Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

OgreGpuProgramParams.h @ 151

Last change on this file since 151 was 148, checked in by patricwi, 6 years ago
Added new dependencies for ogre1.9 and cegui0.8
File size: 84.8 KB

Rev	Line
[148]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://www.ogre3d.org
	6
	7	Copyright (c) 2000-2013 Torus Knot Software Ltd
	8
	9	Permission is hereby granted, free of charge, to any person obtaining a copy
	10	of this software and associated documentation files (the "Software"), to deal
	11	in the Software without restriction, including without limitation the rights
	12	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	copies of the Software, and to permit persons to whom the Software is
	14	furnished to do so, subject to the following conditions:
	15
	16	The above copyright notice and this permission notice shall be included in
	17	all copies or substantial portions of the Software.
	18
	19	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	22	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	25	THE SOFTWARE.
	26	-----------------------------------------------------------------------------
	27	*/
	28	#ifndef __GpuProgramParams_H_
	29	#define __GpuProgramParams_H_
	30
	31	// Precompiler options
	32	#include "OgrePrerequisites.h"
	33	#include "OgreSharedPtr.h"
	34	#include "OgreIteratorWrappers.h"
	35	#include "OgreSerializer.h"
	36	#include "OgreRenderOperation.h"
	37	#include "OgreAny.h"
	38	#include "Threading/OgreThreadHeaders.h"
	39	#include "OgreHeaderPrefix.h"
	40
	41	namespace Ogre {
	42
	43	/** \addtogroup Core
	44	* @{
	45	*/
	46	/** \addtogroup Materials
	47	* @{
	48	*/
	49	/** Enumeration of the types of constant we may encounter in programs.
	50	@note Low-level programs, by definition, will always use either
	51	float4 or int4 constant types since that is the fundamental underlying
	52	type in assembler.
	53	*/
	54	enum GpuConstantType
	55	{
	56	GCT_FLOAT1 = 1,
	57	GCT_FLOAT2 = 2,
	58	GCT_FLOAT3 = 3,
	59	GCT_FLOAT4 = 4,
	60	GCT_SAMPLER1D = 5,
	61	GCT_SAMPLER2D = 6,
	62	GCT_SAMPLER3D = 7,
	63	GCT_SAMPLERCUBE = 8,
	64	GCT_SAMPLERRECT = 9,
	65	GCT_SAMPLER1DSHADOW = 10,
	66	GCT_SAMPLER2DSHADOW = 11,
	67	GCT_SAMPLER2DARRAY = 12,
	68	GCT_MATRIX_2X2 = 13,
	69	GCT_MATRIX_2X3 = 14,
	70	GCT_MATRIX_2X4 = 15,
	71	GCT_MATRIX_3X2 = 16,
	72	GCT_MATRIX_3X3 = 17,
	73	GCT_MATRIX_3X4 = 18,
	74	GCT_MATRIX_4X2 = 19,
	75	GCT_MATRIX_4X3 = 20,
	76	GCT_MATRIX_4X4 = 21,
	77	GCT_INT1 = 22,
	78	GCT_INT2 = 23,
	79	GCT_INT3 = 24,
	80	GCT_INT4 = 25,
	81	GCT_SUBROUTINE = 26,
	82	GCT_DOUBLE1 = 27,
	83	GCT_DOUBLE2 = 28,
	84	GCT_DOUBLE3 = 29,
	85	GCT_DOUBLE4 = 30,
	86	GCT_MATRIX_DOUBLE_2X2 = 31,
	87	GCT_MATRIX_DOUBLE_2X3 = 32,
	88	GCT_MATRIX_DOUBLE_2X4 = 33,
	89	GCT_MATRIX_DOUBLE_3X2 = 34,
	90	GCT_MATRIX_DOUBLE_3X3 = 35,
	91	GCT_MATRIX_DOUBLE_3X4 = 36,
	92	GCT_MATRIX_DOUBLE_4X2 = 37,
	93	GCT_MATRIX_DOUBLE_4X3 = 38,
	94	GCT_MATRIX_DOUBLE_4X4 = 39,
	95	GCT_UNKNOWN = 99
	96	};
	97
	98	/** The variability of a GPU parameter, as derived from auto-params targeting it.
	99	These values must be powers of two since they are used in masks.
	100	*/
	101	enum GpuParamVariability
	102	{
	103	/// No variation except by manual setting - the default
	104	GPV_GLOBAL = 1,
	105	/// Varies per object (based on an auto param usually), but not per light setup
	106	GPV_PER_OBJECT = 2,
	107	/// Varies with light setup
	108	GPV_LIGHTS = 4,
	109	/// Varies with pass iteration number
	110	GPV_PASS_ITERATION_NUMBER = 8,
	111
	112
	113	/// Full mask (16-bit)
	114	GPV_ALL = 0xFFFF
	115
	116	};
	117
	118	/** Information about predefined program constants.
	119	@note Only available for high-level programs but is referenced generically
	120	by GpuProgramParameters.
	121	*/
	122	struct _OgreExport GpuConstantDefinition
	123	{
	124	/// Data type
	125	GpuConstantType constType;
	126	/// Physical start index in buffer (either float, double or int buffer)
	127	size_t physicalIndex;
	128	/// Logical index - used to communicate this constant to the rendersystem
	129	size_t logicalIndex;
	130	/** Number of raw buffer slots per element
	131	(some programs pack each array element to float4, some do not) */
	132	size_t elementSize;
	133	/// Length of array
	134	size_t arraySize;
	135	/// How this parameter varies (bitwise combination of GpuProgramVariability)
	136	mutable uint16 variability;
	137
	138	bool isFloat() const
	139	{
	140	return isFloat(constType);
	141	}
	142
	143	static bool isFloat(GpuConstantType c)
	144	{
	145	switch(c)
	146	{
	147	case GCT_INT1:
	148	case GCT_INT2:
	149	case GCT_INT3:
	150	case GCT_INT4:
	151	case GCT_SAMPLER1D:
	152	case GCT_SAMPLER2D:
	153	case GCT_SAMPLER2DARRAY:
	154	case GCT_SAMPLER3D:
	155	case GCT_SAMPLERCUBE:
	156	case GCT_SAMPLER1DSHADOW:
	157	case GCT_SAMPLER2DSHADOW:
	158	return false;
	159	default:
	160	return true;
	161	};
	162
	163	}
	164
	165	bool isDouble() const
	166	{
	167	return isDouble(constType);
	168	}
	169
	170	static bool isDouble(GpuConstantType c)
	171	{
	172	switch(c)
	173	{
	174	case GCT_INT1:
	175	case GCT_INT2:
	176	case GCT_INT3:
	177	case GCT_INT4:
	178	case GCT_FLOAT1:
	179	case GCT_FLOAT2:
	180	case GCT_FLOAT3:
	181	case GCT_FLOAT4:
	182	case GCT_SAMPLER1D:
	183	case GCT_SAMPLER2D:
	184	case GCT_SAMPLER2DARRAY:
	185	case GCT_SAMPLER3D:
	186	case GCT_SAMPLERCUBE:
	187	case GCT_SAMPLER1DSHADOW:
	188	case GCT_SAMPLER2DSHADOW:
	189	return false;
	190	default:
	191	return true;
	192	};
	193
	194	}
	195
	196	bool isSampler() const
	197	{
	198	return isSampler(constType);
	199	}
	200
	201	static bool isSampler(GpuConstantType c)
	202	{
	203	switch(c)
	204	{
	205	case GCT_SAMPLER1D:
	206	case GCT_SAMPLER2D:
	207	case GCT_SAMPLER2DARRAY:
	208	case GCT_SAMPLER3D:
	209	case GCT_SAMPLERCUBE:
	210	case GCT_SAMPLER1DSHADOW:
	211	case GCT_SAMPLER2DSHADOW:
	212	return true;
	213	default:
	214	return false;
	215	};
	216
	217	}
	218
	219	bool isSubroutine() const
	220	{
	221	return isSubroutine(constType);
	222	}
	223
	224	static bool isSubroutine(GpuConstantType c)
	225	{
	226	return c == GCT_SUBROUTINE;
	227	}
	228
	229	/** Get the element size of a given type, including whether to pad the
	230	elements into multiples of 4 (e.g. SM1 and D3D does, GLSL doesn't)
	231	*/
	232	static size_t getElementSize(GpuConstantType ctype, bool padToMultiplesOf4)
	233	{
	234	if (padToMultiplesOf4)
	235	{
	236	switch(ctype)
	237	{
	238	case GCT_FLOAT1:
	239	case GCT_INT1:
	240	case GCT_SAMPLER1D:
	241	case GCT_SAMPLER2D:
	242	case GCT_SAMPLER2DARRAY:
	243	case GCT_SAMPLER3D:
	244	case GCT_SAMPLERCUBE:
	245	case GCT_SAMPLER1DSHADOW:
	246	case GCT_SAMPLER2DSHADOW:
	247	case GCT_FLOAT2:
	248	case GCT_INT2:
	249	case GCT_FLOAT3:
	250	case GCT_INT3:
	251	case GCT_FLOAT4:
	252	case GCT_INT4:
	253	return 4;
	254	case GCT_MATRIX_2X2:
	255	case GCT_MATRIX_2X3:
	256	case GCT_MATRIX_2X4:
	257	case GCT_DOUBLE1:
	258	case GCT_DOUBLE2:
	259	case GCT_DOUBLE3:
	260	case GCT_DOUBLE4:
	261	return 8; // 2 float4s
	262	case GCT_MATRIX_3X2:
	263	case GCT_MATRIX_3X3:
	264	case GCT_MATRIX_3X4:
	265	return 12; // 3 float4s
	266	case GCT_MATRIX_4X2:
	267	case GCT_MATRIX_4X3:
	268	case GCT_MATRIX_4X4:
	269	case GCT_MATRIX_DOUBLE_2X2:
	270	case GCT_MATRIX_DOUBLE_2X3:
	271	case GCT_MATRIX_DOUBLE_2X4:
	272	return 16; // 4 float4s
	273	case GCT_MATRIX_DOUBLE_3X2:
	274	case GCT_MATRIX_DOUBLE_3X3:
	275	case GCT_MATRIX_DOUBLE_3X4:
	276	return 24;
	277	case GCT_MATRIX_DOUBLE_4X2:
	278	case GCT_MATRIX_DOUBLE_4X3:
	279	case GCT_MATRIX_DOUBLE_4X4:
	280	return 32;
	281	default:
	282	return 4;
	283	};
	284	}
	285	else
	286	{
	287	switch(ctype)
	288	{
	289	case GCT_FLOAT1:
	290	case GCT_DOUBLE1:
	291	case GCT_INT1:
	292	case GCT_SAMPLER1D:
	293	case GCT_SAMPLER2D:
	294	case GCT_SAMPLER2DARRAY:
	295	case GCT_SAMPLER3D:
	296	case GCT_SAMPLERCUBE:
	297	case GCT_SAMPLER1DSHADOW:
	298	case GCT_SAMPLER2DSHADOW:
	299	return 1;
	300	case GCT_FLOAT2:
	301	case GCT_INT2:
	302	case GCT_DOUBLE2:
	303	return 2;
	304	case GCT_FLOAT3:
	305	case GCT_INT3:
	306	case GCT_DOUBLE3:
	307	return 3;
	308	case GCT_FLOAT4:
	309	case GCT_INT4:
	310	case GCT_DOUBLE4:
	311	return 4;
	312	case GCT_MATRIX_2X2:
	313	case GCT_MATRIX_DOUBLE_2X2:
	314	return 4;
	315	case GCT_MATRIX_2X3:
	316	case GCT_MATRIX_3X2:
	317	case GCT_MATRIX_DOUBLE_2X3:
	318	case GCT_MATRIX_DOUBLE_3X2:
	319	return 6;
	320	case GCT_MATRIX_2X4:
	321	case GCT_MATRIX_4X2:
	322	case GCT_MATRIX_DOUBLE_2X4:
	323	case GCT_MATRIX_DOUBLE_4X2:
	324	return 8;
	325	case GCT_MATRIX_3X3:
	326	case GCT_MATRIX_DOUBLE_3X3:
	327	return 9;
	328	case GCT_MATRIX_3X4:
	329	case GCT_MATRIX_4X3:
	330	case GCT_MATRIX_DOUBLE_3X4:
	331	case GCT_MATRIX_DOUBLE_4X3:
	332	return 12;
	333	case GCT_MATRIX_4X4:
	334	case GCT_MATRIX_DOUBLE_4X4:
	335	return 16;
	336	default:
	337	return 4;
	338	};
	339
	340	}
	341	}
	342
	343	GpuConstantDefinition()
	344	: constType(GCT_UNKNOWN)
	345	, physicalIndex((std::numeric_limits<size_t>::max)())
	346	, logicalIndex(0)
	347	, elementSize(0)
	348	, arraySize(1)
	349	, variability(GPV_GLOBAL) {}
	350	};
	351	typedef map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap;
	352	typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator;
	353
	354	/// Struct collecting together the information for named constants.
	355	struct _OgreExport GpuNamedConstants : public GpuParamsAlloc
	356	{
	357	/// Total size of the float buffer required
	358	size_t floatBufferSize;
	359	/// Total size of the double buffer required
	360	size_t doubleBufferSize;
	361	/// Total size of the int buffer required
	362	size_t intBufferSize;
	363	/// Map of parameter names to GpuConstantDefinition
	364	GpuConstantDefinitionMap map;
	365
	366	GpuNamedConstants() : floatBufferSize(0), doubleBufferSize(0), intBufferSize(0) {}
	367
	368	/** Generate additional constant entries for arrays based on a base definition.
	369	@remarks
	370	Array uniforms will be added just with their base name with no array
	371	suffix. This method will add named entries for array suffixes too
	372	so individual array entries can be addressed. Note that we only
	373	individually index array elements if the array size is up to 16
	374	entries in size. Anything larger than that only gets a [0] entry
	375	as well as the main entry, to save cluttering up the name map. After
	376	all, you can address the larger arrays in a bulk fashion much more
	377	easily anyway.
	378	*/
	379	void generateConstantDefinitionArrayEntries(const String& paramName,
	380	const GpuConstantDefinition& baseDef);
	381
	382	/// Indicates whether all array entries will be generated and added to the definitions map
	383	static bool getGenerateAllConstantDefinitionArrayEntries();
	384
	385	/** Sets whether all array entries will be generated and added to the definitions map.
	386	@remarks
	387	Usually, array entries can only be individually indexed if they're up to 16 entries long,
	388	to save memory - arrays larger than that can be set but only via the bulk setting
	389	methods. This option allows you to choose to individually index every array entry.
	390	*/
	391	static void setGenerateAllConstantDefinitionArrayEntries(bool generateAll);
	392
	393	/** Saves constant definitions to a file, compatible with GpuProgram::setManualNamedConstantsFile.
	394	@see GpuProgram::setManualNamedConstantsFile
	395	*/
	396	void save(const String& filename) const;
	397	/** Loads constant definitions from a stream, compatible with GpuProgram::setManualNamedConstantsFile.
	398	@see GpuProgram::setManualNamedConstantsFile
	399	*/
	400	void load(DataStreamPtr& stream);
	401
	402	size_t calculateSize(void) const;
	403
	404	protected:
	405	/** Indicates whether all array entries will be generated and added to the definitions map
	406	@remarks
	407	Normally, the number of array entries added to the definitions map is capped at 16
	408	to save memory. Setting this value to <code>true</code> allows all of the entries
	409	to be generated and added to the map.
	410	*/
	411	static bool msGenerateAllConstantDefinitionArrayEntries;
	412	};
	413	typedef SharedPtr<GpuNamedConstants> GpuNamedConstantsPtr;
	414
	415	/// Simple class for loading / saving GpuNamedConstants
	416	class _OgreExport GpuNamedConstantsSerializer : public Serializer
	417	{
	418	public:
	419	GpuNamedConstantsSerializer();
	420	virtual ~GpuNamedConstantsSerializer();
	421	void exportNamedConstants(const GpuNamedConstants* pConsts, const String& filename,
	422	Endian endianMode = ENDIAN_NATIVE);
	423	void exportNamedConstants(const GpuNamedConstants* pConsts, DataStreamPtr stream,
	424	Endian endianMode = ENDIAN_NATIVE);
	425	void importNamedConstants(DataStreamPtr& stream, GpuNamedConstants* pDest);
	426	};
	427
	428	/** Structure recording the use of a physical buffer by a logical parameter
	429	index. Only used for low-level programs.
	430	*/
	431	struct _OgreExport GpuLogicalIndexUse
	432	{
	433	/// Physical buffer index
	434	size_t physicalIndex;
	435	/// Current physical size allocation
	436	size_t currentSize;
	437	/// How the contents of this slot vary
	438	mutable uint16 variability;
	439
	440	GpuLogicalIndexUse()
	441	: physicalIndex(99999), currentSize(0), variability(GPV_GLOBAL) {}
	442	GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v)
	443	: physicalIndex(bufIdx), currentSize(curSz), variability(v) {}
	444	};
	445	typedef map<size_t, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap;
	446	/// Container struct to allow params to safely & update shared list of logical buffer assignments
	447	struct _OgreExport GpuLogicalBufferStruct : public GpuParamsAlloc
	448	{
	449	OGRE_MUTEX(mutex);
	450
	451	/// Map from logical index to physical buffer location
	452	GpuLogicalIndexUseMap map;
	453	/// Shortcut to know the buffer size needs
	454	size_t bufferSize;
	455	GpuLogicalBufferStruct() : bufferSize(0) {}
	456	};
	457	typedef SharedPtr<GpuLogicalBufferStruct> GpuLogicalBufferStructPtr;
	458
	459	/** Definition of container that holds the current float constants.
	460	@note Not necessarily in direct index order to constant indexes, logical
	461	to physical index map is derived from GpuProgram
	462	*/
	463	typedef vector<float>::type FloatConstantList;
	464	/** Definition of container that holds the current double constants.
	465	@note Not necessarily in direct index order to constant indexes, logical
	466	to physical index map is derived from GpuProgram
	467	*/
	468	typedef vector<double>::type DoubleConstantList;
	469	/** Definition of container that holds the current float constants.
	470	@note Not necessarily in direct index order to constant indexes, logical
	471	to physical index map is derived from GpuProgram
	472	*/
	473	typedef vector<int>::type IntConstantList;
	474
	475	/** A group of manually updated parameters that are shared between many parameter sets.
	476	@remarks
	477	Sometimes you want to set some common parameters across many otherwise
	478	different parameter sets, and keep them all in sync together. This class
	479	allows you to define a set of parameters that you can share across many
	480	parameter sets and have the parameters that match automatically be pulled
	481	from the shared set, rather than you having to set them on all the parameter
	482	sets individually.
	483	@par
	484	Parameters in a shared set are matched up with instances in a GpuProgramParameters
	485	structure by matching names. It is up to you to define the named parameters
	486	that a shared set contains, and ensuring the definition matches.
	487	@note
	488	Shared parameter sets can be named, and looked up using the GpuProgramManager.
	489	*/
	490	class _OgreExport GpuSharedParameters : public GpuParamsAlloc
	491	{
	492	protected:
	493	GpuNamedConstants mNamedConstants;
	494	FloatConstantList mFloatConstants;
	495	DoubleConstantList mDoubleConstants;
	496	IntConstantList mIntConstants;
	497	String mName;
	498
	499	// Optional data the rendersystem might want to store
	500	mutable Any mRenderSystemData;
	501
	502	/// Not used when copying data, but might be useful to RS using shared buffers
	503	size_t mFrameLastUpdated;
	504
	505	/// Version number of the definitions in this buffer
	506	unsigned long mVersion;
	507
	508	public:
	509	GpuSharedParameters(const String& name);
	510	virtual ~GpuSharedParameters();
	511
	512	/// Get the name of this shared parameter set
	513	const String& getName() { return mName; }
	514
	515	/** Add a new constant definition to this shared set of parameters.
	516	@remarks
	517	Unlike GpuProgramParameters, where the parameter list is defined by the
	518	program being compiled, this shared parameter set is defined by the
	519	user. Only parameters which have been predefined here may be later
	520	updated.
	521	*/
	522	void addConstantDefinition(const String& name, GpuConstantType constType, size_t arraySize = 1);
	523
	524	/** Remove a constant definition from this shared set of parameters.
	525	*/
	526	void removeConstantDefinition(const String& name);
	527
	528	/** Remove a constant definition from this shared set of parameters.
	529	*/
	530	void removeAllConstantDefinitions();
	531
	532	/** Get the version number of this shared parameter set, can be used to identify when
	533	changes have occurred.
	534	*/
	535	unsigned long getVersion() const { return mVersion; }
	536
	537	size_t calculateSize(void) const;
	538
	539	/** Mark the shared set as being dirty (values modified).
	540	@remarks
	541	You do not need to call this yourself, set is marked as dirty whenever
	542	setNamedConstant or (non const) getFloatPointer et al are called.
	543	*/
	544	void _markDirty();
	545	/// Get the frame in which this shared parameter set was last updated
	546	size_t getFrameLastUpdated() const { return mFrameLastUpdated; }
	547
	548	/** Gets an iterator over the named GpuConstantDefinition instances as defined
	549	by the user.
	550	*/
	551	GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;
	552
	553	/** Get a specific GpuConstantDefinition for a named parameter.
	554	*/
	555	const GpuConstantDefinition& getConstantDefinition(const String& name) const;
	556
	557	/** Get the full list of GpuConstantDefinition instances.
	558	*/
	559	const GpuNamedConstants& getConstantDefinitions() const;
	560
	561	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, Real val) */
	562	void setNamedConstant(const String& name, Real val);
	563	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, int val) */
	564	void setNamedConstant(const String& name, int val);
	565	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const Vector4& vec) */
	566	void setNamedConstant(const String& name, const Vector4& vec);
	567	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const Vector3& vec) */
	568	void setNamedConstant(const String& name, const Vector3& vec);
	569	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const Vector2& vec) */
	570	void setNamedConstant(const String& name, const Vector2& vec);
	571	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const Matrix4& m) */
	572	void setNamedConstant(const String& name, const Matrix4& m);
	573	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const Matrix4* m, size_t numEntries) */
	574	void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
	575	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const float val, size_t count) /
	576	void setNamedConstant(const String& name, const float *val, size_t count);
	577	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const double val, size_t count) /
	578	void setNamedConstant(const String& name, const double *val, size_t count);
	579	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const ColourValue& colour) */
	580	void setNamedConstant(const String& name, const ColourValue& colour);
	581	/** @copydoc GpuProgramParameters::setNamedConstant(const String& name, const int val, size_t count) /
	582	void setNamedConstant(const String& name, const int *val, size_t count);
	583
	584	/// Get a pointer to the 'nth' item in the float buffer
	585	float* getFloatPointer(size_t pos) { _markDirty(); return &mFloatConstants[pos]; }
	586	/// Get a pointer to the 'nth' item in the float buffer
	587	const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
	588	/// Get a pointer to the 'nth' item in the double buffer
	589	double* getDoublePointer(size_t pos) { _markDirty(); return &mDoubleConstants[pos]; }
	590	/// Get a pointer to the 'nth' item in the double buffer
	591	const double* getDoublePointer(size_t pos) const { return &mDoubleConstants[pos]; }
	592	/// Get a pointer to the 'nth' item in the int buffer
	593	int* getIntPointer(size_t pos) { _markDirty(); return &mIntConstants[pos]; }
	594	/// Get a pointer to the 'nth' item in the int buffer
	595	const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
	596
	597	/// Get a reference to the list of float constants
	598	const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
	599	/// Get a reference to the list of double constants
	600	const DoubleConstantList& getDoubleConstantList() const { return mDoubleConstants; }
	601	/// Get a reference to the list of int constants
	602	const IntConstantList& getIntConstantList() const { return mIntConstants; }
	603
	604	/** Internal method that the RenderSystem might use to store optional data. */
	605	void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
	606	/** Internal method that the RenderSystem might use to store optional data. */
	607	const Any& _getRenderSystemData() const { return mRenderSystemData; }
	608
	609	};
	610
	611	/// Shared pointer used to hold references to GpuProgramParameters instances
	612	typedef SharedPtr<GpuSharedParameters> GpuSharedParametersPtr;
	613
	614	class GpuProgramParameters;
	615
	616	/** This class records the usage of a set of shared parameters in a concrete
	617	set of GpuProgramParameters.
	618	*/
	619	class _OgreExport GpuSharedParametersUsage : public GpuParamsAlloc
	620	{
	621	protected:
	622	GpuSharedParametersPtr mSharedParams;
	623	// Not a shared pointer since this is also parent
	624	GpuProgramParameters* mParams;
	625	// list of physical mappings that we are going to bring in
	626	struct CopyDataEntry
	627	{
	628	const GpuConstantDefinition* srcDefinition;
	629	const GpuConstantDefinition* dstDefinition;
	630	};
	631	typedef vector<CopyDataEntry>::type CopyDataList;
	632
	633	CopyDataList mCopyDataList;
	634
	635	// Optional data the rendersystem might want to store
	636	mutable Any mRenderSystemData;
	637
	638	/// Version of shared params we based the copydata on
	639	unsigned long mCopyDataVersion;
	640
	641	void initCopyData();
	642
	643
	644	public:
	645	/// Construct usage
	646	GpuSharedParametersUsage(GpuSharedParametersPtr sharedParams,
	647	GpuProgramParameters* params);
	648
	649	/** Update the target parameters by copying the data from the shared
	650	parameters.
	651	@note This method may not actually be called if the RenderSystem
	652	supports using shared parameters directly in their own shared buffer; in
	653	which case the values should not be copied out of the shared area
	654	into the individual parameter set, but bound separately.
	655	*/
	656	void _copySharedParamsToTargetParams();
	657
	658	/// Get the name of the shared parameter set
	659	const String& getName() const { return mSharedParams->getName(); }
	660
	661	GpuSharedParametersPtr getSharedParams() const { return mSharedParams; }
	662	GpuProgramParameters* getTargetParams() const { return mParams; }
	663
	664	/** Internal method that the RenderSystem might use to store optional data. */
	665	void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
	666	/** Internal method that the RenderSystem might use to store optional data. */
	667	const Any& _getRenderSystemData() const { return mRenderSystemData; }
	668
	669
	670	};
	671
	672	/** Collects together the program parameters used for a GpuProgram.
	673	@remarks
	674	Gpu program state includes constant parameters used by the program, and
	675	bindings to render system state which is propagated into the constants
	676	by the engine automatically if requested.
	677	@par
	678	GpuProgramParameters objects should be created through the GpuProgram and
	679	may be shared between multiple Pass instances. For this reason they
	680	are managed using a shared pointer, which will ensure they are automatically
	681	deleted when no Pass is using them anymore.
	682	@par
	683	High-level programs use named parameters (uniforms), low-level programs
	684	use indexed constants. This class supports both, but you can tell whether
	685	named constants are supported by calling hasNamedParameters(). There are
	686	references in the documentation below to 'logical' and 'physical' indexes;
	687	logical indexes are the indexes used by low-level programs and represent
	688	indexes into an array of float4's, some of which may be settable, some of
	689	which may be predefined constants in the program. We only store those
	690	constants which have actually been set, therefore our buffer could have
	691	gaps if we used the logical indexes in our own buffers. So instead we map
	692	these logical indexes to physical indexes in our buffer. When using
	693	high-level programs, logical indexes don't necessarily exist, although they
	694	might if the high-level program has a direct, exposed mapping from parameter
	695	names to logical indexes. In addition, high-level languages may or may not pack
	696	arrays of elements that are smaller than float4 (e.g. float2/vec2) contiguously.
	697	This kind of information is held in the ConstantDefinition structure which
	698	is only populated for high-level programs. You don't have to worry about
	699	any of this unless you intend to read parameters back from this structure
	700	rather than just setting them.
	701	*/
	702	class _OgreExport GpuProgramParameters : public GpuParamsAlloc
	703	{
	704	public:
	705	/** Defines the types of automatically updated values that may be bound to GpuProgram
	706	parameters, or used to modify parameters on a per-object basis.
	707	*/
	708	enum AutoConstantType
	709	{
	710	/// The current world matrix
	711	ACT_WORLD_MATRIX,
	712	/// The current world matrix, inverted
	713	ACT_INVERSE_WORLD_MATRIX,
	714	/** Provides transpose of world matrix.
	715	Equivalent to RenderMonkey's "WorldTranspose".
	716	*/
	717	ACT_TRANSPOSE_WORLD_MATRIX,
	718	/// The current world matrix, inverted & transposed
	719	ACT_INVERSE_TRANSPOSE_WORLD_MATRIX,
	720
	721	/// The current array of world matrices, as a 3x4 matrix, used for blending
	722	ACT_WORLD_MATRIX_ARRAY_3x4,
	723	/// The current array of world matrices, used for blending
	724	ACT_WORLD_MATRIX_ARRAY,
	725	/// The current array of world matrices transformed to an array of dual quaternions, represented as a 2x4 matrix
	726	ACT_WORLD_DUALQUATERNION_ARRAY_2x4,
	727	/// The scale and shear components of the current array of world matrices
	728	ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4,
	729
	730	/// The current view matrix
	731	ACT_VIEW_MATRIX,
	732	/// The current view matrix, inverted
	733	ACT_INVERSE_VIEW_MATRIX,
	734	/** Provides transpose of view matrix.
	735	Equivalent to RenderMonkey's "ViewTranspose".
	736	*/
	737	ACT_TRANSPOSE_VIEW_MATRIX,
	738	/** Provides inverse transpose of view matrix.
	739	Equivalent to RenderMonkey's "ViewInverseTranspose".
	740	*/
	741	ACT_INVERSE_TRANSPOSE_VIEW_MATRIX,
	742
	743
	744	/// The current projection matrix
	745	ACT_PROJECTION_MATRIX,
	746	/** Provides inverse of projection matrix.
	747	Equivalent to RenderMonkey's "ProjectionInverse".
	748	*/
	749	ACT_INVERSE_PROJECTION_MATRIX,
	750	/** Provides transpose of projection matrix.
	751	Equivalent to RenderMonkey's "ProjectionTranspose".
	752	*/
	753	ACT_TRANSPOSE_PROJECTION_MATRIX,
	754	/** Provides inverse transpose of projection matrix.
	755	Equivalent to RenderMonkey's "ProjectionInverseTranspose".
	756	*/
	757	ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX,
	758
	759
	760	/// The current view & projection matrices concatenated
	761	ACT_VIEWPROJ_MATRIX,
	762	/** Provides inverse of concatenated view and projection matrices.
	763	Equivalent to RenderMonkey's "ViewProjectionInverse".
	764	*/
	765	ACT_INVERSE_VIEWPROJ_MATRIX,
	766	/** Provides transpose of concatenated view and projection matrices.
	767	Equivalent to RenderMonkey's "ViewProjectionTranspose".
	768	*/
	769	ACT_TRANSPOSE_VIEWPROJ_MATRIX,
	770	/** Provides inverse transpose of concatenated view and projection matrices.
	771	Equivalent to RenderMonkey's "ViewProjectionInverseTranspose".
	772	*/
	773	ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX,
	774
	775
	776	/// The current world & view matrices concatenated
	777	ACT_WORLDVIEW_MATRIX,
	778	/// The current world & view matrices concatenated, then inverted
	779	ACT_INVERSE_WORLDVIEW_MATRIX,
	780	/** Provides transpose of concatenated world and view matrices.
	781	Equivalent to RenderMonkey's "WorldViewTranspose".
	782	*/
	783	ACT_TRANSPOSE_WORLDVIEW_MATRIX,
	784	/// The current world & view matrices concatenated, then inverted & transposed
	785	ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX,
	786	/// view matrices.
	787
	788
	789	/// The current world, view & projection matrices concatenated
	790	ACT_WORLDVIEWPROJ_MATRIX,
	791	/** Provides inverse of concatenated world, view and projection matrices.
	792	Equivalent to RenderMonkey's "WorldViewProjectionInverse".
	793	*/
	794	ACT_INVERSE_WORLDVIEWPROJ_MATRIX,
	795	/** Provides transpose of concatenated world, view and projection matrices.
	796	Equivalent to RenderMonkey's "WorldViewProjectionTranspose".
	797	*/
	798	ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
	799	/** Provides inverse transpose of concatenated world, view and projection
	800	matrices. Equivalent to RenderMonkey's "WorldViewProjectionInverseTranspose".
	801	*/
	802	ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
	803
	804
	805	/// render target related values
	806	/** -1 if requires texture flipping, +1 otherwise. It's useful when you bypassed
	807	projection matrix transform, still able use this value to adjust transformed y position.
	808	*/
	809	ACT_RENDER_TARGET_FLIPPING,
	810
	811	/** -1 if the winding has been inverted (e.g. for reflections), +1 otherwise.
	812	*/
	813	ACT_VERTEX_WINDING,
	814
	815	/// Fog colour
	816	ACT_FOG_COLOUR,
	817	/// Fog params: density, linear start, linear end, 1/(end-start)
	818	ACT_FOG_PARAMS,
	819
	820
	821	/// Surface ambient colour, as set in Pass::setAmbient
	822	ACT_SURFACE_AMBIENT_COLOUR,
	823	/// Surface diffuse colour, as set in Pass::setDiffuse
	824	ACT_SURFACE_DIFFUSE_COLOUR,
	825	/// Surface specular colour, as set in Pass::setSpecular
	826	ACT_SURFACE_SPECULAR_COLOUR,
	827	/// Surface emissive colour, as set in Pass::setSelfIllumination
	828	ACT_SURFACE_EMISSIVE_COLOUR,
	829	/// Surface shininess, as set in Pass::setShininess
	830	ACT_SURFACE_SHININESS,
	831	/// Surface alpha rejection value, not as set in Pass::setAlphaRejectionValue, but a floating number between 0.0f and 1.0f instead (255.0f / Pass::getAlphaRejectionValue())
	832	ACT_SURFACE_ALPHA_REJECTION_VALUE,
	833
	834
	835	/// The number of active light sources (better than gl_MaxLights)
	836	ACT_LIGHT_COUNT,
	837
	838
	839	/// The ambient light colour set in the scene
	840	ACT_AMBIENT_LIGHT_COLOUR,
	841
	842	/// Light diffuse colour (index determined by setAutoConstant call)
	843	ACT_LIGHT_DIFFUSE_COLOUR,
	844	/// Light specular colour (index determined by setAutoConstant call)
	845	ACT_LIGHT_SPECULAR_COLOUR,
	846	/// Light attenuation parameters, Vector4(range, constant, linear, quadric)
	847	ACT_LIGHT_ATTENUATION,
	848	/** Spotlight parameters, Vector4(innerFactor, outerFactor, falloff, isSpot)
	849	innerFactor and outerFactor are cos(angle/2)
	850	The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.
	851	Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively
	852	*/
	853	ACT_SPOTLIGHT_PARAMS,
	854	/// A light position in world space (index determined by setAutoConstant call)
	855	ACT_LIGHT_POSITION,
	856	/// A light position in object space (index determined by setAutoConstant call)
	857	ACT_LIGHT_POSITION_OBJECT_SPACE,
	858	/// A light position in view space (index determined by setAutoConstant call)
	859	ACT_LIGHT_POSITION_VIEW_SPACE,
	860	/// A light direction in world space (index determined by setAutoConstant call)
	861	ACT_LIGHT_DIRECTION,
	862	/// A light direction in object space (index determined by setAutoConstant call)
	863	ACT_LIGHT_DIRECTION_OBJECT_SPACE,
	864	/// A light direction in view space (index determined by setAutoConstant call)
	865	ACT_LIGHT_DIRECTION_VIEW_SPACE,
	866	/** The distance of the light from the center of the object
	867	a useful approximation as an alternative to per-vertex distance
	868	calculations.
	869	*/
	870	ACT_LIGHT_DISTANCE_OBJECT_SPACE,
	871	/** Light power level, a single scalar as set in Light::setPowerScale (index determined by setAutoConstant call) */
	872	ACT_LIGHT_POWER_SCALE,
	873	/// Light diffuse colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call)
	874	ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED,
	875	/// Light specular colour pre-scaled by Light::setPowerScale (index determined by setAutoConstant call)
	876	ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED,
	877	/// Array of light diffuse colours (count set by extra param)
	878	ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,
	879	/// Array of light specular colours (count set by extra param)
	880	ACT_LIGHT_SPECULAR_COLOUR_ARRAY,
	881	/// Array of light diffuse colours scaled by light power (count set by extra param)
	882	ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY,
	883	/// Array of light specular colours scaled by light power (count set by extra param)
	884	ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY,
	885	/// Array of light attenuation parameters, Vector4(range, constant, linear, quadric) (count set by extra param)
	886	ACT_LIGHT_ATTENUATION_ARRAY,
	887	/// Array of light positions in world space (count set by extra param)
	888	ACT_LIGHT_POSITION_ARRAY,
	889	/// Array of light positions in object space (count set by extra param)
	890	ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,
	891	/// Array of light positions in view space (count set by extra param)
	892	ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY,
	893	/// Array of light directions in world space (count set by extra param)
	894	ACT_LIGHT_DIRECTION_ARRAY,
	895	/// Array of light directions in object space (count set by extra param)
	896	ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY,
	897	/// Array of light directions in view space (count set by extra param)
	898	ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,
	899	/** Array of distances of the lights from the center of the object
	900	a useful approximation as an alternative to per-vertex distance
	901	calculations. (count set by extra param)
	902	*/
	903	ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY,
	904	/** Array of light power levels, a single scalar as set in Light::setPowerScale
	905	(count set by extra param)
	906	*/
	907	ACT_LIGHT_POWER_SCALE_ARRAY,
	908	/** Spotlight parameters array of Vector4(innerFactor, outerFactor, falloff, isSpot)
	909	innerFactor and outerFactor are cos(angle/2)
	910	The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.
	911	Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively.
	912	(count set by extra param)
	913	*/
	914	ACT_SPOTLIGHT_PARAMS_ARRAY,
	915
	916	/** The derived ambient light colour, with 'r', 'g', 'b' components filled with
	917	product of surface ambient colour and ambient light colour, respectively,
	918	and 'a' component filled with surface ambient alpha component.
	919	*/
	920	ACT_DERIVED_AMBIENT_LIGHT_COLOUR,
	921	/** The derived scene colour, with 'r', 'g' and 'b' components filled with sum
	922	of derived ambient light colour and surface emissive colour, respectively,
	923	and 'a' component filled with surface diffuse alpha component.
	924	*/
	925	ACT_DERIVED_SCENE_COLOUR,
	926
	927	/** The derived light diffuse colour (index determined by setAutoConstant call),
	928	with 'r', 'g' and 'b' components filled with product of surface diffuse colour,
	929	light power scale and light diffuse colour, respectively, and 'a' component filled with surface
	930	diffuse alpha component.
	931	*/
	932	ACT_DERIVED_LIGHT_DIFFUSE_COLOUR,
	933	/** The derived light specular colour (index determined by setAutoConstant call),
	934	with 'r', 'g' and 'b' components filled with product of surface specular colour
	935	and light specular colour, respectively, and 'a' component filled with surface
	936	specular alpha component.
	937	*/
	938	ACT_DERIVED_LIGHT_SPECULAR_COLOUR,
	939
	940	/// Array of derived light diffuse colours (count set by extra param)
	941	ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,
	942	/// Array of derived light specular colours (count set by extra param)
	943	ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY,
	944	/** The absolute light number of a local light index. Each pass may have
	945	a number of lights passed to it, and each of these lights will have
	946	an index in the overall light list, which will differ from the local
	947	light index due to factors like setStartLight and setIteratePerLight.
	948	This binding provides the global light index for a local index.
	949	*/
	950	ACT_LIGHT_NUMBER,
	951	/// Returns (int) 1 if the given light casts shadows, 0 otherwise (index set in extra param)
	952	ACT_LIGHT_CASTS_SHADOWS,
	953	/// Returns (int) 1 if the given light casts shadows, 0 otherwise (index set in extra param)
	954	ACT_LIGHT_CASTS_SHADOWS_ARRAY,
	955
	956
	957	/** The distance a shadow volume should be extruded when using
	958	finite extrusion programs.
	959	*/
	960	ACT_SHADOW_EXTRUSION_DISTANCE,
	961	/// The current camera's position in world space
	962	ACT_CAMERA_POSITION,
	963	/// The current camera's position in object space
	964	ACT_CAMERA_POSITION_OBJECT_SPACE,
	965	/// The view/projection matrix of the assigned texture projection frustum
	966	ACT_TEXTURE_VIEWPROJ_MATRIX,
	967	/// Array of view/projection matrices of the first n texture projection frustums
	968	ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY,
	969	/** The view/projection matrix of the assigned texture projection frustum,
	970	combined with the current world matrix
	971	*/
	972	ACT_TEXTURE_WORLDVIEWPROJ_MATRIX,
	973	/// Array of world/view/projection matrices of the first n texture projection frustums
	974	ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY,
	975	/// The view/projection matrix of a given spotlight
	976	ACT_SPOTLIGHT_VIEWPROJ_MATRIX,
	977	/// Array of view/projection matrix of a given spotlight
	978	ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY,
	979	/** The view/projection matrix of a given spotlight projection frustum,
	980	combined with the current world matrix
	981	*/
	982	ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX,
	983	/** An array of the view/projection matrix of a given spotlight projection frustum,
	984	combined with the current world matrix
	985	*/
	986	ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX_ARRAY,
	987	/// A custom parameter which will come from the renderable, using 'data' as the identifier
	988	ACT_CUSTOM,
	989	/** provides current elapsed time
	990	*/
	991	ACT_TIME,
	992	/** Single float value, which repeats itself based on given as
	993	parameter "cycle time". Equivalent to RenderMonkey's "Time0_X".
	994	*/
	995	ACT_TIME_0_X,
	996	/// Cosine of "Time0_X". Equivalent to RenderMonkey's "CosTime0_X".
	997	ACT_COSTIME_0_X,
	998	/// Sine of "Time0_X". Equivalent to RenderMonkey's "SinTime0_X".
	999	ACT_SINTIME_0_X,
	1000	/// Tangent of "Time0_X". Equivalent to RenderMonkey's "TanTime0_X".
	1001	ACT_TANTIME_0_X,
	1002	/** Vector of "Time0_X", "SinTime0_X", "CosTime0_X",
	1003	"TanTime0_X". Equivalent to RenderMonkey's "Time0_X_Packed".
	1004	*/
	1005	ACT_TIME_0_X_PACKED,
	1006	/** Single float value, which represents scaled time value [0..1],
	1007	which repeats itself based on given as parameter "cycle time".
	1008	Equivalent to RenderMonkey's "Time0_1".
	1009	*/
	1010	ACT_TIME_0_1,
	1011	/// Cosine of "Time0_1". Equivalent to RenderMonkey's "CosTime0_1".
	1012	ACT_COSTIME_0_1,
	1013	/// Sine of "Time0_1". Equivalent to RenderMonkey's "SinTime0_1".
	1014	ACT_SINTIME_0_1,
	1015	/// Tangent of "Time0_1". Equivalent to RenderMonkey's "TanTime0_1".
	1016	ACT_TANTIME_0_1,
	1017	/** Vector of "Time0_1", "SinTime0_1", "CosTime0_1",
	1018	"TanTime0_1". Equivalent to RenderMonkey's "Time0_1_Packed".
	1019	*/
	1020	ACT_TIME_0_1_PACKED,
	1021	/** Single float value, which represents scaled time value [0..2*Pi],
	1022	which repeats itself based on given as parameter "cycle time".
	1023	Equivalent to RenderMonkey's "Time0_2PI".
	1024	*/
	1025	ACT_TIME_0_2PI,
	1026	/// Cosine of "Time0_2PI". Equivalent to RenderMonkey's "CosTime0_2PI".
	1027	ACT_COSTIME_0_2PI,
	1028	/// Sine of "Time0_2PI". Equivalent to RenderMonkey's "SinTime0_2PI".
	1029	ACT_SINTIME_0_2PI,
	1030	/// Tangent of "Time0_2PI". Equivalent to RenderMonkey's "TanTime0_2PI".
	1031	ACT_TANTIME_0_2PI,
	1032	/** Vector of "Time0_2PI", "SinTime0_2PI", "CosTime0_2PI",
	1033	"TanTime0_2PI". Equivalent to RenderMonkey's "Time0_2PI_Packed".
	1034	*/
	1035	ACT_TIME_0_2PI_PACKED,
	1036	/// provides the scaled frame time, returned as a floating point value.
	1037	ACT_FRAME_TIME,
	1038	/// provides the calculated frames per second, returned as a floating point value.
	1039	ACT_FPS,
	1040	/// viewport-related values
	1041	/** Current viewport width (in pixels) as floating point value.
	1042	Equivalent to RenderMonkey's "ViewportWidth".
	1043	*/
	1044	ACT_VIEWPORT_WIDTH,
	1045	/** Current viewport height (in pixels) as floating point value.
	1046	Equivalent to RenderMonkey's "ViewportHeight".
	1047	*/
	1048	ACT_VIEWPORT_HEIGHT,
	1049	/** This variable represents 1.0/ViewportWidth.
	1050	Equivalent to RenderMonkey's "ViewportWidthInverse".
	1051	*/
	1052	ACT_INVERSE_VIEWPORT_WIDTH,
	1053	/** This variable represents 1.0/ViewportHeight.
	1054	Equivalent to RenderMonkey's "ViewportHeightInverse".
	1055	*/
	1056	ACT_INVERSE_VIEWPORT_HEIGHT,
	1057	/** Packed of "ViewportWidth", "ViewportHeight", "ViewportWidthInverse",
	1058	"ViewportHeightInverse".
	1059	*/
	1060	ACT_VIEWPORT_SIZE,
	1061
	1062	/// view parameters
	1063	/** This variable provides the view direction vector (world space).
	1064	Equivalent to RenderMonkey's "ViewDirection".
	1065	*/
	1066	ACT_VIEW_DIRECTION,
	1067	/** This variable provides the view side vector (world space).
	1068	Equivalent to RenderMonkey's "ViewSideVector".
	1069	*/
	1070	ACT_VIEW_SIDE_VECTOR,
	1071	/** This variable provides the view up vector (world space).
	1072	Equivalent to RenderMonkey's "ViewUpVector".
	1073	*/
	1074	ACT_VIEW_UP_VECTOR,
	1075	/** This variable provides the field of view as a floating point value.
	1076	Equivalent to RenderMonkey's "FOV".
	1077	*/
	1078	ACT_FOV,
	1079	/** This variable provides the near clip distance as a floating point value.
	1080	Equivalent to RenderMonkey's "NearClipPlane".
	1081	*/
	1082	ACT_NEAR_CLIP_DISTANCE,
	1083	/** This variable provides the far clip distance as a floating point value.
	1084	Equivalent to RenderMonkey's "FarClipPlane".
	1085	*/
	1086	ACT_FAR_CLIP_DISTANCE,
	1087
	1088	/** provides the pass index number within the technique
	1089	of the active materil.
	1090	*/
	1091	ACT_PASS_NUMBER,
	1092
	1093	/** provides the current iteration number of the pass. The iteration
	1094	number is the number of times the current render operation has
	1095	been drawn for the active pass.
	1096	*/
	1097	ACT_PASS_ITERATION_NUMBER,
	1098
	1099
	1100	/** Provides a parametric animation value [0..1], only available
	1101	where the renderable specifically implements it.
	1102	*/
	1103	ACT_ANIMATION_PARAMETRIC,
	1104
	1105	/** Provides the texel offsets required by this rendersystem to map
	1106	texels to pixels. Packed as
	1107	float4(absoluteHorizontalOffset, absoluteVerticalOffset,
	1108	horizontalOffset / viewportWidth, verticalOffset / viewportHeight)
	1109	*/
	1110	ACT_TEXEL_OFFSETS,
	1111
	1112	/** Provides information about the depth range of the scene as viewed
	1113	from the current camera.
	1114	Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)
	1115	*/
	1116	ACT_SCENE_DEPTH_RANGE,
	1117
	1118	/** Provides information about the depth range of the scene as viewed
	1119	from a given shadow camera. Requires an index parameter which maps
	1120	to a light index relative to the current light list.
	1121	Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)
	1122	*/
	1123	ACT_SHADOW_SCENE_DEPTH_RANGE,
	1124
	1125	/** Provides an array of information about the depth range of the scene as viewed
	1126	from a given shadow camera. Requires an index parameter which maps
	1127	to a light index relative to the current light list.
	1128	Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)
	1129	*/
	1130	ACT_SHADOW_SCENE_DEPTH_RANGE_ARRAY,
	1131
	1132	/** Provides the fixed shadow colour as configured via SceneManager::setShadowColour;
	1133	useful for integrated modulative shadows.
	1134	*/
	1135	ACT_SHADOW_COLOUR,
	1136	/** Provides texture size of the texture unit (index determined by setAutoConstant
	1137	call). Packed as float4(width, height, depth, 1)
	1138	*/
	1139	ACT_TEXTURE_SIZE,
	1140	/** Provides inverse texture size of the texture unit (index determined by setAutoConstant
	1141	call). Packed as float4(1 / width, 1 / height, 1 / depth, 1)
	1142	*/
	1143	ACT_INVERSE_TEXTURE_SIZE,
	1144	/** Provides packed texture size of the texture unit (index determined by setAutoConstant
	1145	call). Packed as float4(width, height, 1 / width, 1 / height)
	1146	*/
	1147	ACT_PACKED_TEXTURE_SIZE,
	1148
	1149	/** Provides the current transform matrix of the texture unit (index determined by setAutoConstant
	1150	call), as seen by the fixed-function pipeline.
	1151	*/
	1152	ACT_TEXTURE_MATRIX,
	1153
	1154	/** Provides the position of the LOD camera in world space, allowing you
	1155	to perform separate LOD calculations in shaders independent of the rendering
	1156	camera. If there is no separate LOD camera then this is the real camera
	1157	position. See Camera::setLodCamera.
	1158	*/
	1159	ACT_LOD_CAMERA_POSITION,
	1160	/** Provides the position of the LOD camera in object space, allowing you
	1161	to perform separate LOD calculations in shaders independent of the rendering
	1162	camera. If there is no separate LOD camera then this is the real camera
	1163	position. See Camera::setLodCamera.
	1164	*/
	1165	ACT_LOD_CAMERA_POSITION_OBJECT_SPACE,
	1166	/** Binds custom per-light constants to the shaders. */
	1167	ACT_LIGHT_CUSTOM,
	1168
	1169	ACT_UNKNOWN = 999
	1170	};
	1171
	1172	/** Defines the type of the extra data item used by the auto constant.
	1173
	1174	*/
	1175	enum ACDataType {
	1176	/// no data is required
	1177	ACDT_NONE,
	1178	/// the auto constant requires data of type int
	1179	ACDT_INT,
	1180	/// the auto constant requires data of type real
	1181	ACDT_REAL
	1182	};
	1183
	1184	/** Defines the base element type of the auto constant
	1185	*/
	1186	enum ElementType {
	1187	ET_INT,
	1188	ET_REAL
	1189	};
	1190
	1191	/** Structure defining an auto constant that's available for use in
	1192	a parameters object.
	1193	*/
	1194	struct AutoConstantDefinition
	1195	{
	1196	AutoConstantType acType;
	1197	String name;
	1198	size_t elementCount;
	1199	/// The type of the constant in the program
	1200	ElementType elementType;
	1201	/// The type of any extra data
	1202	ACDataType dataType;
	1203
	1204	AutoConstantDefinition(AutoConstantType _acType, const String& _name,
	1205	size_t _elementCount, ElementType _elementType,
	1206	ACDataType _dataType)
	1207	:acType(_acType), name(_name), elementCount(_elementCount),
	1208	elementType(_elementType), dataType(_dataType)
	1209	{
	1210
	1211	}
	1212	};
	1213
	1214	/** Structure recording the use of an automatic parameter. */
	1215	class AutoConstantEntry
	1216	{
	1217	public:
	1218	/// The type of parameter
	1219	AutoConstantType paramType;
	1220	/// The target (physical) constant index
	1221	size_t physicalIndex;
	1222	/** The number of elements per individual entry in this constant
	1223	Used in case people used packed elements smaller than 4 (e.g. GLSL)
	1224	and bind an auto which is 4-element packed to it */
	1225	size_t elementCount;
	1226	/// Additional information to go with the parameter
	1227	union{
	1228	size_t data;
	1229	Real fData;
	1230	};
	1231	/// The variability of this parameter (see GpuParamVariability)
	1232	uint16 variability;
	1233
	1234	AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData,
	1235	uint16 theVariability, size_t theElemCount = 4)
	1236	: paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
	1237	data(theData), variability(theVariability) {}
	1238
	1239	AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData,
	1240	uint16 theVariability, size_t theElemCount = 4)
	1241	: paramType(theType), physicalIndex(theIndex), elementCount(theElemCount),
	1242	fData(theData), variability(theVariability) {}
	1243
	1244	};
	1245	// Auto parameter storage
	1246	typedef vector<AutoConstantEntry>::type AutoConstantList;
	1247
	1248	typedef vector<GpuSharedParametersUsage>::type GpuSharedParamUsageList;
	1249
	1250	// Map that store subroutines associated with slots
	1251	typedef HashMap<unsigned int, String> SubroutineMap;
	1252	typedef HashMap<unsigned int, String>::const_iterator SubroutineIterator;
	1253
	1254	protected:
	1255	SubroutineMap mSubroutineMap;
	1256
	1257	static AutoConstantDefinition AutoConstantDictionary[];
	1258	/// Packed list of floating-point constants (physical indexing)
	1259	FloatConstantList mFloatConstants;
	1260	/// Packed list of double-point constants (physical indexing)
	1261	DoubleConstantList mDoubleConstants;
	1262	/// Packed list of integer constants (physical indexing)
	1263	IntConstantList mIntConstants;
	1264	/** Logical index to physical index map - for low-level programs
	1265	or high-level programs which pass params this way. */
	1266	GpuLogicalBufferStructPtr mFloatLogicalToPhysical;
	1267	/** Logical index to physical index map - for low-level programs
	1268	or high-level programs which pass params this way. */
	1269	GpuLogicalBufferStructPtr mDoubleLogicalToPhysical;
	1270	/** Logical index to physical index map - for low-level programs
	1271	or high-level programs which pass params this way. */
	1272	GpuLogicalBufferStructPtr mIntLogicalToPhysical;
	1273	/// Mapping from parameter names to def - high-level programs are expected to populate this
	1274	GpuNamedConstantsPtr mNamedConstants;
	1275	/// List of automatically updated parameters
	1276	AutoConstantList mAutoConstants;
	1277	/// The combined variability masks of all parameters
	1278	uint16 mCombinedVariability;
	1279	/// Do we need to transpose matrices?
	1280	bool mTransposeMatrices;
	1281	/// flag to indicate if names not found will be ignored
	1282	bool mIgnoreMissingParams;
	1283	/// physical index for active pass iteration parameter real constant entry;
	1284	size_t mActivePassIterationIndex;
	1285
	1286	/** Gets the low-level structure for a logical index.
	1287	*/
	1288	GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
	1289	/** Gets the low-level structure for a logical index.
	1290	*/
	1291	GpuLogicalIndexUse* _getDoubleConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
	1292	/** Gets the physical buffer index associated with a logical int constant index.
	1293	*/
	1294	GpuLogicalIndexUse* _getIntConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
	1295
	1296	/// Return the variability for an auto constant
	1297	uint16 deriveVariability(AutoConstantType act);
	1298
	1299	void copySharedParamSetUsage(const GpuSharedParamUsageList& srcList);
	1300
	1301	GpuSharedParamUsageList mSharedParamSets;
	1302
	1303	// Optional data the rendersystem might want to store
	1304	mutable Any mRenderSystemData;
	1305
	1306
	1307
	1308	public:
	1309	GpuProgramParameters();
	1310	~GpuProgramParameters() {}
	1311
	1312	/// Copy constructor
	1313	GpuProgramParameters(const GpuProgramParameters& oth);
	1314	/// Operator = overload
	1315	GpuProgramParameters& operator=(const GpuProgramParameters& oth);
	1316
	1317	/** Internal method for providing a link to a name->definition map for parameters. */
	1318	void _setNamedConstants(const GpuNamedConstantsPtr& constantmap);
	1319
	1320	/** Internal method for providing a link to a logical index->physical index map for parameters. */
	1321	void _setLogicalIndexes(const GpuLogicalBufferStructPtr& floatIndexMap, const GpuLogicalBufferStructPtr& doubleIndexMap,
	1322	const GpuLogicalBufferStructPtr& intIndexMap);
	1323
	1324
	1325	/// Does this parameter set include named parameters?
	1326	bool hasNamedParameters() const { return !mNamedConstants.isNull(); }
	1327	/** Does this parameter set include logically indexed parameters?
	1328	@note Not mutually exclusive with hasNamedParameters since some high-level
	1329	programs still use logical indexes to set the parameters on the
	1330	rendersystem.
	1331	*/
	1332	bool hasLogicalIndexedParameters() const { return !mFloatLogicalToPhysical.isNull(); }
	1333
	1334	/** Sets a 4-element floating-point parameter to the program.
	1335	@param index The logical constant index at which to place the parameter
	1336	(each constant is a 4D float)
	1337	@param vec The value to set
	1338	*/
	1339	void setConstant(size_t index, const Vector4& vec);
	1340	/** Sets a single floating-point parameter to the program.
	1341	@note This is actually equivalent to calling
	1342	setConstant(index Vector4(val, 0, 0, 0)) since all constants are 4D.
	1343	@param index The logical constant index at which to place the parameter (each constant is
	1344	a 4D float)
	1345	@param val The value to set
	1346	*/
	1347	void setConstant(size_t index, Real val);
	1348	/** Sets a 4-element floating-point parameter to the program via Vector3.
	1349	@param index The logical constant index at which to place the parameter (each constant is
	1350	a 4D float).
	1351	Note that since you're passing a Vector3, the last element of the 4-element
	1352	value will be set to 1 (a homogeneous vector)
	1353	@param vec The value to set
	1354	*/
	1355	void setConstant(size_t index, const Vector3& vec);
	1356	/** Sets a 4-element floating-point parameter to the program via Vector2.
	1357	@param index The logical constant index at which to place the parameter (each constant is
	1358	a 4D float).
	1359	Note that since you're passing a Vector2, the last 2 elements of the 4-element
	1360	value will be set to 1 (a homogeneous vector)
	1361	@param vec The value to set
	1362	*/
	1363	void setConstant(size_t index, const Vector2& vec);
	1364	/** Sets a Matrix4 parameter to the program.
	1365	@param index The logical constant index at which to place the parameter (each constant is
	1366	a 4D float).
	1367	NB since a Matrix4 is 16 floats long, this parameter will take up 4 indexes.
	1368	@param m The value to set
	1369	*/
	1370	void setConstant(size_t index, const Matrix4& m);
	1371	/** Sets a list of Matrix4 parameters to the program.
	1372	@param index The logical constant index at which to start placing the parameter (each constant is
	1373	a 4D float).
	1374	NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
	1375	@param m Pointer to an array of matrices to set
	1376	@param numEntries Number of Matrix4 entries
	1377	*/
	1378	void setConstant(size_t index, const Matrix4* m, size_t numEntries);
	1379	/** Sets a multiple value constant floating-point parameter to the program.
	1380	@param index The logical constant index at which to start placing parameters (each constant is
	1381	a 4D float)
	1382	@param val Pointer to the values to write, must contain 4*count floats
	1383	@param count The number of groups of 4 floats to write
	1384	*/
	1385	void setConstant(size_t index, const float *val, size_t count);
	1386	/** Sets a multiple value constant floating-point parameter to the program.
	1387	@param index The logical constant index at which to start placing parameters (each constant is
	1388	a 4D float)
	1389	@param val Pointer to the values to write, must contain 4*count floats
	1390	@param count The number of groups of 4 floats to write
	1391	*/
	1392	void setConstant(size_t index, const double *val, size_t count);
	1393	/** Sets a ColourValue parameter to the program.
	1394	@param index The logical constant index at which to place the parameter (each constant is
	1395	a 4D float)
	1396	@param colour The value to set
	1397	*/
	1398	void setConstant(size_t index, const ColourValue& colour);
	1399
	1400	/** Sets a multiple value constant integer parameter to the program.
	1401	@remarks
	1402	Different types of GPU programs support different types of constant parameters.
	1403	For example, it's relatively common to find that vertex programs only support
	1404	floating point constants, and that fragment programs only support integer (fixed point)
	1405	parameters. This can vary depending on the program version supported by the
	1406	graphics card being used. You should consult the documentation for the type of
	1407	low level program you are using, or alternatively use the methods
	1408	provided on RenderSystemCapabilities to determine the options.
	1409	@param index The logical constant index at which to place the parameter (each constant is
	1410	a 4D integer)
	1411	@param val Pointer to the values to write, must contain 4*count ints
	1412	@param count The number of groups of 4 ints to write
	1413	*/
	1414	void setConstant(size_t index, const int *val, size_t count);
	1415
	1416	/** Write a series of floating point values into the underlying float
	1417	constant buffer at the given physical index.
	1418	@param physicalIndex The buffer position to start writing
	1419	@param val Pointer to a list of values to write
	1420	@param count The number of floats to write
	1421	*/
	1422	void _writeRawConstants(size_t physicalIndex, const float* val, size_t count);
	1423	/** Write a series of floating point values into the underlying float
	1424	constant buffer at the given physical index.
	1425	@param physicalIndex The buffer position to start writing
	1426	@param val Pointer to a list of values to write
	1427	@param count The number of floats to write
	1428	*/
	1429	void _writeRawConstants(size_t physicalIndex, const double* val, size_t count);
	1430	/** Write a series of integer values into the underlying integer
	1431	constant buffer at the given physical index.
	1432	@param physicalIndex The buffer position to start writing
	1433	@param val Pointer to a list of values to write
	1434	@param count The number of ints to write
	1435	*/
	1436	void _writeRawConstants(size_t physicalIndex, const int* val, size_t count);
	1437	/** Read a series of floating point values from the underlying float
	1438	constant buffer at the given physical index.
	1439	@param physicalIndex The buffer position to start reading
	1440	@param count The number of floats to read
	1441	@param dest Pointer to a buffer to receive the values
	1442	*/
	1443	void _readRawConstants(size_t physicalIndex, size_t count, float* dest);
	1444	/** Read a series of integer values from the underlying integer
	1445	constant buffer at the given physical index.
	1446	@param physicalIndex The buffer position to start reading
	1447	@param count The number of ints to read
	1448	@param dest Pointer to a buffer to receive the values
	1449	*/
	1450	void _readRawConstants(size_t physicalIndex, size_t count, int* dest);
	1451
	1452	/** Write a 4-element floating-point parameter to the program directly to
	1453	the underlying constants buffer.
	1454	@note You can use these methods if you have already derived the physical
	1455	constant buffer location, for a slight speed improvement over using
	1456	the named / logical index versions.
	1457	@param physicalIndex The physical buffer index at which to place the parameter
	1458	@param vec The value to set
	1459	@param count The number of floats to write; if for example
	1460	the uniform constant 'slot' is smaller than a Vector4
	1461	*/
	1462	void _writeRawConstant(size_t physicalIndex, const Vector4& vec,
	1463	size_t count = 4);
	1464	/** Write a single floating-point parameter to the program.
	1465	@note You can use these methods if you have already derived the physical
	1466	constant buffer location, for a slight speed improvement over using
	1467	the named / logical index versions.
	1468	@param physicalIndex The physical buffer index at which to place the parameter
	1469	@param val The value to set
	1470	*/
	1471	void _writeRawConstant(size_t physicalIndex, Real val);
	1472	/** Write a variable number of floating-point parameters to the program.
	1473	@note You can use these methods if you have already derived the physical
	1474	constant buffer location, for a slight speed improvement over using
	1475	the named / logical index versions.
	1476	@param physicalIndex The physical buffer index at which to place the parameter
	1477	@param val The value to set
	1478	*/
	1479	void _writeRawConstant(size_t physicalIndex, Real val, size_t count);
	1480	/** Write a single integer parameter to the program.
	1481	@note You can use these methods if you have already derived the physical
	1482	constant buffer location, for a slight speed improvement over using
	1483	the named / logical index versions.
	1484	@param physicalIndex The physical buffer index at which to place the parameter
	1485	@param val The value to set
	1486	*/
	1487	void _writeRawConstant(size_t physicalIndex, int val);
	1488	/** Write a 3-element floating-point parameter to the program via Vector3.
	1489	@note You can use these methods if you have already derived the physical
	1490	constant buffer location, for a slight speed improvement over using
	1491	the named / logical index versions.
	1492	@param physicalIndex The physical buffer index at which to place the parameter
	1493	@param vec The value to set
	1494	*/
	1495	void _writeRawConstant(size_t physicalIndex, const Vector3& vec);
	1496	/** Write a 2-element floating-point parameter to the program via Vector2.
	1497	@note You can use these methods if you have already derived the physical
	1498	constant buffer location, for a slight speed improvement over using
	1499	the named / logical index versions.
	1500	@param physicalIndex The physical buffer index at which to place the parameter
	1501	@param vec The value to set
	1502	*/
	1503	void _writeRawConstant(size_t physicalIndex, const Vector2& vec);
	1504	/** Write a Matrix4 parameter to the program.
	1505	@note You can use these methods if you have already derived the physical
	1506	constant buffer location, for a slight speed improvement over using
	1507	the named / logical index versions.
	1508	@param physicalIndex The physical buffer index at which to place the parameter
	1509	@param m The value to set
	1510	@param elementCount actual element count used with shader
	1511	*/
	1512	void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount);
	1513	/** Write a list of Matrix4 parameters to the program.
	1514	@note You can use these methods if you have already derived the physical
	1515	constant buffer location, for a slight speed improvement over using
	1516	the named / logical index versions.
	1517	@param physicalIndex The physical buffer index at which to place the parameter
	1518	@param numEntries Number of Matrix4 entries
	1519	*/
	1520	void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries);
	1521	/** Write a ColourValue parameter to the program.
	1522	@note You can use these methods if you have already derived the physical
	1523	constant buffer location, for a slight speed improvement over using
	1524	the named / logical index versions.
	1525	@param physicalIndex The physical buffer index at which to place the parameter
	1526	@param colour The value to set
	1527	@param count The number of floats to write; if for example
	1528	the uniform constant 'slot' is smaller than a Vector4
	1529	*/
	1530	void _writeRawConstant(size_t physicalIndex, const ColourValue& colour,
	1531	size_t count = 4);
	1532
	1533
	1534	/** Gets an iterator over the named GpuConstantDefinition instances as defined
	1535	by the program for which these parameters exist.
	1536	@note
	1537	Only available if this parameters object has named parameters.
	1538	*/
	1539	GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;
	1540
	1541	/** Get a specific GpuConstantDefinition for a named parameter.
	1542	@note
	1543	Only available if this parameters object has named parameters.
	1544	*/
	1545	const GpuConstantDefinition& getConstantDefinition(const String& name) const;
	1546
	1547	/** Get the full list of GpuConstantDefinition instances.
	1548	@note
	1549	Only available if this parameters object has named parameters.
	1550	*/
	1551	const GpuNamedConstants& getConstantDefinitions() const;
	1552
	1553	/** Get the current list of mappings from low-level logical param indexes
	1554	to physical buffer locations in the float buffer.
	1555	@note
	1556	Only applicable to low-level programs.
	1557	*/
	1558	const GpuLogicalBufferStructPtr& getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; }
	1559
	1560	/** Retrieves the logical index relating to a physical index in the float
	1561	buffer, for programs which support that (low-level programs and
	1562	high-level programs which use logical parameter indexes).
	1563	@return std::numeric_limits<size_t>::max() if not found
	1564	*/
	1565	size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex);
	1566	/** Retrieves the logical index relating to a physical index in the int
	1567	buffer, for programs which support that (low-level programs and
	1568	high-level programs which use logical parameter indexes).
	1569	@return std::numeric_limits<size_t>::max() if not found
	1570	*/
	1571	/** Get the current list of mappings from low-level logical param indexes
	1572	to physical buffer locations in the double buffer.
	1573	@note
	1574	Only applicable to low-level programs.
	1575	*/
	1576	const GpuLogicalBufferStructPtr& getDoubleLogicalBufferStruct() const { return mDoubleLogicalToPhysical; }
	1577
	1578	/** Retrieves the logical index relating to a physical index in the double
	1579	buffer, for programs which support that (low-level programs and
	1580	high-level programs which use logical parameter indexes).
	1581	@return std::numeric_limits<size_t>::max() if not found
	1582	*/
	1583	size_t getDoubleLogicalIndexForPhysicalIndex(size_t physicalIndex);
	1584	/** Retrieves the logical index relating to a physical index in the int
	1585	buffer, for programs which support that (low-level programs and
	1586	high-level programs which use logical parameter indexes).
	1587	@return std::numeric_limits<size_t>::max() if not found
	1588	*/
	1589	size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex);
	1590
	1591	/** Get the current list of mappings from low-level logical param indexes
	1592	to physical buffer locations in the integer buffer.
	1593	@note
	1594	Only applicable to low-level programs.
	1595	*/
	1596	const GpuLogicalBufferStructPtr& getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; }
	1597	/// Get a reference to the list of float constants
	1598	const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
	1599	/// Get a pointer to the 'nth' item in the float buffer
	1600	float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; }
	1601	/// Get a pointer to the 'nth' item in the float buffer
	1602	const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
	1603	/// Get a reference to the list of double constants
	1604	const DoubleConstantList& getDoubleConstantList() const { return mDoubleConstants; }
	1605	/// Get a pointer to the 'nth' item in the double buffer
	1606	double* getDoublePointer(size_t pos) { return &mDoubleConstants[pos]; }
	1607	/// Get a pointer to the 'nth' item in the double buffer
	1608	const double* getDoublePointer(size_t pos) const { return &mDoubleConstants[pos]; }
	1609	/// Get a reference to the list of int constants
	1610	const IntConstantList& getIntConstantList() const { return mIntConstants; }
	1611	/// Get a pointer to the 'nth' item in the int buffer
	1612	int* getIntPointer(size_t pos) { return &mIntConstants[pos]; }
	1613	/// Get a pointer to the 'nth' item in the int buffer
	1614	const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
	1615	/// Get a reference to the list of auto constant bindings
	1616	const AutoConstantList& getAutoConstantList() const { return mAutoConstants; }
	1617
	1618	/** Sets up a constant which will automatically be updated by the system.
	1619	@remarks
	1620	Vertex and fragment programs often need parameters which are to do with the
	1621	current render state, or particular values which may very well change over time,
	1622	and often between objects which are being rendered. This feature allows you
	1623	to set up a certain number of predefined parameter mappings that are kept up to
	1624	date for you.
	1625	@param index The location in the constant list to place this updated constant every time
	1626	it is changed. Note that because of the nature of the types, we know how big the
	1627	parameter details will be so you don't need to set that like you do for manual constants.
	1628	@param acType The type of automatic constant to set
	1629	@param extraInfo If the constant type needs more information (like a light index) put it here.
	1630	*/
	1631	void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0);
	1632	void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData);
	1633
	1634	/** Sets up a constant which will automatically be updated by the system.
	1635	@remarks
	1636	Vertex and fragment programs often need parameters which are to do with the
	1637	current render state, or particular values which may very well change over time,
	1638	and often between objects which are being rendered. This feature allows you
	1639	to set up a certain number of predefined parameter mappings that are kept up to
	1640	date for you.
	1641	@param index The location in the constant list to place this updated constant every time
	1642	it is changed. Note that because of the nature of the types, we know how big the
	1643	parameter details will be so you don't need to set that like you do for manual constants.
	1644	@param acType The type of automatic constant to set
	1645	@param extraInfo1 The first extra parameter required by the auto constant type
	1646	@param extraInfo2 The first extra parameter required by the auto constant type
	1647	*/
	1648	void setAutoConstant(size_t index, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);
	1649
	1650	/** As setAutoConstant, but sets up the auto constant directly against a
	1651	physical buffer index.
	1652	*/
	1653	void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo,
	1654	uint16 variability, size_t elementSize = 4);
	1655	/** As setAutoConstantReal, but sets up the auto constant directly against a
	1656	physical buffer index.
	1657	*/
	1658	void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData,
	1659	uint16 variability, size_t elementSize = 4);
	1660
	1661
	1662	/** Unbind an auto constant so that the constant is manually controlled again. */
	1663	void clearAutoConstant(size_t index);
	1664
	1665	/** Sets a named parameter up to track a derivation of the current time.
	1666	@param index The index of the parameter
	1667	@param factor The amount by which to scale the time value
	1668	*/
	1669	void setConstantFromTime(size_t index, Real factor);
	1670
	1671	/** Clears all the existing automatic constants. */
	1672	void clearAutoConstants(void);
	1673	typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator;
	1674	/** Gets an iterator over the automatic constant bindings currently in place. */
	1675	AutoConstantIterator getAutoConstantIterator(void) const;
	1676	/// Gets the number of int constants that have been set
	1677	size_t getAutoConstantCount(void) const { return mAutoConstants.size(); }
	1678	/** Gets a specific Auto Constant entry if index is in valid range
	1679	otherwise returns a NULL
	1680	@param index which entry is to be retrieved
	1681	*/
	1682	AutoConstantEntry* getAutoConstantEntry(const size_t index);
	1683	/** Returns true if this instance has any automatic constants. */
	1684	bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); }
	1685	/** Finds an auto constant that's affecting a given logical parameter
	1686	index for floating-point values.
	1687	@note Only applicable for low-level programs.
	1688	*/
	1689	const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex);
	1690	/** Finds an auto constant that's affecting a given logical parameter
	1691	index for double-point values.
	1692	@note Only applicable for low-level programs.
	1693	*/
	1694	const AutoConstantEntry* findDoubleAutoConstantEntry(size_t logicalIndex);
	1695	/** Finds an auto constant that's affecting a given logical parameter
	1696	index for integer values.
	1697	@note Only applicable for low-level programs.
	1698	*/
	1699	const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex);
	1700	/** Finds an auto constant that's affecting a given named parameter index.
	1701	@note Only applicable to high-level programs.
	1702	*/
	1703	const AutoConstantEntry* findAutoConstantEntry(const String& paramName);
	1704	/** Finds an auto constant that's affecting a given physical position in
	1705	the floating-point buffer
	1706	*/
	1707	const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex);
	1708	/** Finds an auto constant that's affecting a given physical position in
	1709	the double-point buffer
	1710	*/
	1711	const AutoConstantEntry* _findRawAutoConstantEntryDouble(size_t physicalIndex);
	1712	/** Finds an auto constant that's affecting a given physical position in
	1713	the integer buffer
	1714	*/
	1715	const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex);
	1716
	1717	/** Update automatic parameters.
	1718	@param source The source of the parameters
	1719	@param variabilityMask A mask of GpuParamVariability which identifies which autos will need updating
	1720	*/
	1721	void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask);
	1722
	1723	/** Tells the program whether to ignore missing parameters or not.
	1724	*/
	1725	void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; }
	1726
	1727	/** Sets a single value constant floating-point parameter to the program.
	1728	@remarks
	1729	Different types of GPU programs support different types of constant parameters.
	1730	For example, it's relatively common to find that vertex programs only support
	1731	floating point constants, and that fragment programs only support integer (fixed point)
	1732	parameters. This can vary depending on the program version supported by the
	1733	graphics card being used. You should consult the documentation for the type of
	1734	low level program you are using, or alternatively use the methods
	1735	provided on RenderSystemCapabilities to determine the options.
	1736	@par
	1737	Another possible limitation is that some systems only allow constants to be set
	1738	on certain boundaries, e.g. in sets of 4 values for example. Again, see
	1739	RenderSystemCapabilities for full details.
	1740	@note
	1741	This named option will only work if you are using a parameters object created
	1742	from a high-level program (HighLevelGpuProgram).
	1743	@param name The name of the parameter
	1744	@param val The value to set
	1745	*/
	1746	void setNamedConstant(const String& name, Real val);
	1747	/** Sets a single value constant integer parameter to the program.
	1748	@remarks
	1749	Different types of GPU programs support different types of constant parameters.
	1750	For example, it's relatively common to find that vertex programs only support
	1751	floating point constants, and that fragment programs only support integer (fixed point)
	1752	parameters. This can vary depending on the program version supported by the
	1753	graphics card being used. You should consult the documentation for the type of
	1754	low level program you are using, or alternatively use the methods
	1755	provided on RenderSystemCapabilities to determine the options.
	1756	@par
	1757	Another possible limitation is that some systems only allow constants to be set
	1758	on certain boundaries, e.g. in sets of 4 values for example. Again, see
	1759	RenderSystemCapabilities for full details.
	1760	@note
	1761	This named option will only work if you are using a parameters object created
	1762	from a high-level program (HighLevelGpuProgram).
	1763	@param name The name of the parameter
	1764	@param val The value to set
	1765	*/
	1766	void setNamedConstant(const String& name, int val);
	1767	/** Sets a Vector4 parameter to the program.
	1768	@param name The name of the parameter
	1769	@param vec The value to set
	1770	*/
	1771	void setNamedConstant(const String& name, const Vector4& vec);
	1772	/** Sets a Vector3 parameter to the program.
	1773	@note
	1774	This named option will only work if you are using a parameters object created
	1775	from a high-level program (HighLevelGpuProgram).
	1776	@param name The name of the parameter
	1777	@param vec The value to set
	1778	*/
	1779	void setNamedConstant(const String& name, const Vector3& vec);
	1780	/** Sets a Vector2 parameter to the program.
	1781	@param name The name of the parameter
	1782	@param vec The value to set
	1783	*/
	1784	void setNamedConstant(const String& name, const Vector2& vec);
	1785	/** Sets a Matrix4 parameter to the program.
	1786	@param name The name of the parameter
	1787	@param m The value to set
	1788	*/
	1789	void setNamedConstant(const String& name, const Matrix4& m);
	1790	/** Sets a list of Matrix4 parameters to the program.
	1791	@param name The name of the parameter; this must be the first index of an array,
	1792	for examples 'matrices[0]'
	1793	NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
	1794	@param m Pointer to an array of matrices to set
	1795	@param numEntries Number of Matrix4 entries
	1796	*/
	1797	void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
	1798	/** Sets a multiple value constant floating-point parameter to the program.
	1799	@par
	1800	Some systems only allow constants to be set on certain boundaries,
	1801	e.g. in sets of 4 values for example. The 'multiple' parameter allows
	1802	you to control that although you should only change it if you know
	1803	your chosen language supports that (at the time of writing, only
	1804	GLSL allows constants which are not a multiple of 4).
	1805	@note
	1806	This named option will only work if you are using a parameters object created
	1807	from a high-level program (HighLevelGpuProgram).
	1808	@param name The name of the parameter
	1809	@param val Pointer to the values to write
	1810	@param count The number of 'multiples' of floats to write
	1811	@param multiple The number of raw entries in each element to write,
	1812	the default is 4 so count = 1 would write 4 floats.
	1813	*/
	1814	void setNamedConstant(const String& name, const float *val, size_t count,
	1815	size_t multiple = 4);
	1816	/** Sets a multiple value constant floating-point parameter to the program.
	1817	@par
	1818	Some systems only allow constants to be set on certain boundaries,
	1819	e.g. in sets of 4 values for example. The 'multiple' parameter allows
	1820	you to control that although you should only change it if you know
	1821	your chosen language supports that (at the time of writing, only
	1822	GLSL allows constants which are not a multiple of 4).
	1823	@note
	1824	This named option will only work if you are using a parameters object created
	1825	from a high-level program (HighLevelGpuProgram).
	1826	@param name The name of the parameter
	1827	@param val Pointer to the values to write
	1828	@param count The number of 'multiples' of floats to write
	1829	@param multiple The number of raw entries in each element to write,
	1830	the default is 4 so count = 1 would write 4 floats.
	1831	*/
	1832	void setNamedConstant(const String& name, const double *val, size_t count,
	1833	size_t multiple = 4);
	1834	/** Sets a ColourValue parameter to the program.
	1835	@param name The name of the parameter
	1836	@param colour The value to set
	1837	*/
	1838	void setNamedConstant(const String& name, const ColourValue& colour);
	1839
	1840	/** Sets a multiple value constant floating-point parameter to the program.
	1841	@par
	1842	Some systems only allow constants to be set on certain boundaries,
	1843	e.g. in sets of 4 values for example. The 'multiple' parameter allows
	1844	you to control that although you should only change it if you know
	1845	your chosen language supports that (at the time of writing, only
	1846	GLSL allows constants which are not a multiple of 4).
	1847	@note
	1848	This named option will only work if you are using a parameters object created
	1849	from a high-level program (HighLevelGpuProgram).
	1850	@param name The name of the parameter
	1851	@param val Pointer to the values to write
	1852	@param count The number of 'multiples' of floats to write
	1853	@param multiple The number of raw entries in each element to write,
	1854	the default is 4 so count = 1 would write 4 floats.
	1855	*/
	1856	void setNamedConstant(const String& name, const int *val, size_t count,
	1857	size_t multiple = 4);
	1858
	1859	/** Sets up a constant which will automatically be updated by the system.
	1860	@remarks
	1861	Vertex and fragment programs often need parameters which are to do with the
	1862	current render state, or particular values which may very well change over time,
	1863	and often between objects which are being rendered. This feature allows you
	1864	to set up a certain number of predefined parameter mappings that are kept up to
	1865	date for you.
	1866	@note
	1867	This named option will only work if you are using a parameters object created
	1868	from a high-level program (HighLevelGpuProgram).
	1869	@param name The name of the parameter
	1870	@param acType The type of automatic constant to set
	1871	@param extraInfo If the constant type needs more information (like a light index) put it here.
	1872	*/
	1873	void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0);
	1874	void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData);
	1875
	1876	/** Sets up a constant which will automatically be updated by the system.
	1877	@remarks
	1878	Vertex and fragment programs often need parameters which are to do with the
	1879	current render state, or particular values which may very well change over time,
	1880	and often between objects which are being rendered. This feature allows you
	1881	to set up a certain number of predefined parameter mappings that are kept up to
	1882	date for you.
	1883	@note
	1884	This named option will only work if you are using a parameters object created
	1885	from a high-level program (HighLevelGpuProgram).
	1886	@param name The name of the parameter
	1887	@param acType The type of automatic constant to set
	1888	@param extraInfo1 The first extra info required by this auto constant type
	1889	@param extraInfo2 The first extra info required by this auto constant type
	1890	*/
	1891	void setNamedAutoConstant(const String& name, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);
	1892
	1893	/** Sets a named parameter up to track a derivation of the current time.
	1894	@note
	1895	This named option will only work if you are using a parameters object created
	1896	from a high-level program (HighLevelGpuProgram).
	1897	@param name The name of the parameter
	1898	@param factor The amount by which to scale the time value
	1899	*/
	1900	void setNamedConstantFromTime(const String& name, Real factor);
	1901
	1902	/** Unbind an auto constant so that the constant is manually controlled again. */
	1903	void clearNamedAutoConstant(const String& name);
	1904
	1905	/** Find a constant definition for a named parameter.
	1906	@remarks
	1907	This method returns null if the named parameter did not exist, unlike
	1908	getConstantDefinition which is more strict; unless you set the
	1909	last parameter to true.
	1910	@param name The name to look up
	1911	@param throwExceptionIfMissing If set to true, failure to find an entry
	1912	will throw an exception.
	1913	*/
	1914	const GpuConstantDefinition* _findNamedConstantDefinition(
	1915	const String& name, bool throwExceptionIfMissing = false) const;
	1916	/** Gets the physical buffer index associated with a logical float constant index.
	1917	@note Only applicable to low-level programs.
	1918	@param logicalIndex The logical parameter index
	1919	@param requestedSize The requested size - pass 0 to ignore missing entries
	1920	and return std::numeric_limits<size_t>::max()
	1921	*/
	1922	size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
	1923	/** Gets the physical buffer index associated with a logical double constant index.
	1924	@note Only applicable to low-level programs.
	1925	@param logicalIndex The logical parameter index
	1926	@param requestedSize The requested size - pass 0 to ignore missing entries
	1927	and return std::numeric_limits<size_t>::max()
	1928	*/
	1929	size_t _getDoubleConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
	1930	/** Gets the physical buffer index associated with a logical int constant index.
	1931	@note Only applicable to low-level programs.
	1932	@param logicalIndex The logical parameter index
	1933	@param requestedSize The requested size - pass 0 to ignore missing entries
	1934	and return std::numeric_limits<size_t>::max()
	1935	*/
	1936	size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
	1937
	1938	/** Sets whether or not we need to transpose the matrices passed in from the rest of OGRE.
	1939	@remarks
	1940	D3D uses transposed matrices compared to GL and OGRE; this is not important when you
	1941	use programs which are written to process row-major matrices, such as those generated
	1942	by Cg, but if you use a program written to D3D's matrix layout you will need to enable
	1943	this flag.
	1944	*/
	1945	void setTransposeMatrices(bool val) { mTransposeMatrices = val; }
	1946	/// Gets whether or not matrices are to be transposed when set
	1947	bool getTransposeMatrices(void) const { return mTransposeMatrices; }
	1948
	1949	/** Copies the values of all constants (including auto constants) from another
	1950	GpuProgramParameters object.
	1951	@note This copes the internal storage of the paarameters object and therefore
	1952	can only be used for parameters objects created from the same GpuProgram.
	1953	To merge parameters that match from different programs, use copyMatchingNamedConstantsFrom.
	1954	*/
	1955	void copyConstantsFrom(const GpuProgramParameters& source);
	1956
	1957	/** Copies the values of all matching named constants (including auto constants) from
	1958	another GpuProgramParameters object.
	1959	@remarks
	1960	This method iterates over the named constants in another parameters object
	1961	and copies across the values where they match. This method is safe to
	1962	use when the 2 parameters objects came from different programs, but only
	1963	works for named parameters.
	1964	*/
	1965	void copyMatchingNamedConstantsFrom(const GpuProgramParameters& source);
	1966
	1967	/** gets the auto constant definition associated with name if found else returns NULL
	1968	@param name The name of the auto constant
	1969	*/
	1970	static const AutoConstantDefinition* getAutoConstantDefinition(const String& name);
	1971	/** gets the auto constant definition using an index into the auto constant definition array.
	1972	If the index is out of bounds then NULL is returned;
	1973	@param idx The auto constant index
	1974	*/
	1975	static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx);
	1976	/** Returns the number of auto constant definitions
	1977	*/
	1978	static size_t getNumAutoConstantDefinitions(void);
	1979
	1980
	1981	/** increments the multipass number entry by 1 if it exists
	1982	*/
	1983	void incPassIterationNumber(void);
	1984	/** Does this parameters object have a pass iteration number constant? */
	1985	bool hasPassIterationNumber() const
	1986	{ return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
	1987	/** Get the physical buffer index of the pass iteration number constant */
	1988	size_t getPassIterationNumberIndex() const
	1989	{ return mActivePassIterationIndex; }
	1990
	1991
	1992	/** Use a set of shared parameters in this parameters object.
	1993	@remarks
	1994	Allows you to use a set of shared parameters to automatically update
	1995	this parameter set.
	1996	*/
	1997	void addSharedParameters(GpuSharedParametersPtr sharedParams);
	1998
	1999	/** Use a set of shared parameters in this parameters object.
	2000	@remarks
	2001	Allows you to use a set of shared parameters to automatically update
	2002	this parameter set.
	2003	@param sharedParamsName The name of a shared parameter set as defined in
	2004	GpuProgramManager
	2005	*/
	2006	void addSharedParameters(const String& sharedParamsName);
	2007
	2008	/** Returns whether this parameter set is using the named shared parameter set. */
	2009	bool isUsingSharedParameters(const String& sharedParamsName) const;
	2010
	2011	/** Stop using the named shared parameter set. */
	2012	void removeSharedParameters(const String& sharedParamsName);
	2013
	2014	/** Stop using all shared parameter sets. */
	2015	void removeAllSharedParameters();
	2016
	2017	/** Get the list of shared parameter sets. */
	2018	const GpuSharedParamUsageList& getSharedParameters() const;
	2019
	2020	/** Internal method that the RenderSystem might use to store optional data. */
	2021	void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
	2022	/** Internal method that the RenderSystem might use to store optional data. */
	2023	const Any& _getRenderSystemData() const { return mRenderSystemData; }
	2024
	2025	/** Update the parameters by copying the data from the shared
	2026	parameters.
	2027	@note This method may not actually be called if the RenderSystem
	2028	supports using shared parameters directly in their own shared buffer; in
	2029	which case the values should not be copied out of the shared area
	2030	into the individual parameter set, but bound separately.
	2031	*/
	2032	void _copySharedParams();
	2033
	2034	size_t calculateSize(void) const;
	2035
	2036	/** Set subroutine name by slot name
	2037	*/
	2038	void setNamedSubroutine(const String& subroutineSlot, const String& subroutine);
	2039
	2040	/** Set subroutine name by slot index
	2041	*/
	2042	void setSubroutine(size_t index, const String& subroutine);
	2043
	2044	/** Get map with
	2045	*/
	2046	const SubroutineMap& getSubroutineMap() const { return mSubroutineMap; }
	2047	};
	2048
	2049	/// Shared pointer used to hold references to GpuProgramParameters instances
	2050	typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr;
	2051
	2052	/** @} */
	2053	/** @} */
	2054	}
	2055
	2056	#include "OgreHeaderSuffix.h"
	2057
	2058	#endif
	2059

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: downloads/ogre_src_v1-9-0/OgreMain/include/OgreGpuProgramParams.h @ 151

Download in other formats: