ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreGpuProgramParams.h

@@ -0,0 +1,1840 @@
+/*
+-----------------------------------------------------------------------------
+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
+