Context Navigation

OgreGpuProgram.cpp @ 692

Revision 692, 54.8 KB checked in by mattausch, 18 years ago (diff)
adding ogre 1.2 and dependencies

Line
1	/*
2	-----------------------------------------------------------------------------
3	This source file is part of OGRE
4	(Object-oriented Graphics Rendering Engine)
5	For the latest info, see http://ogre.sourceforge.net/
6
7	Copyright (c) 2000-2005 The OGRE Team
8	Also see acknowledgements in Readme.html
9
10	This program is free software you can redistribute it and/or modify it under
11	the terms of the GNU Lesser General Public License as published by the Free Software
12	Foundation either version 2 of the License, or (at your option) any later
13	version.
14
15	This program is distributed in the hope that it will be useful, but WITHOUT
16	ANY WARRANTY without even the implied warranty of MERCHANTABILITY or FITNESS
17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19	You should have received a copy of the GNU Lesser General Public License along with
20	this program if not, write to the Free Software Foundation, Inc., 59 Temple
21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22	http://www.gnu.org/copyleft/lesser.txt.
23	-----------------------------------------------------------------------------
24	*/
25	#include "OgreStableHeaders.h"
26	#include "OgreGpuProgram.h"
27	#include "OgreHighLevelGpuProgram.h"
28	#include "OgreGpuProgramManager.h"
29	#include "OgreVector3.h"
30	#include "OgreVector4.h"
31	#include "OgreAutoParamDataSource.h"
32	#include "OgreLight.h"
33	#include "OgreRoot.h"
34	#include "OgreRenderSystem.h"
35	#include "OgreRenderSystemCapabilities.h"
36	#include "OgreStringConverter.h"
37
38	namespace Ogre
39	{
40	//-----------------------------------------------------------------------------
41	GpuProgram::CmdType GpuProgram::msTypeCmd;
42	GpuProgram::CmdSyntax GpuProgram::msSyntaxCmd;
43	GpuProgram::CmdSkeletal GpuProgram::msSkeletalCmd;
44
45
46	GpuProgramParameters::AutoConstantDefinition GpuProgramParameters::AutoConstantDictionary[] = {
47	AutoConstantDefinition(ACT_WORLD_MATRIX, "world_matrix", 16, ET_REAL, ACDT_NONE),
48	AutoConstantDefinition(ACT_INVERSE_WORLD_MATRIX, "inverse_world_matrix", 16, ET_REAL, ACDT_NONE),
49	AutoConstantDefinition(ACT_TRANSPOSE_WORLD_MATRIX, "transpose_world_matrix", 16, ET_REAL, ACDT_NONE),
50	AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_WORLD_MATRIX, "inverse_transpose_world_matrix", 16, ET_REAL, ACDT_NONE),
51
52	AutoConstantDefinition(ACT_WORLD_MATRIX_ARRAY_3x4, "world_matrix_array_3x4", 12, ET_REAL, ACDT_NONE),
53	AutoConstantDefinition(ACT_WORLD_MATRIX_ARRAY, "world_matrix_array", 16, ET_REAL, ACDT_NONE),
54
55	AutoConstantDefinition(ACT_VIEW_MATRIX, "view_matrix", 16, ET_REAL, ACDT_NONE),
56	AutoConstantDefinition(ACT_INVERSE_VIEW_MATRIX, "inverse_view_matrix", 16, ET_REAL, ACDT_NONE),
57	AutoConstantDefinition(ACT_TRANSPOSE_VIEW_MATRIX, "transpose_view_matrix", 16, ET_REAL, ACDT_NONE),
58	AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_VIEW_MATRIX, "inverse_transpose_view_matrix", 16, ET_REAL, ACDT_NONE),
59
60	AutoConstantDefinition(ACT_PROJECTION_MATRIX, "projection_matrix", 16, ET_REAL, ACDT_NONE),
61	AutoConstantDefinition(ACT_INVERSE_PROJECTION_MATRIX, "inverse_projection_matrix", 16, ET_REAL, ACDT_NONE),
62	AutoConstantDefinition(ACT_TRANSPOSE_PROJECTION_MATRIX, "transpose_projection_matrix", 16, ET_REAL, ACDT_NONE),
63	AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX, "inverse_transpose_projection_matrix", 16, ET_REAL, ACDT_NONE),
64
65	AutoConstantDefinition(ACT_VIEWPROJ_MATRIX, "viewproj_matrix", 16, ET_REAL, ACDT_NONE),
66	AutoConstantDefinition(ACT_INVERSE_VIEWPROJ_MATRIX, "inverse_viewproj_matrix", 16, ET_REAL, ACDT_NONE),
67	AutoConstantDefinition(ACT_TRANSPOSE_VIEWPROJ_MATRIX, "transpose_viewproj_matrix", 16, ET_REAL, ACDT_NONE),
68	AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX, "inverse_transpose_viewproj_matrix", 16, ET_REAL, ACDT_NONE),
69
70	AutoConstantDefinition(ACT_WORLDVIEW_MATRIX, "worldview_matrix", 16, ET_REAL, ACDT_NONE),
71	AutoConstantDefinition(ACT_INVERSE_WORLDVIEW_MATRIX, "inverse_worldview_matrix", 16, ET_REAL, ACDT_NONE),
72	AutoConstantDefinition(ACT_TRANSPOSE_WORLDVIEW_MATRIX, "transpose_worldview_matrix", 16, ET_REAL, ACDT_NONE),
73	AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX, "inverse_transpose_worldview_matrix", 16, ET_REAL, ACDT_NONE),
74
75	AutoConstantDefinition(ACT_WORLDVIEWPROJ_MATRIX, "worldviewproj_matrix", 16, ET_REAL, ACDT_NONE),
76	AutoConstantDefinition(ACT_INVERSE_WORLDVIEWPROJ_MATRIX, "inverse_worldviewproj_matrix", 16, ET_REAL, ACDT_NONE),
77	AutoConstantDefinition(ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX, "transpose_worldviewproj_matrix", 16, ET_REAL, ACDT_NONE),
78	AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX, "inverse_transpose_worldviewproj_matrix", 16, ET_REAL, ACDT_NONE),
79
80	AutoConstantDefinition(ACT_RENDER_TARGET_FLIPPING, "render_target_flipping", 1, ET_REAL, ACDT_NONE),
81
82	AutoConstantDefinition(ACT_FOG_COLOUR, "fog_colour", 4, ET_REAL, ACDT_NONE),
83	AutoConstantDefinition(ACT_FOG_PARAMS, "fog_params", 4, ET_REAL, ACDT_NONE),
84
85	AutoConstantDefinition(ACT_AMBIENT_LIGHT_COLOUR, "ambient_light_colour", 4, ET_REAL, ACDT_NONE),
86	AutoConstantDefinition(ACT_LIGHT_DIFFUSE_COLOUR, "light_diffuse_colour", 4, ET_REAL, ACDT_INT),
87	AutoConstantDefinition(ACT_LIGHT_SPECULAR_COLOUR, "light_specular_colour", 4, ET_REAL, ACDT_INT),
88	AutoConstantDefinition(ACT_LIGHT_ATTENUATION, "light_attenuation", 4, ET_REAL, ACDT_INT),
89	AutoConstantDefinition(ACT_LIGHT_POSITION, "light_position", 4, ET_REAL, ACDT_INT),
90	AutoConstantDefinition(ACT_LIGHT_POSITION_OBJECT_SPACE, "light_position_object_space", 4, ET_REAL, ACDT_INT),
91	AutoConstantDefinition(ACT_LIGHT_POSITION_VIEW_SPACE, "light_position_view_space", 4, ET_REAL, ACDT_INT),
92	AutoConstantDefinition(ACT_LIGHT_DIRECTION, "light_direction", 4, ET_REAL, ACDT_INT),
93	AutoConstantDefinition(ACT_LIGHT_DIRECTION_OBJECT_SPACE, "light_direction_object_space", 4, ET_REAL, ACDT_INT),
94	AutoConstantDefinition(ACT_LIGHT_DIRECTION_VIEW_SPACE, "light_direction_view_space", 4, ET_REAL, ACDT_INT),
95	AutoConstantDefinition(ACT_LIGHT_DISTANCE_OBJECT_SPACE, "light_distance_object_space", 1, ET_REAL, ACDT_INT),
96	AutoConstantDefinition(ACT_LIGHT_POWER_SCALE, "light_power", 1, ET_REAL, ACDT_INT),
97	AutoConstantDefinition(ACT_SHADOW_EXTRUSION_DISTANCE, "shadow_extrusion_distance", 1, ET_REAL, ACDT_INT),
98	AutoConstantDefinition(ACT_CAMERA_POSITION, "camera_position", 3, ET_REAL, ACDT_NONE),
99	AutoConstantDefinition(ACT_CAMERA_POSITION_OBJECT_SPACE, "camera_position_object_space", 3, ET_REAL, ACDT_NONE),
100	AutoConstantDefinition(ACT_TEXTURE_VIEWPROJ_MATRIX, "texture_viewproj_matrix", 16, ET_REAL, ACDT_NONE),
101	AutoConstantDefinition(ACT_CUSTOM, "custom", 4, ET_REAL, ACDT_INT), // *** needs to be tested
102	AutoConstantDefinition(ACT_TIME, "time", 1, ET_REAL, ACDT_REAL),
103	AutoConstantDefinition(ACT_TIME_0_X, "time_0_x", 4, ET_REAL, ACDT_REAL),
104	AutoConstantDefinition(ACT_COSTIME_0_X, "costime_0_x", 4, ET_REAL, ACDT_REAL),
105	AutoConstantDefinition(ACT_SINTIME_0_X, "sintime_0_x", 4, ET_REAL, ACDT_REAL),
106	AutoConstantDefinition(ACT_TANTIME_0_X, "tantime_0_x", 4, ET_REAL, ACDT_REAL),
107	AutoConstantDefinition(ACT_TIME_0_X_PACKED, "time_0_x_packed", 4, ET_REAL, ACDT_REAL),
108	AutoConstantDefinition(ACT_TIME_0_1, "time_0_1", 4, ET_REAL, ACDT_REAL),
109	AutoConstantDefinition(ACT_COSTIME_0_1, "costime_0_1", 4, ET_REAL, ACDT_REAL),
110	AutoConstantDefinition(ACT_SINTIME_0_1, "sintime_0_1", 4, ET_REAL, ACDT_REAL),
111	AutoConstantDefinition(ACT_TANTIME_0_1, "tantime_0_1", 4, ET_REAL, ACDT_REAL),
112	AutoConstantDefinition(ACT_TIME_0_1_PACKED, "time_0_1_packed", 4, ET_REAL, ACDT_REAL),
113	AutoConstantDefinition(ACT_TIME_0_2PI, "time_0_2pi", 4, ET_REAL, ACDT_REAL),
114	AutoConstantDefinition(ACT_COSTIME_0_2PI, "costime_0_2pi", 4, ET_REAL, ACDT_REAL),
115	AutoConstantDefinition(ACT_SINTIME_0_2PI, "sintime_0_2pi", 4, ET_REAL, ACDT_REAL),
116	AutoConstantDefinition(ACT_TANTIME_0_2PI, "tantime_0_2pi", 4, ET_REAL, ACDT_REAL),
117	AutoConstantDefinition(ACT_TIME_0_2PI_PACKED, "time_0_2pi_packed", 4, ET_REAL, ACDT_REAL),
118	AutoConstantDefinition(ACT_FRAME_TIME, "frame_time", 1, ET_REAL, ACDT_REAL),
119	AutoConstantDefinition(ACT_FPS, "fps", 1, ET_REAL, ACDT_NONE),
120	AutoConstantDefinition(ACT_VIEWPORT_WIDTH, "viewport_width", 1, ET_REAL, ACDT_NONE),
121	AutoConstantDefinition(ACT_VIEWPORT_HEIGHT, "viewport_height", 1, ET_REAL, ACDT_NONE),
122	AutoConstantDefinition(ACT_INVERSE_VIEWPORT_WIDTH, "inverse_viewport_width", 1, ET_REAL, ACDT_NONE),
123	AutoConstantDefinition(ACT_INVERSE_VIEWPORT_HEIGHT, "inverse_viewport_height", 1, ET_REAL, ACDT_NONE),
124	AutoConstantDefinition(ACT_VIEWPORT_SIZE, "viewport_size", 4, ET_REAL, ACDT_NONE),
125	AutoConstantDefinition(ACT_VIEW_DIRECTION, "view_direction", 3, ET_REAL, ACDT_NONE),
126	AutoConstantDefinition(ACT_VIEW_SIDE_VECTOR, "view_side_vector", 3, ET_REAL, ACDT_NONE),
127	AutoConstantDefinition(ACT_VIEW_UP_VECTOR, "view_up_vector", 3, ET_REAL, ACDT_NONE),
128	AutoConstantDefinition(ACT_FOV, "fov", 1, ET_REAL, ACDT_NONE),
129	AutoConstantDefinition(ACT_NEAR_CLIP_DISTANCE, "near_clip_distance", 1, ET_REAL, ACDT_NONE),
130	AutoConstantDefinition(ACT_FAR_CLIP_DISTANCE, "far_clip_distance", 1, ET_REAL, ACDT_NONE),
131	AutoConstantDefinition(ACT_PASS_NUMBER, "pass_number", 1, ET_REAL, ACDT_NONE),
132	AutoConstantDefinition(ACT_PASS_ITERATION_NUMBER, "pass_iteration_number", 1, ET_REAL, ACDT_NONE),
133	AutoConstantDefinition(ACT_ANIMATION_PARAMETRIC, "animation_parametric", 4, ET_REAL, ACDT_INT),
134	};
135
136
137
138	//-----------------------------------------------------------------------------
139	GpuProgram::GpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
140	const String& group, bool isManual, ManualResourceLoader* loader)
141	:Resource(creator, name, handle, group, isManual, loader),
142	mType(GPT_VERTEX_PROGRAM), mLoadFromFile(true), mSkeletalAnimation(false),
143	mPassSurfaceAndLightStates(false)
144	{
145	}
146	//-----------------------------------------------------------------------------
147	void GpuProgram::setType(GpuProgramType t)
148	{
149	mType = t;
150	}
151	//-----------------------------------------------------------------------------
152	void GpuProgram::setSyntaxCode(const String& syntax)
153	{
154	mSyntaxCode = syntax;
155	}
156	//-----------------------------------------------------------------------------
157	void GpuProgram::setSourceFile(const String& filename)
158	{
159	mFilename = filename;
160	mSource = "";
161	mLoadFromFile = true;
162	}
163	//-----------------------------------------------------------------------------
164	void GpuProgram::setSource(const String& source)
165	{
166	mSource = source;
167	mFilename = "";
168	mLoadFromFile = false;
169	}
170
171	//-----------------------------------------------------------------------------
172	void GpuProgram::loadImpl(void)
173	{
174	if (mLoadFromFile)
175	{
176	// find & load source code
177	DataStreamPtr stream =
178	ResourceGroupManager::getSingleton().openResource(
179	mFilename, mGroup, true, this);
180	mSource = stream->getAsString();
181	}
182
183	// Call polymorphic load
184	loadFromSource();
185
186	}
187	//-----------------------------------------------------------------------------
188	bool GpuProgram::isSupported(void) const
189	{
190	// If skeletal animation is being done, we need support for UBYTE4
191	if (isSkeletalAnimationIncluded() &&
192	!Root::getSingleton().getRenderSystem()->getCapabilities()
193	->hasCapability(RSC_VERTEX_FORMAT_UBYTE4))
194	{
195	return false;
196	}
197	return GpuProgramManager::getSingleton().isSyntaxSupported(mSyntaxCode);
198	}
199	//-----------------------------------------------------------------------------
200	GpuProgramParametersSharedPtr GpuProgram::createParameters(void)
201	{
202	// Default implementation simply returns standard parameters.
203	GpuProgramParametersSharedPtr ret =
204	GpuProgramManager::getSingleton().createParameters();
205	// Copy in default parameters if present
206	if (!mDefaultParams.isNull())
207	ret->copyConstantsFrom(*(mDefaultParams.get()));
208
209	return ret;
210	}
211	//-----------------------------------------------------------------------------
212	GpuProgramParametersSharedPtr GpuProgram::getDefaultParameters(void)
213	{
214	if (mDefaultParams.isNull())
215	{
216	mDefaultParams = createParameters();
217	}
218	return mDefaultParams;
219	}
220	//-----------------------------------------------------------------------------
221	void GpuProgram::setupBaseParamDictionary(void)
222	{
223	ParamDictionary* dict = getParamDictionary();
224
225	dict->addParameter(
226	ParameterDef("type", "'vertex_program' or 'fragment_program'",
227	PT_STRING), &msTypeCmd);
228	dict->addParameter(
229	ParameterDef("syntax", "Syntax code, e.g. vs_1_1", PT_STRING), &msSyntaxCmd);
230	dict->addParameter(
231	ParameterDef("includes_skeletal_animation",
232	"Whether this vertex program includes skeletal animation", PT_BOOL),
233	&msSkeletalCmd);
234	}
235
236	//-----------------------------------------------------------------------
237	const String& GpuProgram::getLanguage(void) const
238	{
239	static const String language = "asm";
240
241	return language;
242	}
243
244
245
246	//-----------------------------------------------------------------------------
247	// GpuProgramParameters Methods
248	//-----------------------------------------------------------------------------
249	GpuProgramParameters::GpuProgramParameters()
250	: mTransposeMatrices(false), mAutoAddParamName(false), mActivePassIterationEntry(0)
251	{
252	}
253	//-----------------------------------------------------------------------------
254
255	GpuProgramParameters::GpuProgramParameters(const GpuProgramParameters& oth)
256	{
257	*this = oth;
258	}
259
260	//-----------------------------------------------------------------------------
261	GpuProgramParameters& GpuProgramParameters::operator=(const GpuProgramParameters& oth)
262	{
263	// nfz: perform copy of all containers
264	// let compiler perform shallow copies of structures
265	// AutoConstantEntry, RealConstantEntry, IntConstantEntry
266	mRealConstants = oth.mRealConstants;
267	mIntConstants = oth.mIntConstants;
268	mAutoConstants = oth.mAutoConstants;
269	mParamNameMap = oth.mParamNameMap;
270
271	mTransposeMatrices = oth.mTransposeMatrices;
272	mAutoAddParamName = oth.mAutoAddParamName;
273	mConstantDefinitions = oth.mConstantDefinitions;
274
275	return *this;
276	}
277
278	void GpuProgramParameters::setConstant(size_t index, const Vector4& vec)
279	{
280	setConstant(index, vec.val, 1);
281	}
282	//-----------------------------------------------------------------------------
283	void GpuProgramParameters::setConstant(size_t index, Real val)
284	{
285	setConstant(index, Vector4(val, 0.0f, 0.0f, 0.0f));
286	}
287	//-----------------------------------------------------------------------------
288	void GpuProgramParameters::setConstant(size_t index, const Vector3& vec)
289	{
290	setConstant(index, Vector4(vec.x, vec.y, vec.z, 1.0f));
291	}
292	//-----------------------------------------------------------------------------
293	void GpuProgramParameters::setConstant(size_t index, const Matrix4& m)
294	{
295	// set as 4x 4-element floats
296	if (mTransposeMatrices)
297	{
298	Matrix4 t = m.transpose();
299	GpuProgramParameters::setConstant(index++, t[0], 1);
300	GpuProgramParameters::setConstant(index++, t[1], 1);
301	GpuProgramParameters::setConstant(index++, t[2], 1);
302	GpuProgramParameters::setConstant(index, t[3], 1);
303	}
304	else
305	{
306	GpuProgramParameters::setConstant(index++, m[0], 1);
307	GpuProgramParameters::setConstant(index++, m[1], 1);
308	GpuProgramParameters::setConstant(index++, m[2], 1);
309	GpuProgramParameters::setConstant(index, m[3], 1);
310	}
311
312	}
313	//-----------------------------------------------------------------------------
314	void GpuProgramParameters::setConstant(size_t index, const Matrix4* pMatrix,
315	size_t numEntries)
316	{
317	for (size_t i = 0; i < numEntries; ++i)
318	{
319	const Matrix4& m = pMatrix[i];
320
321	if (mTransposeMatrices)
322	{
323	Matrix4 t = m.transpose();
324	GpuProgramParameters::setConstant(index++, t[0], 1);
325	GpuProgramParameters::setConstant(index++, t[1], 1);
326	GpuProgramParameters::setConstant(index++, t[2], 1);
327	GpuProgramParameters::setConstant(index++, t[3], 1);
328	}
329	else
330	{
331	GpuProgramParameters::setConstant(index++, m[0], 1);
332	GpuProgramParameters::setConstant(index++, m[1], 1);
333	GpuProgramParameters::setConstant(index++, m[2], 1);
334	GpuProgramParameters::setConstant(index++, m[3], 1);
335	}
336	}
337
338	}
339	//-----------------------------------------------------------------------------
340	void GpuProgramParameters::setConstant(size_t index, const ColourValue& colour)
341	{
342	setConstant(index, colour.val, 1);
343	}
344	//-----------------------------------------------------------------------------
345	void GpuProgramParameters::setConstant(size_t index, const float *val, size_t count)
346	{
347	// Expand if required
348	if (mRealConstants.size() < index + count)
349	mRealConstants.resize(index + count);
350
351	// Copy in chunks of 4
352	while (count--)
353	{
354	RealConstantEntry* e = &(mRealConstants[index++]);
355	e->isSet = true;
356	memcpy(e->val, val, sizeof(float) * 4);
357	val += 4;
358	}
359
360	}
361	//-----------------------------------------------------------------------------
362	void GpuProgramParameters::setConstant(size_t index, const double *val, size_t count)
363	{
364	// Expand if required
365	if (mRealConstants.size() < index + count)
366	mRealConstants.resize(index + count);
367
368	// Copy, casting to float
369	while (count--)
370	{
371	RealConstantEntry* e = &(mRealConstants[index++]);
372	e->isSet = true;
373	e->val[0] = static_cast<float>(val[0]);
374	e->val[1] = static_cast<float>(val[1]);
375	e->val[2] = static_cast<float>(val[2]);
376	e->val[3] = static_cast<float>(val[3]);
377	val += 4;
378	}
379
380	}
381	//-----------------------------------------------------------------------------
382	void GpuProgramParameters::setConstant(size_t index, const int *val, size_t count)
383	{
384	// Expand if required
385	if (mIntConstants.size() < index + count)
386	mIntConstants.resize(index + count);
387
388	// Copy in chunks of 4
389	while (count--)
390	{
391	IntConstantEntry* e = &(mIntConstants[index++]);
392	e->isSet = true;
393	memcpy(e->val, val, sizeof(int) * 4);
394	val += 4;
395	}
396
397	}
398	//-----------------------------------------------------------------------------
399	void GpuProgramParameters::setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo)
400	{
401	mAutoConstants.push_back(AutoConstantEntry(acType, index, extraInfo));
402	}
403	//-----------------------------------------------------------------------------
404	void GpuProgramParameters::clearAutoConstants(void)
405	{
406	mAutoConstants.clear();
407	}
408	//-----------------------------------------------------------------------------
409	GpuProgramParameters::AutoConstantIterator GpuProgramParameters::getAutoConstantIterator(void) const
410	{
411	return AutoConstantIterator(mAutoConstants.begin(), mAutoConstants.end());
412	}
413	//-----------------------------------------------------------------------------
414	void GpuProgramParameters::setAutoConstantReal(size_t index, AutoConstantType acType, Real rData)
415	{
416	mAutoConstants.push_back(AutoConstantEntry(acType, index, rData));
417	}
418	//-----------------------------------------------------------------------------
419
420	//-----------------------------------------------------------------------------
421	void GpuProgramParameters::_updateAutoParamsNoLights(const AutoParamDataSource& source)
422	{
423	if (!hasAutoConstants()) return; // abort early if no autos
424	Vector3 vec3;
425	Vector4 vec4;
426	size_t index;
427	size_t numMatrices;
428	const Matrix4* pMatrix;
429	size_t m;
430
431	mActivePassIterationEntry = 0;
432
433	AutoConstantList::const_iterator i, iend;
434	iend = mAutoConstants.end();
435	for (i = mAutoConstants.begin(); i != iend; ++i)
436	{
437	switch(i->paramType)
438	{
439	case ACT_WORLD_MATRIX:
440	setConstant(i->index, source.getWorldMatrix());
441	break;
442	case ACT_INVERSE_WORLD_MATRIX:
443	setConstant(i->index, source.getInverseWorldMatrix());
444	break;
445	case ACT_TRANSPOSE_WORLD_MATRIX:
446	setConstant(i->index, source.getTransposeWorldMatrix());
447	break;
448	case ACT_INVERSE_TRANSPOSE_WORLD_MATRIX:
449	setConstant(i->index, source.getInverseTransposeWorldMatrix());
450	break;
451
452	case ACT_WORLD_MATRIX_ARRAY_3x4:
453	// Loop over matrices
454	pMatrix = source.getWorldMatrixArray();
455	numMatrices = source.getWorldMatrixCount();
456	index = i->index;
457	for (m = 0; m < numMatrices; ++m)
458	{
459	GpuProgramParameters::setConstant(index++, (*pMatrix)[0], 1);
460	GpuProgramParameters::setConstant(index++, (*pMatrix)[1], 1);
461	GpuProgramParameters::setConstant(index++, (*pMatrix)[2], 1);
462	++pMatrix;
463	}
464
465	break;
466	case ACT_WORLD_MATRIX_ARRAY:
467	setConstant(i->index, source.getWorldMatrixArray(),
468	source.getWorldMatrixCount());
469	break;
470	case ACT_VIEW_MATRIX:
471	setConstant(i->index, source.getViewMatrix());
472	break;
473	case ACT_INVERSE_VIEW_MATRIX:
474	setConstant(i->index, source.getInverseViewMatrix());
475	break;
476	case ACT_TRANSPOSE_VIEW_MATRIX:
477	setConstant(i->index, source.getTransposeViewMatrix());
478	break;
479	case ACT_INVERSE_TRANSPOSE_VIEW_MATRIX:
480	setConstant(i->index, source.getTransposeViewMatrix());
481	break;
482
483	case ACT_PROJECTION_MATRIX:
484	setConstant(i->index, source.getProjectionMatrix());
485	break;
486	case ACT_INVERSE_PROJECTION_MATRIX:
487	setConstant(i->index, source.getInverseProjectionMatrix());
488	break;
489	case ACT_TRANSPOSE_PROJECTION_MATRIX:
490	setConstant(i->index, source.getTransposeProjectionMatrix());
491	break;
492	case ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX:
493	setConstant(i->index, source.getInverseTransposeProjectionMatrix());
494	break;
495
496	case ACT_VIEWPROJ_MATRIX:
497	setConstant(i->index, source.getViewProjectionMatrix());
498	break;
499	case ACT_INVERSE_VIEWPROJ_MATRIX:
500	setConstant(i->index, source.getInverseViewProjMatrix());
501	break;
502	case ACT_TRANSPOSE_VIEWPROJ_MATRIX:
503	setConstant(i->index, source.getTransposeViewProjMatrix());
504	break;
505	case ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX:
506	setConstant(i->index, source.getInverseTransposeViewProjMatrix());
507	break;
508
509	case ACT_WORLDVIEW_MATRIX:
510	setConstant(i->index, source.getWorldViewMatrix());
511	break;
512	case ACT_INVERSE_WORLDVIEW_MATRIX:
513	setConstant(i->index, source.getInverseWorldViewMatrix());
514	break;
515	case ACT_TRANSPOSE_WORLDVIEW_MATRIX:
516	setConstant(i->index, source.getTransposeWorldViewMatrix());
517	break;
518	case ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX:
519	setConstant(i->index, source.getInverseTransposeWorldViewMatrix());
520	break;
521
522	case ACT_WORLDVIEWPROJ_MATRIX:
523	setConstant(i->index, source.getWorldViewProjMatrix());
524	break;
525	case ACT_INVERSE_WORLDVIEWPROJ_MATRIX:
526	setConstant(i->index, source.getInverseWorldViewProjMatrix());
527	break;
528	case ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX:
529	setConstant(i->index, source.getTransposeWorldViewProjMatrix());
530	break;
531	case ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX:
532	setConstant(i->index, source.getInverseTransposeWorldViewProjMatrix());
533	break;
534
535	case ACT_RENDER_TARGET_FLIPPING:
536	setConstant(i->index, source.getCurrentRenderTarget()->requiresTextureFlipping() ? -1.f : +1.f);
537	break;
538
539	// NB ambient light still here because it's not related to a specific light
540	case ACT_AMBIENT_LIGHT_COLOUR:
541	setConstant(i->index, source.getAmbientLightColour());
542	break;
543
544	case ACT_FOG_COLOUR:
545	setConstant(i->index, source.getFogColour());
546	break;
547	case ACT_FOG_PARAMS:
548	setConstant(i->index, source.getFogParams());
549	break;
550
551	case ACT_CAMERA_POSITION:
552	setConstant(i->index, source.getCameraPosition());
553	break;
554	case ACT_CAMERA_POSITION_OBJECT_SPACE:
555	setConstant(i->index, source.getCameraPositionObjectSpace());
556	break;
557
558	case ACT_TIME:
559	setConstant(i->index, Vector4(source.getTime() * i->fData, 0.f, 0.f, 0.f));
560	break;
561	case ACT_TIME_0_X:
562	setConstant(i->index, Vector4(source.getTime_0_X(i->fData), 0.f, 0.f, 0.f));
563	break;
564	case ACT_COSTIME_0_X:
565	setConstant(i->index, Vector4(source.getCosTime_0_X(i->fData), 0.f, 0.f, 0.f));
566	break;
567	case ACT_SINTIME_0_X:
568	setConstant(i->index, Vector4(source.getSinTime_0_X(i->fData), 0.f, 0.f, 0.f));
569	break;
570	case ACT_TANTIME_0_X:
571	setConstant(i->index, Vector4(source.getTanTime_0_X(i->fData), 0.f, 0.f, 0.f));
572	break;
573	case ACT_TIME_0_X_PACKED:
574	setConstant(i->index, source.getTime_0_X_packed(i->fData));
575	break;
576	case ACT_TIME_0_1:
577	setConstant(i->index, Vector4(source.getTime_0_1(i->fData), 0.f, 0.f, 0.f));
578	break;
579	case ACT_COSTIME_0_1:
580	setConstant(i->index, Vector4(source.getCosTime_0_1(i->fData), 0.f, 0.f, 0.f));
581	break;
582	case ACT_SINTIME_0_1:
583	setConstant(i->index, Vector4(source.getSinTime_0_1(i->fData), 0.f, 0.f, 0.f));
584	break;
585	case ACT_TANTIME_0_1:
586	setConstant(i->index, Vector4(source.getTanTime_0_1(i->fData), 0.f, 0.f, 0.f));
587	break;
588	case ACT_TIME_0_1_PACKED:
589	setConstant(i->index, source.getTime_0_1_packed(i->fData));
590	break;
591	case ACT_TIME_0_2PI:
592	setConstant(i->index, Vector4(source.getTime_0_2Pi(i->fData), 0.f, 0.f, 0.f));
593	break;
594	case ACT_COSTIME_0_2PI:
595	setConstant(i->index, Vector4(source.getCosTime_0_2Pi(i->fData), 0.f, 0.f, 0.f));
596	break;
597	case ACT_SINTIME_0_2PI:
598	setConstant(i->index, Vector4(source.getSinTime_0_2Pi(i->fData), 0.f, 0.f, 0.f));
599	break;
600	case ACT_TANTIME_0_2PI:
601	setConstant(i->index, Vector4(source.getTanTime_0_2Pi(i->fData), 0.f, 0.f, 0.f));
602	break;
603	case ACT_TIME_0_2PI_PACKED:
604	setConstant(i->index, source.getTime_0_2Pi_packed(i->fData));
605	break;
606	case ACT_FRAME_TIME:
607	setConstant(i->index, source.getFrameTime() * i->fData);
608	break;
609	case ACT_FPS:
610	setConstant(i->index, source.getFPS());
611	break;
612	case ACT_VIEWPORT_WIDTH:
613	setConstant(i->index, source.getViewportWidth());
614	break;
615	case ACT_VIEWPORT_HEIGHT:
616	setConstant(i->index, source.getViewportHeight());
617	break;
618	case ACT_INVERSE_VIEWPORT_WIDTH:
619	setConstant(i->index, source.getInverseViewportWidth());
620	break;
621	case ACT_INVERSE_VIEWPORT_HEIGHT:
622	setConstant(i->index, source.getInverseViewportHeight());
623	break;
624	case ACT_VIEWPORT_SIZE:
625	setConstant(i->index, Vector4(
626	source.getViewportWidth(),
627	source.getViewportHeight(),
628	source.getInverseViewportWidth(),
629	source.getInverseViewportHeight()));
630	break;
631	case ACT_VIEW_DIRECTION:
632	setConstant(i->index, source.getViewDirection());
633	break;
634	case ACT_VIEW_SIDE_VECTOR:
635	setConstant(i->index, source.getViewSideVector());
636	break;
637	case ACT_VIEW_UP_VECTOR:
638	setConstant(i->index, source.getViewUpVector());
639	break;
640	case ACT_FOV:
641	setConstant(i->index, source.getFOV());
642	break;
643	case ACT_NEAR_CLIP_DISTANCE:
644	setConstant(i->index, source.getNearClipDistance());
645	break;
646	case ACT_FAR_CLIP_DISTANCE:
647	setConstant(i->index, source.getFarClipDistance());
648	break;
649	case ACT_TEXTURE_VIEWPROJ_MATRIX:
650	setConstant(i->index, source.getTextureViewProjMatrix());
651	break;
652	case ACT_PASS_NUMBER:
653	setConstant(i->index, (float)source.getPassNumber());
654	break;
655	case ACT_PASS_ITERATION_NUMBER:
656	setConstant(i->index, 0.0f);
657	mActivePassIterationEntry = getRealConstantEntry(i->index);
658	mActivePassIterationEntryIndex = i->index;
659	break;
660	case ACT_CUSTOM:
661	case ACT_ANIMATION_PARAMETRIC:
662	source.getCurrentRenderable()->_updateCustomGpuParameter(*i, this);
663	break;
664	default:
665	break;
666	}
667	}
668	}
669	//-----------------------------------------------------------------------------
670	void GpuProgramParameters::_updateAutoParamsLightsOnly(const AutoParamDataSource& source)
671	{
672	if (!hasAutoConstants()) return; // abort early if no autos
673	Vector3 vec3;
674	Vector4 vec4;
675
676	AutoConstantList::const_iterator i, iend;
677	iend = mAutoConstants.end();
678	for (i = mAutoConstants.begin(); i != iend; ++i)
679	{
680	switch(i->paramType)
681	{
682	case ACT_LIGHT_DIFFUSE_COLOUR:
683	setConstant(i->index, source.getLight(i->data).getDiffuseColour());
684	break;
685	case ACT_LIGHT_SPECULAR_COLOUR:
686	setConstant(i->index, source.getLight(i->data).getSpecularColour());
687	break;
688	case ACT_LIGHT_POSITION:
689	// Get as 4D vector, works for directional lights too
690	setConstant(i->index,
691	source.getLight(i->data).getAs4DVector());
692	break;
693	case ACT_LIGHT_DIRECTION:
694	vec3 = source.getLight(i->data).getDerivedDirection();
695	// Set as 4D vector for compatibility
696	setConstant(i->index, Vector4(vec3.x, vec3.y, vec3.z, 1.0f));
697	break;
698	case ACT_LIGHT_POSITION_OBJECT_SPACE:
699	setConstant(i->index,
700	source.getInverseWorldMatrix() * source.getLight(i->data).getAs4DVector());
701	break;
702	case ACT_LIGHT_DIRECTION_OBJECT_SPACE:
703	vec3 = source.getInverseWorldMatrix() *
704	source.getLight(i->data).getDerivedDirection();
705	vec3.normalise();
706	// Set as 4D vector for compatibility
707	setConstant(i->index, Vector4(vec3.x, vec3.y, vec3.z, 1.0f));
708	break;
709	case ACT_LIGHT_POSITION_VIEW_SPACE:
710	setConstant(i->index,
711	source.getWorldViewMatrix() * source.getLight(i->data).getAs4DVector());
712	break;
713	case ACT_LIGHT_DIRECTION_VIEW_SPACE:
714	vec3 = source.getWorldViewMatrix() *
715	source.getLight(i->data).getDerivedDirection();
716	vec3.normalise();
717	// Set as 4D vector for compatibility
718	setConstant(i->index, Vector4(vec3.x, vec3.y, vec3.z, 1.0f));
719	break;
720	case ACT_LIGHT_DISTANCE_OBJECT_SPACE:
721	vec3 = source.getInverseWorldMatrix() * source.getLight(i->data).getDerivedPosition();
722	setConstant(i->index, vec3.length());
723	break;
724	case ACT_SHADOW_EXTRUSION_DISTANCE:
725	setConstant(i->index, source.getShadowExtrusionDistance());
726	break;
727	case ACT_LIGHT_POWER_SCALE:
728	setConstant(i->index, source.getLight(i->data).getPowerScale());
729	break;
730	case ACT_LIGHT_ATTENUATION:
731	// range, const, linear, quad
732	const Light& l = source.getLight(i->data);
733	vec4.x = l.getAttenuationRange();
734	vec4.y = l.getAttenuationConstant();
735	vec4.z = l.getAttenuationLinear();
736	vec4.w = l.getAttenuationQuadric();
737	setConstant(i->index, vec4);
738	break;
739	}
740	}
741	}
742	//---------------------------------------------------------------------------
743	void GpuProgramParameters::_mapParameterNameToIndex(const String& name, const size_t index)
744	{
745	mParamNameMap[name] = index;
746	}
747	//---------------------------------------------------------------------------
748	size_t GpuProgramParameters::getParamIndex(const String& name)
749	{
750	ParamNameMap::const_iterator i = mParamNameMap.find(name);
751	if (i == mParamNameMap.end())
752	{
753	// name not found in map, should it be added to the map?
754	if(mAutoAddParamName)
755	{
756	// determine index
757	// don't know which Constants list the name is for
758	// so pick the largest index - a waste
759	size_t index = (mRealConstants.size() > mIntConstants.size()) ?
760	mRealConstants.size() : mIntConstants.size();
761
762	_mapParameterNameToIndex(name, index);
763	return index;
764	}
765	else
766	{
767	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot find a parameter named " + name,
768	"GpuProgramParameters::getParamIndex");
769	}
770	}
771	return i->second;
772	}
773	//---------------------------------------------------------------------------
774	void GpuProgramParameters::setNamedConstant(const String& name, Real val)
775	{
776	setConstant(getParamIndex(name), val);
777	}
778	//---------------------------------------------------------------------------
779	void GpuProgramParameters::setNamedConstant(const String& name, int val)
780	{
781	setConstant(getParamIndex(name), val);
782	}
783	//---------------------------------------------------------------------------
784	void GpuProgramParameters::setNamedConstant(const String& name, const Vector4& vec)
785	{
786	setConstant(getParamIndex(name), vec);
787	}
788	//---------------------------------------------------------------------------
789	void GpuProgramParameters::setNamedConstant(const String& name, const Vector3& vec)
790	{
791	setConstant(getParamIndex(name), vec);
792	}
793	//---------------------------------------------------------------------------
794	void GpuProgramParameters::setNamedConstant(const String& name, const Matrix4& m)
795	{
796	setConstant(getParamIndex(name), m);
797	}
798	//---------------------------------------------------------------------------
799	void GpuProgramParameters::setNamedConstant(const String& name, const Matrix4* m,
800	size_t numEntries)
801	{
802	setConstant(getParamIndex(name), m, numEntries);
803	}
804	//---------------------------------------------------------------------------
805	void GpuProgramParameters::setNamedConstant(const String& name, const float *val, size_t count)
806	{
807	setConstant(getParamIndex(name), val, count);
808	}
809	//---------------------------------------------------------------------------
810	void GpuProgramParameters::setNamedConstant(const String& name, const double *val, size_t count)
811	{
812	setConstant(getParamIndex(name), val, count);
813	}
814	//---------------------------------------------------------------------------
815	void GpuProgramParameters::setNamedConstant(const String& name, const ColourValue& colour)
816	{
817	setConstant(getParamIndex(name), colour);
818	}
819	//---------------------------------------------------------------------------
820	void GpuProgramParameters::setNamedConstant(const String& name, const int *val, size_t count)
821	{
822	setConstant(getParamIndex(name), val, count);
823	}
824	//---------------------------------------------------------------------------
825	void GpuProgramParameters::setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo)
826	{
827	setAutoConstant(getParamIndex(name), acType, extraInfo);
828	}
829	//---------------------------------------------------------------------------
830	void GpuProgramParameters::setConstantFromTime(size_t index, Real factor)
831	{
832	setAutoConstantReal(index, ACT_TIME, factor);
833	}
834	//---------------------------------------------------------------------------
835	void GpuProgramParameters::setNamedConstantFromTime(const String& name, Real factor)
836	{
837	setConstantFromTime(getParamIndex(name), factor);
838	}
839	//---------------------------------------------------------------------------
840	GpuProgramParameters::RealConstantIterator GpuProgramParameters::getRealConstantIterator(void) const
841	{
842	return RealConstantIterator(mRealConstants.begin(), mRealConstants.end());
843	}
844	//---------------------------------------------------------------------------
845	GpuProgramParameters::IntConstantIterator GpuProgramParameters::getIntConstantIterator(void) const
846	{
847	return IntConstantIterator(mIntConstants.begin(), mIntConstants.end());
848	}
849
850	//---------------------------------------------------------------------------
851	GpuProgramParameters::RealConstantEntry* GpuProgramParameters::getRealConstantEntry(const size_t index)
852	{
853	if (index < mRealConstants.size())
854	{
855	return &(mRealConstants[index]);
856	}
857	else
858	{
859	return NULL;
860	}
861	}
862
863	//---------------------------------------------------------------------------
864	GpuProgramParameters::IntConstantEntry* GpuProgramParameters::getIntConstantEntry(const size_t index)
865	{
866	if (index < mIntConstants.size())
867	{
868	return &(mIntConstants[index]);
869	}
870	else
871	{
872	return NULL;
873	}
874	}
875
876	//---------------------------------------------------------------------------
877	GpuProgramParameters::AutoConstantEntry* GpuProgramParameters::getAutoConstantEntry(const size_t index)
878	{
879	if (index < mAutoConstants.size())
880	{
881	return &(mAutoConstants[index]);
882	}
883	else
884	{
885	return NULL;
886	}
887	}
888
889	//---------------------------------------------------------------------------
890	GpuProgramParameters::RealConstantEntry* GpuProgramParameters::getNamedRealConstantEntry(const String& name)
891	{
892	// check if name is found
893	ParamNameMap::const_iterator i = mParamNameMap.find(name);
894
895	if (i == mParamNameMap.end())
896	{
897	// no valid name found
898	return NULL;
899	}
900	else
901	{
902	// name found: return the entry
903	return getRealConstantEntry(i->second);
904	}
905
906	}
907
908	//---------------------------------------------------------------------------
909	GpuProgramParameters::IntConstantEntry* GpuProgramParameters::getNamedIntConstantEntry(const String& name)
910	{
911	// check if name is found
912	ParamNameMap::const_iterator i = mParamNameMap.find(name);
913
914	if (i == mParamNameMap.end())
915	{
916	// no valid name found
917	return NULL;
918	}
919	else
920	{
921	// name found: return the entry
922	return getIntConstantEntry(i->second);
923	}
924
925	}
926
927	//---------------------------------------------------------------------------
928	void GpuProgramParameters::copyConstantsFrom(const GpuProgramParameters& source)
929	{
930	// Iterate over fixed parameters
931	RealConstantIterator ri = source.getRealConstantIterator();
932	ushort i = 0;
933	while(ri.hasMoreElements())
934	{
935	RealConstantEntry re = ri.getNext();
936	if (re.isSet)
937	{
938	setConstant(i, re.val, 4);
939	}
940	++i;
941
942	}
943	IntConstantIterator ii = source.getIntConstantIterator();
944	i = 0;
945	while (ii.hasMoreElements())
946	{
947	IntConstantEntry ie = ii.getNext();
948	if (ie.isSet)
949	{
950	setConstant(i, ie.val, 4);
951	}
952	++i;
953	}
954
955	// Iterate over auto parameters
956	// Clear existing auto constants
957	clearAutoConstants();
958	AutoConstantIterator ai = source.getAutoConstantIterator();
959	while (ai.hasMoreElements())
960	{
961	AutoConstantEntry ae = ai.getNext();
962	setAutoConstant(ae.index, ae.paramType, ae.data);
963	}
964
965	// need to copy Parameter names from the source
966	mParamNameMap = source.mParamNameMap;
967	// copy constant definitions
968	mConstantDefinitions = source.mConstantDefinitions;
969
970
971	}
972
973	//-----------------------------------------------------------------------
974	size_t GpuProgramParameters::addConstantDefinition(const String& name,
975	const size_t index, const size_t elementCount,
976	const ElementType elementType)
977	{
978	size_t idx;
979
980	// check if definition already exists
981	const ConstantDefinition* foundDef =
982	findMatchingConstantDefinition(name, index, elementType);
983
984	// add the definition if it doesn't exist
985	if(!foundDef)
986	{
987	ConstantDefinition def;
988	def.elementType = elementType;
989	def.entryIndex = index;
990	def.elementCount = elementCount;
991	def.name = name;
992
993	mConstantDefinitions.push_back( def );
994	idx = mConstantDefinitions.size() - 1;
995	}
996	else
997	{
998	// calc the index of the found constant definition
999	idx = foundDef - &(*mConstantDefinitions.begin());
1000	// update element count if it was 0 before
1001	if (foundDef->elementCount == 0)
1002	mConstantDefinitions[idx].elementCount = elementCount;
1003	}
1004
1005	return idx;
1006	}
1007
1008	//-----------------------------------------------------------------------
1009	const GpuProgramParameters::ConstantDefinition*
1010	GpuProgramParameters::getConstantDefinition(const String& name) const
1011	{
1012	// find a constant definition that matches name by iterating through
1013	// the constant definition array
1014	ConstantDefinitionContainer::const_iterator currentConstDef
1015	= mConstantDefinitions.begin();
1016	ConstantDefinitionContainer::const_iterator endConstDef
1017	= mConstantDefinitions.end();
1018	while (currentConstDef != endConstDef)
1019	{
1020	if (name == (*currentConstDef).name)
1021	break;
1022	++currentConstDef;
1023	}
1024
1025	if (currentConstDef != endConstDef)
1026	return &(*currentConstDef);
1027	else
1028	return 0;
1029	}
1030
1031	//-----------------------------------------------------------------------
1032	const GpuProgramParameters::ConstantDefinition*
1033	GpuProgramParameters::getConstantDefinition(const size_t idx) const
1034	{
1035	if (idx < mConstantDefinitions.size())
1036	return &mConstantDefinitions[idx];
1037	else
1038	return 0;
1039	}
1040
1041	//-----------------------------------------------------------------------
1042	const GpuProgramParameters::ConstantDefinition*
1043	GpuProgramParameters::findMatchingConstantDefinition(const String& name,
1044	const size_t entryIndex, const ElementType elementType) const
1045	{
1046	ConstantDefinitionContainer::const_iterator currentConstDef
1047	= mConstantDefinitions.begin();
1048	ConstantDefinitionContainer::const_iterator endConstDef
1049	= mConstantDefinitions.end();
1050
1051	while (currentConstDef != endConstDef)
1052	{
1053	if ((name == (*currentConstDef).name)
1054	&& (entryIndex == (*currentConstDef).entryIndex)
1055	&& (elementType == (*currentConstDef).elementType))
1056	break;
1057
1058	++currentConstDef;
1059	}
1060
1061	if (currentConstDef != endConstDef)
1062	return &(*currentConstDef);
1063	else
1064	return 0;
1065
1066	}
1067
1068	//-----------------------------------------------------------------------
1069	void GpuProgramParameters::setConstantDefinitionAutoState(
1070	const size_t index, const bool isAuto, const size_t autoIndex )
1071	{
1072	if (index < mConstantDefinitions.size())
1073	{
1074	ConstantDefinition* cDef = &mConstantDefinitions[index];
1075	cDef->isAuto = isAuto;
1076	// if auto then check to make sure enough storage is allocated and
1077	// update element count
1078	if (isAuto)
1079	{
1080	// get the auto constant entry associated with this constant definition
1081	const GpuProgramParameters::AutoConstantEntry* autoEntry =
1082	getAutoConstantEntry(autoIndex);
1083
1084	if (autoEntry)
1085	{
1086	// get auto constant defintion
1087	const AutoConstantDefinition* autoCDef =
1088	getAutoConstantDefinition(autoEntry->paramType);
1089
1090	// if auto constant exists then its definition will override
1091	// constant definition attributes
1092	if (autoCDef)
1093	{
1094	cDef->autoIndex = autoIndex;
1095	cDef->elementType = autoCDef->elementType;
1096
1097	if (cDef->elementCount < autoCDef->elementCount)
1098	{
1099	cDef->elementCount = autoCDef->elementCount;
1100	// check constant entry list for proper size
1101	const size_t endPos = cDef->entryIndex +
1102	(cDef->elementCount - 1) / 4 + 1;
1103	switch(cDef->elementType)
1104	{
1105	case ET_INT:
1106	if (mIntConstants.size() < endPos)
1107	mIntConstants.resize(endPos);
1108	break;
1109
1110	case ET_REAL:
1111	if (mRealConstants.size() < endPos)
1112	mRealConstants.resize(endPos);
1113	break;
1114	} // end switch
1115	}
1116	}
1117	}
1118	}
1119	}
1120	}
1121
1122	//-----------------------------------------------------------------------
1123	const GpuProgramParameters::AutoConstantDefinition*
1124	GpuProgramParameters::getAutoConstantDefinition(const String& name)
1125	{
1126	// find a constant definition that matches name by iterating through the
1127	// constant definition array
1128	bool nameFound = false;
1129	size_t i = 0;
1130	const size_t numDefs = getNumAutoConstantDefinitions();
1131	while (!nameFound && (i < numDefs))
1132	{
1133	if (name == AutoConstantDictionary[i].name)
1134	nameFound = true;
1135	else
1136	++i;
1137	}
1138
1139	if (nameFound)
1140	return &AutoConstantDictionary[i];
1141	else
1142	return 0;
1143	}
1144
1145	//-----------------------------------------------------------------------
1146	const GpuProgramParameters::AutoConstantDefinition*
1147	GpuProgramParameters::getAutoConstantDefinition(const size_t idx)
1148	{
1149
1150	if (idx < getNumAutoConstantDefinitions())
1151	{
1152	assert(idx == AutoConstantDictionary[idx].acType);
1153	return &AutoConstantDictionary[idx];
1154	}
1155	else
1156	return 0;
1157	}
1158	//-----------------------------------------------------------------------
1159	size_t GpuProgramParameters::getNumAutoConstantDefinitions(void)
1160	{
1161	return sizeof(AutoConstantDictionary)/sizeof(AutoConstantDefinition);
1162	}
1163
1164	//-----------------------------------------------------------------------
1165	void GpuProgramParameters::incPassIterationNumber(void)
1166	{
1167	if (mActivePassIterationEntry)
1168	{
1169	// only increment first element
1170	++mActivePassIterationEntry->val[0];
1171	mActivePassIterationEntry->isSet = true;
1172	}
1173	}
1174
1175	//-----------------------------------------------------------------------
1176	GpuProgramParameters::RealConstantEntry* GpuProgramParameters::getPassIterationEntry(void)
1177	{
1178	return mActivePassIterationEntry;
1179	}
1180	//-----------------------------------------------------------------------
1181	//-----------------------------------------------------------------------
1182	String GpuProgram::CmdType::doGet(const void* target) const
1183	{
1184	const GpuProgram* t = static_cast<const GpuProgram*>(target);
1185	if (t->getType() == GPT_VERTEX_PROGRAM)
1186	{
1187	return "vertex_program";
1188	}
1189	else
1190	{
1191	return "fragment_program";
1192	}
1193	}
1194	void GpuProgram::CmdType::doSet(void* target, const String& val)
1195	{
1196	GpuProgram* t = static_cast<GpuProgram*>(target);
1197	if (val == "vertex_program")
1198	{
1199	t->setType(GPT_VERTEX_PROGRAM);
1200	}
1201	else
1202	{
1203	t->setType(GPT_FRAGMENT_PROGRAM);
1204	}
1205	}
1206	//-----------------------------------------------------------------------
1207	String GpuProgram::CmdSyntax::doGet(const void* target) const
1208	{
1209	const GpuProgram* t = static_cast<const GpuProgram*>(target);
1210	return t->getSyntaxCode();
1211	}
1212	void GpuProgram::CmdSyntax::doSet(void* target, const String& val)
1213	{
1214	GpuProgram* t = static_cast<GpuProgram*>(target);
1215	t->setSyntaxCode(val);
1216	}
1217	//-----------------------------------------------------------------------
1218	String GpuProgram::CmdSkeletal::doGet(const void* target) const
1219	{
1220	const GpuProgram* t = static_cast<const GpuProgram*>(target);
1221	return StringConverter::toString(t->isSkeletalAnimationIncluded());
1222	}
1223	void GpuProgram::CmdSkeletal::doSet(void* target, const String& val)
1224	{
1225	GpuProgram* t = static_cast<GpuProgram*>(target);
1226	t->setSkeletalAnimationIncluded(StringConverter::parseBool(val));
1227	}
1228	//-----------------------------------------------------------------------
1229	GpuProgramPtr& GpuProgramPtr::operator=(const HighLevelGpuProgramPtr& r)
1230	{
1231	// Can assign direct
1232	if (pRep == r.getPointer())
1233	return *this;
1234	release();
1235	// lock & copy other mutex pointer
1236	OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
1237	OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
1238	pRep = r.getPointer();
1239	pUseCount = r.useCountPointer();
1240	if (pUseCount)
1241	{
1242	++(*pUseCount);
1243	}
1244	return *this;
1245	}
1246
1247	}

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

Context Navigation

source: OGRE/trunk/ogrenew/OgreMain/src/OgreGpuProgram.cpp @ 692

Download in other formats: