RubyGems - ruby-ogre - Versions diffs - 0.0.5-x86-linux → 0.1.0-x86-linux - Mend

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

Files changed (1620) hide show

data/deps/include/OGRE/OgreGpuProgramManager.h DELETED

@@ -1,262 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __GpuProgramManager_H_
-#define __GpuProgramManager_H_
-// Precompiler options
-#include "OgrePrerequisites.h"
-#include "OgreResourceManager.h"
-#include "OgreException.h"
-#include "OgreGpuProgram.h"
-#include "OgreSingleton.h"
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Resources
-	*  @{
-	*/
-	class _OgreExport GpuProgramManager : public ResourceManager, public Singleton<GpuProgramManager>
-	{
-	public:
-		typedef set<String>::type SyntaxCodes;
-		typedef map<String, GpuSharedParametersPtr>::type SharedParametersMap;
-		typedef MemoryDataStreamPtr Microcode;
-		typedef map<String, Microcode>::type MicrocodeMap;
-	protected:
-		SharedParametersMap mSharedParametersMap;
-		MicrocodeMap mMicrocodeCache;
-		bool mSaveMicrocodesToCache;
-		static String addRenderSystemToName( const String &  name );
-        /// Specialised create method with specific parameters
-        virtual Resource* createImpl(const String& name, ResourceHandle handle,
-            const String& group, bool isManual, ManualResourceLoader* loader,
-            GpuProgramType gptype, const String& syntaxCode) = 0;
-	public:
-		GpuProgramManager();
-		virtual ~GpuProgramManager();
-        /** Loads a GPU program from a file of assembly.
-		@remarks
-			This method creates a new program of the type specified as the second parameter.
-			As with all types of ResourceManager, this class will search for the file in
-			all resource locations it has been configured to look in.
-		@param name The name of the GpuProgram
-		@param groupName The name of the resource group
-		@param filename The file to load
-		@param gptype The type of program to create
-        @param syntaxCode The name of the syntax to be used for this program e.g. arbvp1, vs_1_1
-		*/
-		virtual GpuProgramPtr load(const String& name, const String& groupName,
-			const String& filename, GpuProgramType gptype,
-            const String& syntaxCode);
-		/** Loads a GPU program from a string of assembly code.
-		@remarks
-			The assembly code must be compatible with this manager - call the
-			getSupportedSyntax method for details of the supported syntaxes
-		@param name The identifying name to give this program, which can be used to
-			retrieve this program later with getByName.
-		@param groupName The name of the resource group
-		@param code A string of assembly code which will form the program to run
-		@param gptype The type of program to create.
-        @param syntaxCode The name of the syntax to be used for this program e.g. arbvp1, vs_1_1
-		*/
-		virtual GpuProgramPtr loadFromString(const String& name, const String& groupName,
-			const String& code, GpuProgramType gptype,
-            const String& syntaxCode);
-		/** Returns the syntaxes that this manager supports. */
-		virtual const SyntaxCodes& getSupportedSyntax(void) const;
-        /** Returns whether a given syntax code (e.g. "ps_1_3", "fp20", "arbvp1") is supported. */
-        virtual bool isSyntaxSupported(const String& syntaxCode) const;
-		/** Creates a new GpuProgramParameters instance which can be used to bind
-            parameters to your programs.
-        @remarks
-            Program parameters can be shared between multiple programs if you wish.
-        */
-        virtual GpuProgramParametersSharedPtr createParameters(void);
-        /** Create a new, unloaded GpuProgram from a file of assembly.
-        @remarks
-            Use this method in preference to the 'load' methods if you wish to define
-            a GpuProgram, but not load it yet; useful for saving memory.
-		@par
-			This method creates a new program of the type specified as the second parameter.
-			As with all types of ResourceManager, this class will search for the file in
-			all resource locations it has been configured to look in.
-		@param name The name of the program
-		@param groupName The name of the resource group
-		@param filename The file to load
-        @param syntaxCode The name of the syntax to be used for this program e.g. arbvp1, vs_1_1
-		@param gptype The type of program to create
-		*/
-		virtual GpuProgramPtr createProgram(const String& name,
-			const String& groupName, const String& filename,
-			GpuProgramType gptype, const String& syntaxCode);
-		/** Create a GPU program from a string of assembly code.
-        @remarks
-            Use this method in preference to the 'load' methods if you wish to define
-            a GpuProgram, but not load it yet; useful for saving memory.
-		@par
-			The assembly code must be compatible with this manager - call the
-			getSupportedSyntax method for details of the supported syntaxes
-		@param name The identifying name to give this program, which can be used to
-			retrieve this program later with getByName.
-		@param groupName The name of the resource group
-		@param code A string of assembly code which will form the program to run
-		@param gptype The type of program to create.
-        @param syntaxCode The name of the syntax to be used for this program e.g. arbvp1, vs_1_1
-		*/
-		virtual GpuProgramPtr createProgramFromString(const String& name,
-			const String& groupName, const String& code,
-            GpuProgramType gptype, const String& syntaxCode);
-        /** General create method, using specific create parameters
-            instead of name / value pairs.
-        */
-        virtual ResourcePtr create(const String& name, const String& group,
-            GpuProgramType gptype, const String& syntaxCode, bool isManual = false,
-            ManualResourceLoader* loader = 0);
-        /** Overrides the standard ResourceManager getByName method.
-        @param name The name of the program to retrieve
-        @param preferHighLevelPrograms If set to true (the default), high level programs will be
-            returned in preference to low-level programs.
-        */
-        ResourcePtr getByName(const String& name, bool preferHighLevelPrograms = true);
-		/** Create a new set of shared parameters, which can be used across many
-			GpuProgramParameters objects of different structures.
-		@param name The name to give the shared parameters so you can refer to them
-			later.
-		*/
-		virtual GpuSharedParametersPtr createSharedParameters(const String& name);
-		/** Retrieve a set of shared parameters, which can be used across many
-		GpuProgramParameters objects of different structures.
-		*/
-		virtual GpuSharedParametersPtr getSharedParameters(const String& name) const;
-		/** Get (const) access to the available shared parameter sets.
-		*/
-		virtual const SharedParametersMap& getAvailableSharedParameters() const;
-        /** Get if the microcode of a shader should be saved to a cache
-        */
-		bool getSaveMicrocodesToCache();
-        /** Set if the microcode of a shader should be saved to a cache
-        */
-		void setSaveMicrocodesToCache( const bool val );
-		bool canGetCompiledShaderBuffer();
-        /** Check if a microcode is available for a program in the microcode cache.
-        @param name The name of the program.
-        */
-		virtual bool isMicrocodeAvailableInCache( const String & name ) const;
-        /** Returns a microcode for a program from the microcode cache.
-        @param name The name of the program.
-        */
-		virtual const Microcode & getMicrocodeFromCache( const String & name ) const;
-        /** Creates a microcode to be later added to the cache.
-		@param size The size of the microcode in bytes
-        */
-		virtual Microcode createMicrocode( const size_t size ) const;
-        /** Adds a microcode for a program to the microcode cache.
-        @param name The name of the program.
-        */
-		virtual void addMicrocodeToCache( const String & name, const Microcode & microcode );
-        /** Saves the microcode cache to disk.
-        @param stream The destination stream
-        */
-		virtual void saveMicrocodeCache( DataStreamPtr stream ) const;
-        /** Loads the microcode cache from disk.
-        @param stream The source stream
-        */
-		virtual void loadMicrocodeCache( DataStreamPtr stream );
-        /** Override standard Singleton retrieval.
-        @remarks
-        Why do we do this? Well, it's because the Singleton
-        implementation is in a .h file, which means it gets compiled
-        into anybody who includes it. This is needed for the
-        Singleton template to work, but we actually only want it
-        compiled into the implementation of the class based on the
-        Singleton, not all of them. If we don't change this, we get
-        link errors when trying to use the Singleton-based class from
-        an outside dll.
-        @par
-        This method just delegates to the template version anyway,
-        but the implementation stays in this single compilation unit,
-        preventing link errors.
-        */
-        static GpuProgramManager& getSingleton(void);
-        /** Override standard Singleton retrieval.
-        @remarks
-        Why do we do this? Well, it's because the Singleton
-        implementation is in a .h file, which means it gets compiled
-        into anybody who includes it. This is needed for the
-        Singleton template to work, but we actually only want it
-        compiled into the implementation of the class based on the
-        Singleton, not all of them. If we don't change this, we get
-        link errors when trying to use the Singleton-based class from
-        an outside dll.
-        @par
-        This method just delegates to the template version anyway,
-        but the implementation stays in this single compilation unit,
-        preventing link errors.
-        */
-        static GpuProgramManager* getSingletonPtr(void);
-	};
-	/** @} */
-	/** @} */
-}
-#endif

data/deps/include/OGRE/OgreGpuProgramParams.h DELETED

@@ -1,1840 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __GpuProgramParams_H_
-#define __GpuProgramParams_H_
-// Precompiler options
-#include "OgrePrerequisites.h"
-#include "OgreSharedPtr.h"
-#include "OgreIteratorWrappers.h"
-#include "OgreSerializer.h"
-#include "OgreRenderOperation.h"
-#include "OgreAny.h"
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Materials
-	*  @{
-	*/
-	/** Enumeration of the types of constant we may encounter in programs.
-	@note Low-level programs, by definition, will always use either
-	float4 or int4 constant types since that is the fundamental underlying
-	type in assembler.
-	*/
-	enum GpuConstantType
-	{
-		GCT_FLOAT1 = 1,
-		GCT_FLOAT2 = 2,
-		GCT_FLOAT3 = 3,
-		GCT_FLOAT4 = 4,
-		GCT_SAMPLER1D = 5,
-		GCT_SAMPLER2D = 6,
-		GCT_SAMPLER3D = 7,
-		GCT_SAMPLERCUBE = 8,
-		GCT_SAMPLER1DSHADOW = 9,
-		GCT_SAMPLER2DSHADOW = 10,
-		GCT_SAMPLER2DARRAY = 11,
-		GCT_MATRIX_2X2 = 12,
-		GCT_MATRIX_2X3 = 13,
-		GCT_MATRIX_2X4 = 14,
-		GCT_MATRIX_3X2 = 15,
-		GCT_MATRIX_3X3 = 16,
-		GCT_MATRIX_3X4 = 17,
-		GCT_MATRIX_4X2 = 18,
-		GCT_MATRIX_4X3 = 19,
-		GCT_MATRIX_4X4 = 20,
-		GCT_INT1 = 21,
-		GCT_INT2 = 22,
-		GCT_INT3 = 23,
-		GCT_INT4 = 24,
-		GCT_UNKNOWN = 99
-	};
-	/** The variability of a GPU parameter, as derived from auto-params targeting it.
-	These values must be powers of two since they are used in masks.
-	*/
-	enum GpuParamVariability
-	{
-		/// No variation except by manual setting - the default
-		GPV_GLOBAL = 1,
-		/// Varies per object (based on an auto param usually), but not per light setup
-		GPV_PER_OBJECT = 2,
-		/// Varies with light setup
-		GPV_LIGHTS = 4,
-		/// Varies with pass iteration number
-		GPV_PASS_ITERATION_NUMBER = 8,
-		/// Full mask (16-bit)
-		GPV_ALL = 0xFFFF
-	};
-	/** Information about predefined program constants.
-	@note Only available for high-level programs but is referenced generically
-	by GpuProgramParameters.
-	*/
-	struct _OgreExport GpuConstantDefinition
-	{
-		/// Data type
-		GpuConstantType constType;
-		/// Physical start index in buffer (either float or int buffer)
-		size_t physicalIndex;
-		/// Logical index - used to communicate this constant to the rendersystem
-		size_t logicalIndex;
-		/** Number of raw buffer slots per element
-		(some programs pack each array element to float4, some do not) */
-		size_t elementSize;
-		/// Length of array
-		size_t arraySize;
-		/// How this parameter varies (bitwise combination of GpuProgramVariability)
-		mutable uint16 variability;
-		bool isFloat() const
-		{
-			return isFloat(constType);
-		}
-		static bool isFloat(GpuConstantType c)
-		{
-			switch(c)
-			{
-			case GCT_INT1:
-			case GCT_INT2:
-			case GCT_INT3:
-			case GCT_INT4:
-			case GCT_SAMPLER1D:
-			case GCT_SAMPLER2D:
-            case GCT_SAMPLER2DARRAY:
-			case GCT_SAMPLER3D:
-			case GCT_SAMPLERCUBE:
-			case GCT_SAMPLER1DSHADOW:
-			case GCT_SAMPLER2DSHADOW:
-				return false;
-			default:
-				return true;
-			};
-		}
-		bool isSampler() const
-		{
-			return isSampler(constType);
-		}
-		static bool isSampler(GpuConstantType c)
-		{
-			switch(c)
-			{
-			case GCT_SAMPLER1D:
-			case GCT_SAMPLER2D:
-            case GCT_SAMPLER2DARRAY:
-			case GCT_SAMPLER3D:
-			case GCT_SAMPLERCUBE:
-			case GCT_SAMPLER1DSHADOW:
-			case GCT_SAMPLER2DSHADOW:
-				return true;
-			default:
-				return false;
-			};
-		}
-		/** Get the element size of a given type, including whether to pad the
-			elements into multiples of 4 (e.g. SM1 and D3D does, GLSL doesn't)
-		*/
-		static size_t getElementSize(GpuConstantType ctype, bool padToMultiplesOf4)
-		{
-			if (padToMultiplesOf4)
-			{
-				switch(ctype)
-				{
-				case GCT_FLOAT1:
-				case GCT_INT1:
-				case GCT_SAMPLER1D:
-				case GCT_SAMPLER2D:
-                case GCT_SAMPLER2DARRAY:
-				case GCT_SAMPLER3D:
-				case GCT_SAMPLERCUBE:
-				case GCT_SAMPLER1DSHADOW:
-				case GCT_SAMPLER2DSHADOW:
-				case GCT_FLOAT2:
-				case GCT_INT2:
-				case GCT_FLOAT3:
-				case GCT_INT3:
-				case GCT_FLOAT4:
-				case GCT_INT4:
-					return 4;
-				case GCT_MATRIX_2X2:
-				case GCT_MATRIX_2X3:
-				case GCT_MATRIX_2X4:
-					return 8; // 2 float4s
-				case GCT_MATRIX_3X2:
-				case GCT_MATRIX_3X3:
-				case GCT_MATRIX_3X4:
-					return 12; // 3 float4s
-				case GCT_MATRIX_4X2:
-				case GCT_MATRIX_4X3:
-				case GCT_MATRIX_4X4:
-					return 16; // 4 float4s
-				default:
-					return 4;
-				};
-			}
-			else
-			{
-				switch(ctype)
-				{
-				case GCT_FLOAT1:
-				case GCT_INT1:
-				case GCT_SAMPLER1D:
-				case GCT_SAMPLER2D:
-                case GCT_SAMPLER2DARRAY:
-				case GCT_SAMPLER3D:
-				case GCT_SAMPLERCUBE:
-				case GCT_SAMPLER1DSHADOW:
-				case GCT_SAMPLER2DSHADOW:
-					return 1;
-				case GCT_FLOAT2:
-				case GCT_INT2:
-					return 2;
-				case GCT_FLOAT3:
-				case GCT_INT3:
-					return 3;
-				case GCT_FLOAT4:
-				case GCT_INT4:
-					return 4;
-				case GCT_MATRIX_2X2:
-					return 4;
-				case GCT_MATRIX_2X3:
-				case GCT_MATRIX_3X2:
-					return 6;
-				case GCT_MATRIX_2X4:
-				case GCT_MATRIX_4X2:
-					return 8;
-				case GCT_MATRIX_3X3:
-					return 9;
-				case GCT_MATRIX_3X4:
-				case GCT_MATRIX_4X3:
-					return 12;
-				case GCT_MATRIX_4X4:
-					return 16;
-				default:
-					return 4;
-				};
-			}
-		}
-		GpuConstantDefinition()
-			: constType(GCT_UNKNOWN)
-			, physicalIndex((std::numeric_limits<size_t>::max)())
-            , logicalIndex(0)
-			, elementSize(0)
-			, arraySize(1)
-			, variability(GPV_GLOBAL) {}
-	};
-	typedef map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap;
-	typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator;
-	/// Struct collecting together the information for named constants.
-	struct _OgreExport GpuNamedConstants : public GpuParamsAlloc
-	{
-		/// Total size of the float buffer required
-		size_t floatBufferSize;
-		/// Total size of the int buffer required
-		size_t intBufferSize;
-		/// Map of parameter names to GpuConstantDefinition
-		GpuConstantDefinitionMap map;
-		GpuNamedConstants() : floatBufferSize(0), intBufferSize(0) {}
-		/** Generate additional constant entries for arrays based on a base definition.
-		@remarks
-		Array uniforms will be added just with their base name with no array
-		suffix. This method will add named entries for array suffixes too
-		so individual array entries can be addressed. Note that we only
-		individually index array elements if the array size is up to 16
-		entries in size. Anything larger than that only gets a [0] entry
-		as well as the main entry, to save cluttering up the name map. After
-		all, you can address the larger arrays in a bulk fashion much more
-		easily anyway.
-		*/
-		void generateConstantDefinitionArrayEntries(const String& paramName,
-			const GpuConstantDefinition& baseDef);
-		/// Indicates whether all array entries will be generated and added to the definitions map
-		static bool getGenerateAllConstantDefinitionArrayEntries();
-		/** Sets whether all array entries will be generated and added to the definitions map.
-		@remarks
-		Usually, array entries can only be individually indexed if they're up to 16 entries long,
-		to save memory - arrays larger than that can be set but only via the bulk setting
-		methods. This option allows you to choose to individually index every array entry.
-		*/
-		static void setGenerateAllConstantDefinitionArrayEntries(bool generateAll);
-		/** Saves constant definitions to a file, compatible with GpuProgram::setManualNamedConstantsFile.
-		@see GpuProgram::setManualNamedConstantsFile
-		*/
-		void save(const String& filename) const;
-		/** Loads constant definitions from a stream, compatible with GpuProgram::setManualNamedConstantsFile.
-		@see GpuProgram::setManualNamedConstantsFile
-		*/
-		void load(DataStreamPtr& stream);
-	protected:
-		/** Indicates whether all array entries will be generated and added to the definitions map
-		@remarks
-		Normally, the number of array entries added to the definitions map is capped at 16
-		to save memory. Setting this value to <code>true</code> allows all of the entries
-		to be generated and added to the map.
-		*/
-		static bool msGenerateAllConstantDefinitionArrayEntries;
-	};
-	typedef SharedPtr<GpuNamedConstants> GpuNamedConstantsPtr;
-	/// Simple class for loading / saving GpuNamedConstants
-	class _OgreExport GpuNamedConstantsSerializer : public Serializer
-	{
-	public:
-		GpuNamedConstantsSerializer();
-		virtual ~GpuNamedConstantsSerializer();
-		void exportNamedConstants(const GpuNamedConstants* pConsts, const String& filename,
-			Endian endianMode = ENDIAN_NATIVE);
-		void exportNamedConstants(const GpuNamedConstants* pConsts, DataStreamPtr stream,
-			Endian endianMode = ENDIAN_NATIVE);
-		void importNamedConstants(DataStreamPtr& stream, GpuNamedConstants* pDest);
-	};
-	/** Structure recording the use of a physical buffer by a logical parameter
-	index. Only used for low-level programs.
-	*/
-	struct _OgreExport GpuLogicalIndexUse
-	{
-		/// Physical buffer index
-		size_t physicalIndex;
-		/// Current physical size allocation
-		size_t currentSize;
-		/// How the contents of this slot vary
-		mutable uint16 variability;
-		GpuLogicalIndexUse()
-			: physicalIndex(99999), currentSize(0), variability(GPV_GLOBAL) {}
-		GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v)
-			: physicalIndex(bufIdx), currentSize(curSz), variability(v) {}
-	};
-	typedef map<size_t, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap;
-	/// Container struct to allow params to safely & update shared list of logical buffer assignments
-	struct _OgreExport GpuLogicalBufferStruct : public GpuParamsAlloc
-	{
-		OGRE_MUTEX(mutex)
-			/// Map from logical index to physical buffer location
-			GpuLogicalIndexUseMap map;
-		/// Shortcut to know the buffer size needs
-		size_t bufferSize;
-		GpuLogicalBufferStruct() : bufferSize(0) {}
-	};
-	typedef SharedPtr<GpuLogicalBufferStruct> GpuLogicalBufferStructPtr;
-	/** Definition of container that holds the current float constants.
-	@note Not necessarily in direct index order to constant indexes, logical
-	to physical index map is derived from GpuProgram
-	*/
-	typedef vector<float>::type FloatConstantList;
-	/** Definition of container that holds the current float constants.
-	@note Not necessarily in direct index order to constant indexes, logical
-	to physical index map is derived from GpuProgram
-	*/
-	typedef vector<int>::type IntConstantList;
-	/** A group of manually updated parameters that are shared between many parameter sets.
-	@remarks
-		Sometimes you want to set some common parameters across many otherwise
-		different parameter sets, and keep them all in sync together. This class
-		allows you to define a set of parameters that you can share across many
-		parameter sets and have the parameters that match automatically be pulled
-		from the shared set, rather than you having to set them on all the parameter
-		sets individually.
-	@par
-		Parameters in a shared set are matched up with instances in a GpuProgramParameters
-		structure by matching names. It is up to you to define the named parameters
-		that a shared set contains, and ensuring the definition matches.
-	@note
-		Shared parameter sets can be named, and looked up using the GpuProgramManager.
-	*/
-	class _OgreExport GpuSharedParameters : public GpuParamsAlloc
-	{
-	protected:
-		GpuNamedConstants mNamedConstants;
-		FloatConstantList mFloatConstants;
-		IntConstantList mIntConstants;
-		String mName;
-		// Optional data the rendersystem might want to store
-		mutable Any mRenderSystemData;
-		/// Not used when copying data, but might be useful to RS using shared buffers
-		size_t mFrameLastUpdated;
-		/// Version number of the definitions in this buffer
-		unsigned long mVersion;
-	public:
-		GpuSharedParameters(const String& name);
-		virtual ~GpuSharedParameters();
-		/// Get the name of this shared parameter set
-		const String& getName() { return mName; }
-		/** Add a new constant definition to this shared set of parameters.
-		@remarks
-			Unlike GpuProgramParameters, where the parameter list is defined by the
-			program being compiled, this shared parameter set is defined by the
-			user. Only parameters which have been predefined here may be later
-			updated.
-		*/
-		void addConstantDefinition(const String& name, GpuConstantType constType, size_t arraySize = 1);
-		/** Remove a constant definition from this shared set of parameters.
-		*/
-		void removeConstantDefinition(const String& name);
-		/** Remove a constant definition from this shared set of parameters.
-		*/
-		void removeAllConstantDefinitions();
-		/** Get the version number of this shared parameter set, can be used to identify when
-			changes have occurred.
-		*/
-		unsigned long getVersion() const { return mVersion; }
-		/** Mark the shared set as being dirty (values modified).
-		@remarks
-		You do not need to call this yourself, set is marked as dirty whenever
-		setNamedConstant or (non const) getFloatPointer et al are called.
-		*/
-		void _markDirty();
-		/// Get the frame in which this shared parameter set was last updated
-		size_t getFrameLastUpdated() const { return mFrameLastUpdated; }
-		/** Gets an iterator over the named GpuConstantDefinition instances as defined
-			by the user.
-		*/
-		GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;
-		/** Get a specific GpuConstantDefinition for a named parameter.
-		*/
-		const GpuConstantDefinition& getConstantDefinition(const String& name) const;
-		/** Get the full list of GpuConstantDefinition instances.
-		*/
-		const GpuNamedConstants& getConstantDefinitions() const;
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, Real val);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, int val);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const Vector4& vec);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const Vector3& vec);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const Matrix4& m);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const float *val, size_t count);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const double *val, size_t count);
-			/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const ColourValue& colour);
-		/** @copydoc GpuProgramParameters::setNamedConstant */
-		void setNamedConstant(const String& name, const int *val, size_t count);
-		/// Get a pointer to the 'nth' item in the float buffer
-		float* getFloatPointer(size_t pos) { _markDirty(); return &mFloatConstants[pos]; }
-		/// Get a pointer to the 'nth' item in the float buffer
-		const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
-		/// Get a pointer to the 'nth' item in the int buffer
-		int* getIntPointer(size_t pos) { _markDirty(); return &mIntConstants[pos]; }
-		/// Get a pointer to the 'nth' item in the int buffer
-		const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
-		/** Internal method that the RenderSystem might use to store optional data. */
-		void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
-		/** Internal method that the RenderSystem might use to store optional data. */
-		const Any& _getRenderSystemData() const { return mRenderSystemData; }
-	};
-	/// Shared pointer used to hold references to GpuProgramParameters instances
-	typedef SharedPtr<GpuSharedParameters> GpuSharedParametersPtr;
-	class GpuProgramParameters;
-	/** This class records the usage of a set of shared parameters in a concrete
-		set of GpuProgramParameters.
-	*/
-	class _OgreExport GpuSharedParametersUsage : public GpuParamsAlloc
-	{
-	protected:
-		GpuSharedParametersPtr mSharedParams;
-		// Not a shared pointer since this is also parent
-		GpuProgramParameters* mParams;
-		// list of physical mappings that we are going to bring in
-		struct CopyDataEntry
-		{
-			const GpuConstantDefinition* srcDefinition;
-			const GpuConstantDefinition* dstDefinition;
-		};
-		typedef vector<CopyDataEntry>::type CopyDataList;
-		CopyDataList mCopyDataList;
-		// Optional data the rendersystem might want to store
-		mutable Any mRenderSystemData;
-		/// Version of shared params we based the copydata on
-		unsigned long mCopyDataVersion;
-		void initCopyData();
-	public:
-		/// Construct usage
-		GpuSharedParametersUsage(GpuSharedParametersPtr sharedParams,
-			GpuProgramParameters* params);
-		/** Update the target parameters by copying the data from the shared
-			parameters.
-		@note This method  may not actually be called if the RenderSystem
-			supports using shared parameters directly in their own shared buffer; in
-			which case the values should not be copied out of the shared area
-			into the individual parameter set, but bound separately.
-		*/
-		void _copySharedParamsToTargetParams();
-		/// Get the name of the shared parameter set
-		const String& getName() const { return mSharedParams->getName(); }
-		GpuSharedParametersPtr getSharedParams() const { return mSharedParams; }
-		GpuProgramParameters* getTargetParams() const { return mParams; }
-		/** Internal method that the RenderSystem might use to store optional data. */
-		void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
-		/** Internal method that the RenderSystem might use to store optional data. */
-		const Any& _getRenderSystemData() const { return mRenderSystemData; }
-	};
-	/** Collects together the program parameters used for a GpuProgram.
-	@remarks
-	Gpu program state includes constant parameters used by the program, and
-	bindings to render system state which is propagated into the constants
-	by the engine automatically if requested.
-	@par
-	GpuProgramParameters objects should be created through the GpuProgram and
-	may be shared between multiple Pass instances. For this reason they
-	are managed using a shared pointer, which will ensure they are automatically
-	deleted when no Pass is using them anymore.
-	@par
-	High-level programs use named parameters (uniforms), low-level programs
-	use indexed constants. This class supports both, but you can tell whether
-	named constants are supported by calling hasNamedParameters(). There are
-	references in the documentation below to 'logical' and 'physical' indexes;
-	logical indexes are the indexes used by low-level programs and represent
-	indexes into an array of float4's, some of which may be settable, some of
-	which may be predefined constants in the program. We only store those
-	constants which have actually been set, therefore our buffer could have
-	gaps if we used the logical indexes in our own buffers. So instead we map
-	these logical indexes to physical indexes in our buffer. When using
-	high-level programs, logical indexes don't necessarily exist, although they
-	might if the high-level program has a direct, exposed mapping from parameter
-	names to logical indexes. In addition, high-level languages may or may not pack
-	arrays of elements that are smaller than float4 (e.g. float2/vec2) contiguously.
-	This kind of information is held in the ConstantDefinition structure which
-	is only populated for high-level programs. You don't have to worry about
-	any of this unless you intend to read parameters back from this structure
-	rather than just setting them.
-	*/
-	class _OgreExport GpuProgramParameters : public GpuParamsAlloc
-	{
-	public:
-		/** Defines the types of automatically updated values that may be bound to GpuProgram
-		parameters, or used to modify parameters on a per-object basis.
-		*/
-		enum AutoConstantType
-		{
-			/// The current world matrix
-			ACT_WORLD_MATRIX,
-			/// The current world matrix, inverted
-			ACT_INVERSE_WORLD_MATRIX,
-			/** Provides transpose of world matrix.
-			Equivalent to RenderMonkey's "WorldTranspose".
-			*/
-			ACT_TRANSPOSE_WORLD_MATRIX,
-			/// The current world matrix, inverted & transposed
-			ACT_INVERSE_TRANSPOSE_WORLD_MATRIX,
-			/// The current array of world matrices, as a 3x4 matrix, used for blending
-			ACT_WORLD_MATRIX_ARRAY_3x4,
-			/// The current array of world matrices, used for blending
-			ACT_WORLD_MATRIX_ARRAY,
-			/// The current array of world matrices transformed to an array of dual quaternions, represented as a 2x4 matrix
-			ACT_WORLD_DUALQUATERNION_ARRAY_2x4,
-			/// The scale and shear components of the current array of world matrices
-			ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4,
-			/// The current view matrix
-			ACT_VIEW_MATRIX,
-			/// The current view matrix, inverted
-			ACT_INVERSE_VIEW_MATRIX,
-			/** Provides transpose of view matrix.
-			Equivalent to RenderMonkey's "ViewTranspose".
-			*/
-			ACT_TRANSPOSE_VIEW_MATRIX,
-			/** Provides inverse transpose of view matrix.
-			Equivalent to RenderMonkey's "ViewInverseTranspose".
-			*/
-			ACT_INVERSE_TRANSPOSE_VIEW_MATRIX,
-			/// The current projection matrix
-			ACT_PROJECTION_MATRIX,
-			/** Provides inverse of projection matrix.
-			Equivalent to RenderMonkey's "ProjectionInverse".
-			*/
-			ACT_INVERSE_PROJECTION_MATRIX,
-			/** Provides transpose of projection matrix.
-			Equivalent to RenderMonkey's "ProjectionTranspose".
-			*/
-			ACT_TRANSPOSE_PROJECTION_MATRIX,
-			/** Provides inverse transpose of projection matrix.
-			Equivalent to RenderMonkey's "ProjectionInverseTranspose".
-			*/
-			ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX,
-			/// The current view & projection matrices concatenated
-			ACT_VIEWPROJ_MATRIX,
-			/** Provides inverse of concatenated view and projection matrices.
-			Equivalent to RenderMonkey's "ViewProjectionInverse".
-			*/
-			ACT_INVERSE_VIEWPROJ_MATRIX,
-			/** Provides transpose of concatenated view and projection matrices.
-			Equivalent to RenderMonkey's "ViewProjectionTranspose".
-			*/
-			ACT_TRANSPOSE_VIEWPROJ_MATRIX,
-			/** Provides inverse transpose of concatenated view and projection matrices.
-			Equivalent to RenderMonkey's "ViewProjectionInverseTranspose".
-			*/
-			ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX,
-			/// The current world & view matrices concatenated
-			ACT_WORLDVIEW_MATRIX,
-			/// The current world & view matrices concatenated, then inverted
-			ACT_INVERSE_WORLDVIEW_MATRIX,
-			/** Provides transpose of concatenated world and view matrices.
-			Equivalent to RenderMonkey's "WorldViewTranspose".
-			*/
-			ACT_TRANSPOSE_WORLDVIEW_MATRIX,
-			/// The current world & view matrices concatenated, then inverted & transposed
-			ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX,
-			/// view matrices.
-			/// The current world, view & projection matrices concatenated
-			ACT_WORLDVIEWPROJ_MATRIX,
-			/** Provides inverse of concatenated world, view and projection matrices.
-			Equivalent to RenderMonkey's "WorldViewProjectionInverse".
-			*/
-			ACT_INVERSE_WORLDVIEWPROJ_MATRIX,
-			/** Provides transpose of concatenated world, view and projection matrices.
-			Equivalent to RenderMonkey's "WorldViewProjectionTranspose".
-			*/
-			ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
-			/** Provides inverse transpose of concatenated world, view and projection
-			matrices. Equivalent to RenderMonkey's "WorldViewProjectionInverseTranspose".
-			*/
-			ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
-			/// render target related values
-			/** -1 if requires texture flipping, +1 otherwise. It's useful when you bypassed
-			projection matrix transform, still able use this value to adjust transformed y position.
-			*/
-			ACT_RENDER_TARGET_FLIPPING,
-			/** -1 if the winding has been inverted (e.g. for reflections), +1 otherwise.
-			*/
-			ACT_VERTEX_WINDING,
-			/// Fog colour
-			ACT_FOG_COLOUR,
-			/// Fog params: density, linear start, linear end, 1/(end-start)
-			ACT_FOG_PARAMS,
-			/// Surface ambient colour, as set in Pass::setAmbient
-			ACT_SURFACE_AMBIENT_COLOUR,
-			/// Surface diffuse colour, as set in Pass::setDiffuse
-			ACT_SURFACE_DIFFUSE_COLOUR,
-			/// Surface specular colour, as set in Pass::setSpecular
-			ACT_SURFACE_SPECULAR_COLOUR,
-			/// Surface emissive colour, as set in Pass::setSelfIllumination
-			ACT_SURFACE_EMISSIVE_COLOUR,
-			/// Surface shininess, as set in Pass::setShininess
-			ACT_SURFACE_SHININESS,
-			/// The number of active light sources (better than gl_MaxLights)
-			ACT_LIGHT_COUNT,
-			/// The ambient light colour set in the scene
-			ACT_AMBIENT_LIGHT_COLOUR,
-			/// Light diffuse colour (index determined by setAutoConstant call)
-			ACT_LIGHT_DIFFUSE_COLOUR,
-			/// Light specular colour (index determined by setAutoConstant call)
-			ACT_LIGHT_SPECULAR_COLOUR,
-			/// Light attenuation parameters, Vector4(range, constant, linear, quadric)
-			ACT_LIGHT_ATTENUATION,
-			/** Spotlight parameters, Vector4(innerFactor, outerFactor, falloff, isSpot)
-			innerFactor and outerFactor are cos(angle/2)
-			The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.
-			Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively
-			*/
-			ACT_SPOTLIGHT_PARAMS,
-			/// A light position in world space (index determined by setAutoConstant call)
-			ACT_LIGHT_POSITION,
-			/// A light position in object space (index determined by setAutoConstant call)
-			ACT_LIGHT_POSITION_OBJECT_SPACE,
-			/// A light position in view space (index determined by setAutoConstant call)
-			ACT_LIGHT_POSITION_VIEW_SPACE,
-			/// A light direction in world space (index determined by setAutoConstant call)
-			ACT_LIGHT_DIRECTION,
-			/// A light direction in object space (index determined by setAutoConstant call)
-			ACT_LIGHT_DIRECTION_OBJECT_SPACE,
-			/// A light direction in view space (index determined by setAutoConstant call)
-			ACT_LIGHT_DIRECTION_VIEW_SPACE,
-			/** The distance of the light from the center of the object
-			a useful approximation as an alternative to per-vertex distance
-			calculations.
-			*/
-			ACT_LIGHT_DISTANCE_OBJECT_SPACE,
-			/** Light power level, a single scalar as set in Light::setPowerScale  (index determined by setAutoConstant call) */
-			ACT_LIGHT_POWER_SCALE,
-			/// Light diffuse colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call)
-			ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED,
-			/// Light specular colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call)
-			ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED,
-			/// Array of light diffuse colours (count set by extra param)
-			ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,
-			/// Array of light specular colours (count set by extra param)
-			ACT_LIGHT_SPECULAR_COLOUR_ARRAY,
-			/// Array of light diffuse colours scaled by light power (count set by extra param)
-			ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY,
-			/// Array of light specular colours scaled by light power (count set by extra param)
-			ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY,
-			/// Array of light attenuation parameters, Vector4(range, constant, linear, quadric) (count set by extra param)
-			ACT_LIGHT_ATTENUATION_ARRAY,
-			/// Array of light positions in world space (count set by extra param)
-			ACT_LIGHT_POSITION_ARRAY,
-			/// Array of light positions in object space (count set by extra param)
-			ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,
-			/// Array of light positions in view space (count set by extra param)
-			ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY,
-			/// Array of light directions in world space (count set by extra param)
-			ACT_LIGHT_DIRECTION_ARRAY,
-			/// Array of light directions in object space (count set by extra param)
-			ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY,
-			/// Array of light directions in view space (count set by extra param)
-			ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,
-			/** Array of distances of the lights from the center of the object
-			a useful approximation as an alternative to per-vertex distance
-			calculations. (count set by extra param)
-			*/
-			ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY,
-			/** Array of light power levels, a single scalar as set in Light::setPowerScale
-			(count set by extra param)
-			*/
-			ACT_LIGHT_POWER_SCALE_ARRAY,
-			/** Spotlight parameters array of Vector4(innerFactor, outerFactor, falloff, isSpot)
-			innerFactor and outerFactor are cos(angle/2)
-			The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.
-			Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively.
-			(count set by extra param)
-			*/
-			ACT_SPOTLIGHT_PARAMS_ARRAY,
-			/** The derived ambient light colour, with 'r', 'g', 'b' components filled with
-			product of surface ambient colour and ambient light colour, respectively,
-			and 'a' component filled with surface ambient alpha component.
-			*/
-			ACT_DERIVED_AMBIENT_LIGHT_COLOUR,
-			/** The derived scene colour, with 'r', 'g' and 'b' components filled with sum
-			of derived ambient light colour and surface emissive colour, respectively,
-			and 'a' component filled with surface diffuse alpha component.
-			*/
-			ACT_DERIVED_SCENE_COLOUR,
-			/** The derived light diffuse colour (index determined by setAutoConstant call),
-			with 'r', 'g' and 'b' components filled with product of surface diffuse colour,
-			light power scale and light diffuse colour, respectively, and 'a' component filled with surface
-			diffuse alpha component.
-			*/
-			ACT_DERIVED_LIGHT_DIFFUSE_COLOUR,
-			/** The derived light specular colour (index determined by setAutoConstant call),
-			with 'r', 'g' and 'b' components filled with product of surface specular colour
-			and light specular colour, respectively, and 'a' component filled with surface
-			specular alpha component.
-			*/
-			ACT_DERIVED_LIGHT_SPECULAR_COLOUR,
-			/// Array of derived light diffuse colours (count set by extra param)
-			ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,
-			/// Array of derived light specular colours (count set by extra param)
-			ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY,
-			/** The absolute light number of a local light index. Each pass may have
-			a number of lights passed to it, and each of these lights will have
-			an index in the overall light list, which will differ from the local
-			light index due to factors like setStartLight and setIteratePerLight.
-			This binding provides the global light index for a local index.
-			*/
-			ACT_LIGHT_NUMBER,
-			/// Returns (int) 1 if the  given light casts shadows, 0 otherwise (index set in extra param)
-			ACT_LIGHT_CASTS_SHADOWS,
-			/** The distance a shadow volume should be extruded when using
-			finite extrusion programs.
-			*/
-			ACT_SHADOW_EXTRUSION_DISTANCE,
-			/// The current camera's position in world space
-			ACT_CAMERA_POSITION,
-			/// The current camera's position in object space
-			ACT_CAMERA_POSITION_OBJECT_SPACE,
-			/// The view/projection matrix of the assigned texture projection frustum
-			ACT_TEXTURE_VIEWPROJ_MATRIX,
-			/// Array of view/projection matrices of the first n texture projection frustums
-			ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY,
-			/** The view/projection matrix of the assigned texture projection frustum,
-			combined with the current world matrix
-			*/
-			ACT_TEXTURE_WORLDVIEWPROJ_MATRIX,
-			/// Array of world/view/projection matrices of the first n texture projection frustums
-			ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY,
-			/// The view/projection matrix of a given spotlight
-			ACT_SPOTLIGHT_VIEWPROJ_MATRIX,
-			/// Array of view/projection matrix of a given spotlight
-			ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY,
-			/** The view/projection matrix of a given spotlight projection frustum,
-			combined with the current world matrix
-			*/
-			ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX,
-			/// A custom parameter which will come from the renderable, using 'data' as the identifier
-			ACT_CUSTOM,
-			/** provides current elapsed time
-			*/
-			ACT_TIME,
-			/** Single float value, which repeats itself based on given as
-			parameter "cycle time". Equivalent to RenderMonkey's "Time0_X".
-			*/
-			ACT_TIME_0_X,
-			/// Cosine of "Time0_X". Equivalent to RenderMonkey's "CosTime0_X".
-			ACT_COSTIME_0_X,
-			/// Sine of "Time0_X". Equivalent to RenderMonkey's "SinTime0_X".
-			ACT_SINTIME_0_X,
-			/// Tangent of "Time0_X". Equivalent to RenderMonkey's "TanTime0_X".
-			ACT_TANTIME_0_X,
-			/** Vector of "Time0_X", "SinTime0_X", "CosTime0_X",
-			"TanTime0_X". Equivalent to RenderMonkey's "Time0_X_Packed".
-			*/
-			ACT_TIME_0_X_PACKED,
-			/** Single float value, which represents scaled time value [0..1],
-			which repeats itself based on given as parameter "cycle time".
-			Equivalent to RenderMonkey's "Time0_1".
-			*/
-			ACT_TIME_0_1,
-			/// Cosine of "Time0_1". Equivalent to RenderMonkey's "CosTime0_1".
-			ACT_COSTIME_0_1,
-			/// Sine of "Time0_1". Equivalent to RenderMonkey's "SinTime0_1".
-			ACT_SINTIME_0_1,
-			/// Tangent of "Time0_1". Equivalent to RenderMonkey's "TanTime0_1".
-			ACT_TANTIME_0_1,
-			/** Vector of "Time0_1", "SinTime0_1", "CosTime0_1",
-			"TanTime0_1". Equivalent to RenderMonkey's "Time0_1_Packed".
-			*/
-			ACT_TIME_0_1_PACKED,
-			/**	Single float value, which represents scaled time value [0..2*Pi],
-			which repeats itself based on given as parameter "cycle time".
-			Equivalent to RenderMonkey's "Time0_2PI".
-			*/
-			ACT_TIME_0_2PI,
-			/// Cosine of "Time0_2PI". Equivalent to RenderMonkey's "CosTime0_2PI".
-			ACT_COSTIME_0_2PI,
-			/// Sine of "Time0_2PI". Equivalent to RenderMonkey's "SinTime0_2PI".
-			ACT_SINTIME_0_2PI,
-			/// Tangent of "Time0_2PI". Equivalent to RenderMonkey's "TanTime0_2PI".
-			ACT_TANTIME_0_2PI,
-			/** Vector of "Time0_2PI", "SinTime0_2PI", "CosTime0_2PI",
-			"TanTime0_2PI". Equivalent to RenderMonkey's "Time0_2PI_Packed".
-			*/
-			ACT_TIME_0_2PI_PACKED,
-			/// provides the scaled frame time, returned as a floating point value.
-			ACT_FRAME_TIME,
-			/// provides the calculated frames per second, returned as a floating point value.
-			ACT_FPS,
-			/// viewport-related values
-			/** Current viewport width (in pixels) as floating point value.
-			Equivalent to RenderMonkey's "ViewportWidth".
-			*/
-			ACT_VIEWPORT_WIDTH,
-			/** Current viewport height (in pixels) as floating point value.
-			Equivalent to RenderMonkey's "ViewportHeight".
-			*/
-			ACT_VIEWPORT_HEIGHT,
-			/** This variable represents 1.0/ViewportWidth.
-			Equivalent to RenderMonkey's "ViewportWidthInverse".
-			*/
-			ACT_INVERSE_VIEWPORT_WIDTH,
-			/** This variable represents 1.0/ViewportHeight.
-			Equivalent to RenderMonkey's "ViewportHeightInverse".
-			*/
-			ACT_INVERSE_VIEWPORT_HEIGHT,
-			/** Packed of "ViewportWidth", "ViewportHeight", "ViewportWidthInverse",
-			"ViewportHeightInverse".
-			*/
-			ACT_VIEWPORT_SIZE,
-			/// view parameters
-			/** This variable provides the view direction vector (world space).
-			Equivalent to RenderMonkey's "ViewDirection".
-			*/
-			ACT_VIEW_DIRECTION,
-			/** This variable provides the view side vector (world space).
-			Equivalent to RenderMonkey's "ViewSideVector".
-			*/
-			ACT_VIEW_SIDE_VECTOR,
-			/** This variable provides the view up vector (world space).
-			Equivalent to RenderMonkey's "ViewUpVector".
-			*/
-			ACT_VIEW_UP_VECTOR,
-			/** This variable provides the field of view as a floating point value.
-			Equivalent to RenderMonkey's "FOV".
-			*/
-			ACT_FOV,
-			/**	This variable provides the near clip distance as a floating point value.
-			Equivalent to RenderMonkey's "NearClipPlane".
-			*/
-			ACT_NEAR_CLIP_DISTANCE,
-			/**	This variable provides the far clip distance as a floating point value.
-			Equivalent to RenderMonkey's "FarClipPlane".
-			*/
-			ACT_FAR_CLIP_DISTANCE,
-			/** provides the pass index number within the technique
-			of the active materil.
-			*/
-			ACT_PASS_NUMBER,
-			/** provides the current iteration number of the pass. The iteration
-			number is the number of times the current render operation has
-			been drawn for the active pass.
-			*/
-			ACT_PASS_ITERATION_NUMBER,
-			/** Provides a parametric animation value [0..1], only available
-			where the renderable specifically implements it.
-			*/
-			ACT_ANIMATION_PARAMETRIC,
-			/** Provides the texel offsets required by this rendersystem to map
-			texels to pixels. Packed as
-			float4(absoluteHorizontalOffset, absoluteVerticalOffset,
-			horizontalOffset / viewportWidth, verticalOffset / viewportHeight)
-			*/
-			ACT_TEXEL_OFFSETS,
-			/** Provides information about the depth range of the scene as viewed
-			from the current camera.
-			Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)
-			*/
-			ACT_SCENE_DEPTH_RANGE,
-			/** Provides information about the depth range of the scene as viewed
-			from a given shadow camera. Requires an index parameter which maps
-			to a light index relative to the current light list.
-			Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)
-			*/
-			ACT_SHADOW_SCENE_DEPTH_RANGE,
-			/** Provides the fixed shadow colour as configured via SceneManager::setShadowColour;
-			useful for integrated modulative shadows.
-			*/
-			ACT_SHADOW_COLOUR,
-			/** Provides texture size of the texture unit (index determined by setAutoConstant
-			call). Packed as float4(width, height, depth, 1)
-			*/
-			ACT_TEXTURE_SIZE,
-			/** Provides inverse texture size of the texture unit (index determined by setAutoConstant
-			call). Packed as float4(1 / width, 1 / height, 1 / depth, 1)
-			*/
-			ACT_INVERSE_TEXTURE_SIZE,
-			/** Provides packed texture size of the texture unit (index determined by setAutoConstant
-			call). Packed as float4(width, height, 1 / width, 1 / height)
-			*/
-			ACT_PACKED_TEXTURE_SIZE,
-			/** Provides the current transform matrix of the texture unit (index determined by setAutoConstant
-			call), as seen by the fixed-function pipeline.
-			*/
-			ACT_TEXTURE_MATRIX,
-			/** Provides the position of the LOD camera in world space, allowing you
-			to perform separate LOD calculations in shaders independent of the rendering
-			camera. If there is no separate LOD camera then this is the real camera
-			position. See Camera::setLodCamera.
-			*/
-			ACT_LOD_CAMERA_POSITION,
-			/** Provides the position of the LOD camera in object space, allowing you
-			to perform separate LOD calculations in shaders independent of the rendering
-			camera. If there is no separate LOD camera then this is the real camera
-			position. See Camera::setLodCamera.
-			*/
-			ACT_LOD_CAMERA_POSITION_OBJECT_SPACE,
-			/** Binds custom per-light constants to the shaders. */
-			ACT_LIGHT_CUSTOM
-		};
-		/** Defines the type of the extra data item used by the auto constant.
-		*/
-		enum ACDataType {
-			/// no data is required
-			ACDT_NONE,
-			/// the auto constant requires data of type int
-			ACDT_INT,
-			/// the auto constant requires data of type real
-			ACDT_REAL
-		};
-		/** Defines the base element type of the auto constant
-		*/
-		enum ElementType {
-			ET_INT,
-			ET_REAL
-		};
-		/** Structure defining an auto constant that's available for use in
-		a parameters object.
-		*/
-		struct AutoConstantDefinition
-		{
-			AutoConstantType acType;
-			String name;
-			size_t elementCount;
-			/// The type of the constant in the program
-			ElementType elementType;
-			/// The type of any extra data
-			ACDataType dataType;
-			AutoConstantDefinition(AutoConstantType _acType, const String& _name,
-				size_t _elementCount, ElementType _elementType,
-				ACDataType _dataType)
-				:acType(_acType), name(_name), elementCount(_elementCount),
-				elementType(_elementType), dataType(_dataType)
-			{
-			}
-		};
-		/** Structure recording the use of an automatic parameter. */
-		class AutoConstantEntry
-		{
-		public:
-			/// The type of parameter
-			AutoConstantType paramType;
-			/// The target (physical) constant index
-			size_t physicalIndex;
-			/** The number of elements per individual entry in this constant
-			Used in case people used packed elements smaller than 4 (e.g. GLSL)
-			and bind an auto which is 4-element packed to it */
-			size_t elementCount;
-			/// Additional information to go with the parameter
-			union{
-				size_t data;
-				Real fData;
-			};
-			/// The variability of this parameter (see GpuParamVariability)
-			uint16 variability;
-			AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData,
-				uint16 theVariability, size_t theElemCount = 4)
-				: paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
-				data(theData), variability(theVariability) {}
-			AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData,
-				uint16 theVariability, size_t theElemCount = 4)
-				: paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
-				fData(theData), variability(theVariability) {}
-		};
-		// Auto parameter storage
-		typedef vector<AutoConstantEntry>::type AutoConstantList;
-		typedef vector<GpuSharedParametersUsage>::type GpuSharedParamUsageList;
-	protected:
-		static AutoConstantDefinition AutoConstantDictionary[];
-		/// Packed list of floating-point constants (physical indexing)
-		FloatConstantList mFloatConstants;
-		/// Packed list of integer constants (physical indexing)
-		IntConstantList mIntConstants;
-		/** Logical index to physical index map - for low-level programs
-		or high-level programs which pass params this way. */
-		GpuLogicalBufferStructPtr mFloatLogicalToPhysical;
-		/** Logical index to physical index map - for low-level programs
-		or high-level programs which pass params this way. */
-		GpuLogicalBufferStructPtr mIntLogicalToPhysical;
-		/// Mapping from parameter names to def - high-level programs are expected to populate this
-		GpuNamedConstantsPtr mNamedConstants;
-		/// List of automatically updated parameters
-		AutoConstantList mAutoConstants;
-		/// The combined variability masks of all parameters
-		uint16 mCombinedVariability;
-		/// Do we need to transpose matrices?
-		bool mTransposeMatrices;
-		/// flag to indicate if names not found will be ignored
-		bool mIgnoreMissingParams;
-		/// physical index for active pass iteration parameter real constant entry;
-		size_t mActivePassIterationIndex;
-		/** Gets the low-level structure for a logical index.
-		*/
-		GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
-		/** Gets the physical buffer index associated with a logical int constant index.
-		*/
-		GpuLogicalIndexUse* _getIntConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
-		/// Return the variability for an auto constant
-		uint16 deriveVariability(AutoConstantType act);
-		void copySharedParamSetUsage(const GpuSharedParamUsageList& srcList);
-		GpuSharedParamUsageList mSharedParamSets;
-		// Optional data the rendersystem might want to store
-		mutable Any mRenderSystemData;
-	public:
-		GpuProgramParameters();
-		~GpuProgramParameters() {}
-		/// Copy constructor
-		GpuProgramParameters(const GpuProgramParameters& oth);
-		/// Operator = overload
-		GpuProgramParameters& operator=(const GpuProgramParameters& oth);
-		/** Internal method for providing a link to a name->definition map for parameters. */
-		void _setNamedConstants(const GpuNamedConstantsPtr& constantmap);
-		/** Internal method for providing a link to a logical index->physical index map for parameters. */
-		void _setLogicalIndexes(const GpuLogicalBufferStructPtr& floatIndexMap,
-			const GpuLogicalBufferStructPtr&  intIndexMap);
-		/// Does this parameter set include named parameters?
-		bool hasNamedParameters() const { return !mNamedConstants.isNull(); }
-		/** Does this parameter set include logically indexed parameters?
-		@note Not mutually exclusive with hasNamedParameters since some high-level
-		programs still use logical indexes to set the parameters on the
-		rendersystem.
-		*/
-		bool hasLogicalIndexedParameters() const { return !mFloatLogicalToPhysical.isNull(); }
-		/** Sets a 4-element floating-point parameter to the program.
-		@param index The logical constant index at which to place the parameter
-		(each constant is a 4D float)
-		@param vec The value to set
-		*/
-		void setConstant(size_t index, const Vector4& vec);
-		/** Sets a single floating-point parameter to the program.
-		@note This is actually equivalent to calling
-		setConstant(index Vector4(val, 0, 0, 0)) since all constants are 4D.
-		@param index The logical constant index at which to place the parameter (each constant is
-		a 4D float)
-		@param val The value to set
-		*/
-		void setConstant(size_t index, Real val);
-		/** Sets a 4-element floating-point parameter to the program via Vector3.
-		@param index The logical constant index at which to place the parameter (each constant is
-		a 4D float).
-		Note that since you're passing a Vector3, the last element of the 4-element
-		value will be set to 1 (a homogeneous vector)
-		@param vec The value to set
-		*/
-		void setConstant(size_t index, const Vector3& vec);
-		/** Sets a Matrix4 parameter to the program.
-		@param index The logical constant index at which to place the parameter (each constant is
-		a 4D float).
-		NB since a Matrix4 is 16 floats long, this parameter will take up 4 indexes.
-		@param m The value to set
-		*/
-		void setConstant(size_t index, const Matrix4& m);
-		/** Sets a list of Matrix4 parameters to the program.
-		@param index The logical constant index at which to start placing the parameter (each constant is
-		a 4D float).
-		NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
-		@param m Pointer to an array of matrices to set
-		@param numEntries Number of Matrix4 entries
-		*/
-		void setConstant(size_t index, const Matrix4* m, size_t numEntries);
-		/** Sets a multiple value constant floating-point parameter to the program.
-		@param index The logical constant index at which to start placing parameters (each constant is
-		a 4D float)
-		@param val Pointer to the values to write, must contain 4*count floats
-		@param count The number of groups of 4 floats to write
-		*/
-		void setConstant(size_t index, const float *val, size_t count);
-		/** Sets a multiple value constant floating-point parameter to the program.
-		@param index The logical constant index at which to start placing parameters (each constant is
-		a 4D float)
-		@param val Pointer to the values to write, must contain 4*count floats
-		@param count The number of groups of 4 floats to write
-		*/
-		void setConstant(size_t index, const double *val, size_t count);
-		/** Sets a ColourValue parameter to the program.
-		@param index The logical constant index at which to place the parameter (each constant is
-		a 4D float)
-		@param colour The value to set
-		*/
-		void setConstant(size_t index, const ColourValue& colour);
-		/** Sets a multiple value constant integer parameter to the program.
-		@remarks
-		Different types of GPU programs support different types of constant parameters.
-		For example, it's relatively common to find that vertex programs only support
-		floating point constants, and that fragment programs only support integer (fixed point)
-		parameters. This can vary depending on the program version supported by the
-		graphics card being used. You should consult the documentation for the type of
-		low level program you are using, or alternatively use the methods
-		provided on RenderSystemCapabilities to determine the options.
-		@param index The logical constant index at which to place the parameter (each constant is
-		a 4D integer)
-		@param val Pointer to the values to write, must contain 4*count ints
-		@param count The number of groups of 4 ints to write
-		*/
-		void setConstant(size_t index, const int *val, size_t count);
-		/** Write a series of floating point values into the underlying float
-		constant buffer at the given physical index.
-		@param physicalIndex The buffer position to start writing
-		@param val Pointer to a list of values to write
-		@param count The number of floats to write
-		*/
-		void _writeRawConstants(size_t physicalIndex, const float* val, size_t count);
-		/** Write a series of floating point values into the underlying float
-		constant buffer at the given physical index.
-		@param physicalIndex The buffer position to start writing
-		@param val Pointer to a list of values to write
-		@param count The number of floats to write
-		*/
-		void _writeRawConstants(size_t physicalIndex, const double* val, size_t count);
-		/** Write a series of integer values into the underlying integer
-		constant buffer at the given physical index.
-		@param physicalIndex The buffer position to start writing
-		@param val Pointer to a list of values to write
-		@param count The number of ints to write
-		*/
-		void _writeRawConstants(size_t physicalIndex, const int* val, size_t count);
-		/** Read a series of floating point values from the underlying float
-		constant buffer at the given physical index.
-		@param physicalIndex The buffer position to start reading
-		@param count The number of floats to read
-		@param dest Pointer to a buffer to receive the values
-		*/
-		void _readRawConstants(size_t physicalIndex, size_t count, float* dest);
-		/** Read a series of integer values from the underlying integer
-		constant buffer at the given physical index.
-		@param physicalIndex The buffer position to start reading
-		@param count The number of ints to read
-		@param dest Pointer to a buffer to receive the values
-		*/
-		void _readRawConstants(size_t physicalIndex, size_t count, int* dest);
-		/** Write a 4-element floating-point parameter to the program directly to
-		the underlying constants buffer.
-		@note You can use these methods if you have already derived the physical
-		constant buffer location, for a slight speed improvement over using
-		the named / logical index versions.
-		@param physicalIndex The physical buffer index at which to place the parameter
-		@param vec The value to set
-		@param count The number of floats to write; if for example
-		the uniform constant 'slot' is smaller than a Vector4
-		*/
-		void _writeRawConstant(size_t physicalIndex, const Vector4& vec,
-			size_t count = 4);
-		/** Write a single floating-point parameter to the program.
-		@note You can use these methods if you have already derived the physical
-		constant buffer location, for a slight speed improvement over using
-		the named / logical index versions.
-		@param physicalIndex The physical buffer index at which to place the parameter
-		@param val The value to set
-		*/
-		void _writeRawConstant(size_t physicalIndex, Real val);
-		/** Write a single integer parameter to the program.
-		@note You can use these methods if you have already derived the physical
-		constant buffer location, for a slight speed improvement over using
-		the named / logical index versions.
-		@param physicalIndex The physical buffer index at which to place the parameter
-		@param val The value to set
-		*/
-		void _writeRawConstant(size_t physicalIndex, int val);
-		/** Write a 3-element floating-point parameter to the program via Vector3.
-		@note You can use these methods if you have already derived the physical
-		constant buffer location, for a slight speed improvement over using
-		the named / logical index versions.
-		@param physicalIndex The physical buffer index at which to place the parameter
-		@param vec The value to set
-		*/
-		void _writeRawConstant(size_t physicalIndex, const Vector3& vec);
-		/** Write a Matrix4 parameter to the program.
-		@note You can use these methods if you have already derived the physical
-		constant buffer location, for a slight speed improvement over using
-		the named / logical index versions.
-		@param physicalIndex The physical buffer index at which to place the parameter
-		@param m The value to set
-		@param elementCount actual element count used with shader
-		*/
-		void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount);
-		/** Write a list of Matrix4 parameters to the program.
-		@note You can use these methods if you have already derived the physical
-		constant buffer location, for a slight speed improvement over using
-		the named / logical index versions.
-		@param physicalIndex The physical buffer index at which to place the parameter
-		@param numEntries Number of Matrix4 entries
-		*/
-		void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries);
-		/** Write a ColourValue parameter to the program.
-		@note You can use these methods if you have already derived the physical
-		constant buffer location, for a slight speed improvement over using
-		the named / logical index versions.
-		@param physicalIndex The physical buffer index at which to place the parameter
-		@param colour The value to set
-		@param count The number of floats to write; if for example
-		the uniform constant 'slot' is smaller than a Vector4
-		*/
-		void _writeRawConstant(size_t physicalIndex, const ColourValue& colour,
-			size_t count = 4);
-		/** Gets an iterator over the named GpuConstantDefinition instances as defined
-		by the program for which these parameters exist.
-		@note
-		Only available if this parameters object has named parameters.
-		*/
-		GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;
-		/** Get a specific GpuConstantDefinition for a named parameter.
-		@note
-		Only available if this parameters object has named parameters.
-		*/
-		const GpuConstantDefinition& getConstantDefinition(const String& name) const;
-		/** Get the full list of GpuConstantDefinition instances.
-		@note
-		Only available if this parameters object has named parameters.
-		*/
-		const GpuNamedConstants& getConstantDefinitions() const;
-		/** Get the current list of mappings from low-level logical param indexes
-		to physical buffer locations in the float buffer.
-		@note
-		Only applicable to low-level programs.
-		*/
-		const GpuLogicalBufferStructPtr& getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; }
-		/** Retrieves the logical index relating to a physical index in the float
-		buffer, for programs which support that (low-level programs and
-		high-level programs which use logical parameter indexes).
-		@return std::numeric_limits<size_t>::max() if not found
-		*/
-		size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex);
-		/** Retrieves the logical index relating to a physical index in the int
-		buffer, for programs which support that (low-level programs and
-		high-level programs which use logical parameter indexes).
-		@return std::numeric_limits<size_t>::max() if not found
-		*/
-		size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex);
-		/** Get the current list of mappings from low-level logical param indexes
-		to physical buffer locations in the integer buffer.
-		@note
-		Only applicable to low-level programs.
-		*/
-		const GpuLogicalBufferStructPtr& getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; }
-		/// Get a reference to the list of float constants
-		const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
-		/// Get a pointer to the 'nth' item in the float buffer
-		float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; }
-		/// Get a pointer to the 'nth' item in the float buffer
-		const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
-		/// Get a reference to the list of int constants
-		const IntConstantList& getIntConstantList() const { return mIntConstants; }
-		/// Get a pointer to the 'nth' item in the int buffer
-		int* getIntPointer(size_t pos) { return &mIntConstants[pos]; }
-		/// Get a pointer to the 'nth' item in the int buffer
-		const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
-		/// Get a reference to the list of auto constant bindings
-		const AutoConstantList& getAutoConstantList() const { return mAutoConstants; }
-		/** Sets up a constant which will automatically be updated by the system.
-		@remarks
-		Vertex and fragment programs often need parameters which are to do with the
-		current render state, or particular values which may very well change over time,
-		and often between objects which are being rendered. This feature allows you
-		to set up a certain number of predefined parameter mappings that are kept up to
-		date for you.
-		@param index The location in the constant list to place this updated constant every time
-		it is changed. Note that because of the nature of the types, we know how big the
-		parameter details will be so you don't need to set that like you do for manual constants.
-		@param acType The type of automatic constant to set
-		@param extraInfo If the constant type needs more information (like a light index) put it here.
-		*/
-		void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0);
-		void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData);
-		/** Sets up a constant which will automatically be updated by the system.
-		@remarks
-		Vertex and fragment programs often need parameters which are to do with the
-		current render state, or particular values which may very well change over time,
-		and often between objects which are being rendered. This feature allows you
-		to set up a certain number of predefined parameter mappings that are kept up to
-		date for you.
-		@param index The location in the constant list to place this updated constant every time
-		it is changed. Note that because of the nature of the types, we know how big the
-		parameter details will be so you don't need to set that like you do for manual constants.
-		@param acType The type of automatic constant to set
-		@param extraInfo1 The first extra parameter required by the auto constant type
-		@param extraInfo2 The first extra parameter required by the auto constant type
-		*/
-		void setAutoConstant(size_t index, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);
-		/** As setAutoConstant, but sets up the auto constant directly against a
-		physical buffer index.
-		*/
-		void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo,
-			uint16 variability, size_t elementSize = 4);
-		/** As setAutoConstantReal, but sets up the auto constant directly against a
-		physical buffer index.
-		*/
-		void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData,
-			uint16 variability, size_t elementSize = 4);
-		/** Unbind an auto constant so that the constant is manually controlled again. */
-		void clearAutoConstant(size_t index);
-		/** Sets a named parameter up to track a derivation of the current time.
-		@param index The index of the parameter
-		@param factor The amount by which to scale the time value
-		*/
-		void setConstantFromTime(size_t index, Real factor);
-		/** Clears all the existing automatic constants. */
-		void clearAutoConstants(void);
-		typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator;
-		/** Gets an iterator over the automatic constant bindings currently in place. */
-		AutoConstantIterator getAutoConstantIterator(void) const;
-		/// Gets the number of int constants that have been set
-		size_t getAutoConstantCount(void) const { return mAutoConstants.size(); }
-		/** Gets a specific Auto Constant entry if index is in valid range
-		otherwise returns a NULL
-		@param index which entry is to be retrieved
-		*/
-		AutoConstantEntry* getAutoConstantEntry(const size_t index);
-		/** Returns true if this instance has any automatic constants. */
-		bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); }
-		/** Finds an auto constant that's affecting a given logical parameter
-		index for floating-point values.
-		@note Only applicable for low-level programs.
-		*/
-		const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex);
-		/** Finds an auto constant that's affecting a given logical parameter
-		index for integer values.
-		@note Only applicable for low-level programs.
-		*/
-		const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex);
-		/** Finds an auto constant that's affecting a given named parameter index.
-		@note Only applicable to high-level programs.
-		*/
-		const AutoConstantEntry* findAutoConstantEntry(const String& paramName);
-		/** Finds an auto constant that's affecting a given physical position in
-		the floating-point buffer
-		*/
-		const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex);
-		/** Finds an auto constant that's affecting a given physical position in
-		the integer buffer
-		*/
-		const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex);
-		/** 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);
-		/** Tells the program whether to ignore missing parameters or not.
-		*/
-		void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; }
-		/** Sets a single value constant floating-point parameter to the program.
-		@remarks
-		Different types of GPU programs support different types of constant parameters.
-		For example, it's relatively common to find that vertex programs only support
-		floating point constants, and that fragment programs only support integer (fixed point)
-		parameters. This can vary depending on the program version supported by the
-		graphics card being used. You should consult the documentation for the type of
-		low level program you are using, or alternatively use the methods
-		provided on RenderSystemCapabilities to determine the options.
-		@par
-		Another possible limitation is that some systems only allow constants to be set
-		on certain boundaries, e.g. in sets of 4 values for example. Again, see
-		RenderSystemCapabilities for full details.
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param val The value to set
-		*/
-		void setNamedConstant(const String& name, Real val);
-		/** Sets a single value constant integer parameter to the program.
-		@remarks
-		Different types of GPU programs support different types of constant parameters.
-		For example, it's relatively common to find that vertex programs only support
-		floating point constants, and that fragment programs only support integer (fixed point)
-		parameters. This can vary depending on the program version supported by the
-		graphics card being used. You should consult the documentation for the type of
-		low level program you are using, or alternatively use the methods
-		provided on RenderSystemCapabilities to determine the options.
-		@par
-		Another possible limitation is that some systems only allow constants to be set
-		on certain boundaries, e.g. in sets of 4 values for example. Again, see
-		RenderSystemCapabilities for full details.
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param val The value to set
-		*/
-		void setNamedConstant(const String& name, int val);
-		/** Sets a Vector4 parameter to the program.
-		@param name The name of the parameter
-		@param vec The value to set
-		*/
-		void setNamedConstant(const String& name, const Vector4& vec);
-		/** Sets a Vector3 parameter to the program.
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param index The index at which to place the parameter
-		NB this index refers to the number of floats, so a Vector3 is 3. Note that many
-		rendersystems & programs assume that every floating point parameter is passed in
-		as a vector of 4 items, so you are strongly advised to check with
-		RenderSystemCapabilities before using this version - if in doubt use Vector4
-		or ColourValue instead (both are 4D).
-		@param vec The value to set
-		*/
-		void setNamedConstant(const String& name, const Vector3& vec);
-		/** Sets a Matrix4 parameter to the program.
-		@param name The name of the parameter
-		@param m The value to set
-		*/
-		void setNamedConstant(const String& name, const Matrix4& m);
-		/** Sets a list of Matrix4 parameters to the program.
-		@param name The name of the parameter; this must be the first index of an array,
-		for examples 'matrices[0]'
-		NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
-		@param m Pointer to an array of matrices to set
-		@param numEntries Number of Matrix4 entries
-		*/
-		void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
-		/** Sets a multiple value constant floating-point parameter to the program.
-		@par
-		Some systems only allow constants to be set on certain boundaries,
-		e.g. in sets of 4 values for example. The 'multiple' parameter allows
-		you to control that although you should only change it if you know
-		your chosen language supports that (at the time of writing, only
-		GLSL allows constants which are not a multiple of 4).
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param val Pointer to the values to write
-		@param count The number of 'multiples' of floats to write
-		@param multiple The number of raw entries in each element to write,
-		the default is 4 so count = 1 would write 4 floats.
-		*/
-		void setNamedConstant(const String& name, const float *val, size_t count,
-			size_t multiple = 4);
-		/** Sets a multiple value constant floating-point parameter to the program.
-		@par
-		Some systems only allow constants to be set on certain boundaries,
-		e.g. in sets of 4 values for example. The 'multiple' parameter allows
-		you to control that although you should only change it if you know
-		your chosen language supports that (at the time of writing, only
-		GLSL allows constants which are not a multiple of 4).
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param val Pointer to the values to write
-		@param count The number of 'multiples' of floats to write
-		@param multiple The number of raw entries in each element to write,
-		the default is 4 so count = 1 would write 4 floats.
-		*/
-		void setNamedConstant(const String& name, const double *val, size_t count,
-			size_t multiple = 4);
-		/** Sets a ColourValue parameter to the program.
-		@param name The name of the parameter
-		@param colour The value to set
-		*/
-		void setNamedConstant(const String& name, const ColourValue& colour);
-		/** Sets a multiple value constant floating-point parameter to the program.
-		@par
-		Some systems only allow constants to be set on certain boundaries,
-		e.g. in sets of 4 values for example. The 'multiple' parameter allows
-		you to control that although you should only change it if you know
-		your chosen language supports that (at the time of writing, only
-		GLSL allows constants which are not a multiple of 4).
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param val Pointer to the values to write
-		@param count The number of 'multiples' of floats to write
-		@param multiple The number of raw entries in each element to write,
-		the default is 4 so count = 1 would write 4 floats.
-		*/
-		void setNamedConstant(const String& name, const int *val, size_t count,
-			size_t multiple = 4);
-		/** Sets up a constant which will automatically be updated by the system.
-		@remarks
-		Vertex and fragment programs often need parameters which are to do with the
-		current render state, or particular values which may very well change over time,
-		and often between objects which are being rendered. This feature allows you
-		to set up a certain number of predefined parameter mappings that are kept up to
-		date for you.
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param acType The type of automatic constant to set
-		@param extraInfo If the constant type needs more information (like a light index) put it here.
-		*/
-		void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0);
-		void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData);
-		/** Sets up a constant which will automatically be updated by the system.
-		@remarks
-		Vertex and fragment programs often need parameters which are to do with the
-		current render state, or particular values which may very well change over time,
-		and often between objects which are being rendered. This feature allows you
-		to set up a certain number of predefined parameter mappings that are kept up to
-		date for you.
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param acType The type of automatic constant to set
-		@param extraInfo1 The first extra info required by this auto constant type
-		@param extraInfo2 The first extra info required by this auto constant type
-		*/
-		void setNamedAutoConstant(const String& name, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);
-		/** Sets a named parameter up to track a derivation of the current time.
-		@note
-		This named option will only work if you are using a parameters object created
-		from a high-level program (HighLevelGpuProgram).
-		@param name The name of the parameter
-		@param factor The amount by which to scale the time value
-		*/
-		void setNamedConstantFromTime(const String& name, Real factor);
-		/** Unbind an auto constant so that the constant is manually controlled again. */
-		void clearNamedAutoConstant(const String& name);
-		/** Find a constant definition for a named parameter.
-		@remarks
-		This method returns null if the named parameter did not exist, unlike
-		getConstantDefinition which is more strict; unless you set the
-		last parameter to true.
-		@param name The name to look up
-		@param throwExceptionIfMissing If set to true, failure to find an entry
-		will throw an exception.
-		*/
-		const GpuConstantDefinition* _findNamedConstantDefinition(
-			const String& name, bool throwExceptionIfMissing = false) const;
-		/** Gets the physical buffer index associated with a logical float constant index.
-		@note Only applicable to low-level programs.
-		@param logicalIndex The logical parameter index
-		@param requestedSize The requested size - pass 0 to ignore missing entries
-		and return std::numeric_limits<size_t>::max()
-		*/
-		size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
-		/** Gets the physical buffer index associated with a logical int constant index.
-		@note Only applicable to low-level programs.
-		@param logicalIndex The logical parameter index
-		@param requestedSize The requested size - pass 0 to ignore missing entries
-		and return std::numeric_limits<size_t>::max()
-		*/
-		size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
-		/** Sets whether or not we need to transpose the matrices passed in from the rest of OGRE.
-		@remarks
-		D3D uses transposed matrices compared to GL and OGRE; this is not important when you
-		use programs which are written to process row-major matrices, such as those generated
-		by Cg, but if you use a program written to D3D's matrix layout you will need to enable
-		this flag.
-		*/
-		void setTransposeMatrices(bool val) { mTransposeMatrices = val; }
-		/// Gets whether or not matrices are to be transposed when set
-		bool getTransposeMatrices(void) const { return mTransposeMatrices; }
-		/** Copies the values of all constants (including auto constants) from another
-		GpuProgramParameters object.
-		@note This copes the internal storage of the paarameters object and therefore
-		can only be used for parameters objects created from the same GpuProgram.
-		To merge parameters that match from different programs, use copyMatchingNamedConstantsFrom.
-		*/
-		void copyConstantsFrom(const GpuProgramParameters& source);
-		/** Copies the values of all matching named constants (including auto constants) from
-		another GpuProgramParameters object.
-		@remarks
-		This method iterates over the named constants in another parameters object
-		and copies across the values where they match. This method is safe to
-		use when the 2 parameters objects came from different programs, but only
-		works for named parameters.
-		*/
-		void copyMatchingNamedConstantsFrom(const GpuProgramParameters& source);
-		/** gets the auto constant definition associated with name if found else returns NULL
-		@param name The name of the auto constant
-		*/
-		static const AutoConstantDefinition* getAutoConstantDefinition(const String& name);
-		/** gets the auto constant definition using an index into the auto constant definition array.
-		If the index is out of bounds then NULL is returned;
-		@param idx The auto constant index
-		*/
-		static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx);
-		/** Returns the number of auto constant definitions
-		*/
-		static size_t getNumAutoConstantDefinitions(void);
-		/** increments the multipass number entry by 1 if it exists
-		*/
-		void incPassIterationNumber(void);
-		/** Does this parameters object have a pass iteration number constant? */
-		bool hasPassIterationNumber() const
-		{ return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
-		/** Get the physical buffer index of the pass iteration number constant */
-		size_t getPassIterationNumberIndex() const
-		{ return mActivePassIterationIndex; }
-		/** Use a set of shared parameters in this parameters object.
-		@remarks
-			Allows you to use a set of shared parameters to automatically update
-			this parameter set.
-		*/
-		void addSharedParameters(GpuSharedParametersPtr sharedParams);
-		/** Use a set of shared parameters in this parameters object.
-		@remarks
-			Allows you to use a set of shared parameters to automatically update
-			this parameter set.
-		@param sharedParamsName The name of a shared parameter set as defined in
-			GpuProgramManager
-		*/
-		void addSharedParameters(const String& sharedParamsName);
-		/** Returns whether this parameter set is using the named shared parameter set. */
-		bool isUsingSharedParameters(const String& sharedParamsName) const;
-		/** Stop using the named shared parameter set. */
-		void removeSharedParameters(const String& sharedParamsName);
-		/** Stop using all shared parameter sets. */
-		void removeAllSharedParameters();
-		/** Get the list of shared parameter sets. */
-		const GpuSharedParamUsageList& getSharedParameters() const;
-		/** Internal method that the RenderSystem might use to store optional data. */
-		void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
-		/** Internal method that the RenderSystem might use to store optional data. */
-		const Any& _getRenderSystemData() const { return mRenderSystemData; }
-		/** Update the parameters by copying the data from the shared
-		parameters.
-		@note This method  may not actually be called if the RenderSystem
-		supports using shared parameters directly in their own shared buffer; in
-		which case the values should not be copied out of the shared area
-		into the individual parameter set, but bound separately.
-		*/
-		void _copySharedParams();
-	};
-	/// Shared pointer used to hold references to GpuProgramParameters instances
-	typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr;
-	/** @} */
-	/** @} */
-}
-#endif