Context Navigation

OgreMaterialSerializer.cpp @ 692

Revision 692, 169.6 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
27	#include "OgreMaterialSerializer.h"
28	#include "OgreStringConverter.h"
29	#include "OgreLogManager.h"
30	#include "OgreException.h"
31	#include "OgreTechnique.h"
32	#include "OgrePass.h"
33	#include "OgreTextureUnitState.h"
34	#include "OgreMaterialManager.h"
35	#include "OgreGpuProgramManager.h"
36	#include "OgreHighLevelGpuProgramManager.h"
37	#include "OgreExternalTextureSourceManager.h"
38
39	namespace Ogre
40	{
41
42	//-----------------------------------------------------------------------
43	// Internal parser methods
44	//-----------------------------------------------------------------------
45	void logParseError(const String& error, const MaterialScriptContext& context)
46	{
47	// log material name only if filename not specified
48	if (context.filename.empty() && !context.material.isNull())
49	{
50	LogManager::getSingleton().logMessage(
51	"Error in material " + context.material->getName() +
52	" : " + error);
53	}
54	else
55	{
56	if (!context.material.isNull())
57	{
58	LogManager::getSingleton().logMessage(
59	"Error in material " + context.material->getName() +
60	" at line " + StringConverter::toString(context.lineNo) +
61	" of " + context.filename + ": " + error);
62	}
63	else
64	{
65	LogManager::getSingleton().logMessage(
66	"Error at line " + StringConverter::toString(context.lineNo) +
67	" of " + context.filename + ": " + error);
68	}
69	}
70	}
71	//-----------------------------------------------------------------------
72	ColourValue _parseColourValue(StringVector& vecparams)
73	{
74	return ColourValue(
75	StringConverter::parseReal(vecparams[0]) ,
76	StringConverter::parseReal(vecparams[1]) ,
77	StringConverter::parseReal(vecparams[2]) ,
78	(vecparams.size()==4) ? StringConverter::parseReal(vecparams[3]) : 1.0f ) ;
79	}
80	//-----------------------------------------------------------------------
81	FilterOptions convertFiltering(const String& s)
82	{
83	if (s == "none")
84	{
85	return FO_NONE;
86	}
87	else if (s == "point")
88	{
89	return FO_POINT;
90	}
91	else if (s == "linear")
92	{
93	return FO_LINEAR;
94	}
95	else if (s == "anisotropic")
96	{
97	return FO_ANISOTROPIC;
98	}
99
100	return FO_POINT;
101	}
102	//-----------------------------------------------------------------------
103	bool parseAmbient(String& params, MaterialScriptContext& context)
104	{
105	StringVector vecparams = StringUtil::split(params, " \t");
106	// Must be 1, 3 or 4 parameters
107	if (vecparams.size() == 1) {
108	if(vecparams[0] == "vertexcolour") {
109	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() \| TVC_AMBIENT);
110	} else {
111	logParseError(
112	"Bad ambient attribute, single parameter flag must be 'vertexcolour'",
113	context);
114	}
115	}
116	else if (vecparams.size() == 3 \|\| vecparams.size() == 4)
117	{
118	context.pass->setAmbient( _parseColourValue(vecparams) );
119	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() & ~TVC_AMBIENT);
120	}
121	else
122	{
123	logParseError(
124	"Bad ambient attribute, wrong number of parameters (expected 1, 3 or 4)",
125	context);
126	}
127	return false;
128	}
129	//-----------------------------------------------------------------------
130	bool parseDiffuse(String& params, MaterialScriptContext& context)
131	{
132	StringVector vecparams = StringUtil::split(params, " \t");
133	// Must be 1, 3 or 4 parameters
134	if (vecparams.size() == 1) {
135	if(vecparams[0] == "vertexcolour") {
136	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() \| TVC_DIFFUSE);
137	} else {
138	logParseError(
139	"Bad diffuse attribute, single parameter flag must be 'vertexcolour'",
140	context);
141	}
142	}
143	else if (vecparams.size() == 3 \|\| vecparams.size() == 4)
144	{
145	context.pass->setDiffuse( _parseColourValue(vecparams) );
146	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() & ~TVC_DIFFUSE);
147	}
148	else
149	{
150	logParseError(
151	"Bad diffuse attribute, wrong number of parameters (expected 1, 3 or 4)",
152	context);
153	} return false;
154	}
155	//-----------------------------------------------------------------------
156	bool parseSpecular(String& params, MaterialScriptContext& context)
157	{
158	StringVector vecparams = StringUtil::split(params, " \t");
159	// Must be 2, 4 or 5 parameters
160	if(vecparams.size() == 2)
161	{
162	if(vecparams[0] == "vertexcolour") {
163	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() \| TVC_SPECULAR);
164	context.pass->setShininess(StringConverter::parseReal(vecparams[1]) );
165	}
166	else
167	{
168	logParseError(
169	"Bad specular attribute, double parameter statement must be 'vertexcolour <shininess>'",
170	context);
171	}
172	}
173	else if(vecparams.size() == 4 \|\| vecparams.size() == 5)
174	{
175	context.pass->setSpecular(
176	StringConverter::parseReal(vecparams[0]),
177	StringConverter::parseReal(vecparams[1]),
178	StringConverter::parseReal(vecparams[2]),
179	vecparams.size() == 5?
180	StringConverter::parseReal(vecparams[3]) : 1.0f);
181	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() & ~TVC_SPECULAR);
182	context.pass->setShininess(
183	StringConverter::parseReal(vecparams[vecparams.size() - 1]) );
184	}
185	else
186	{
187	logParseError(
188	"Bad specular attribute, wrong number of parameters (expected 2, 4 or 5)",
189	context);
190	}
191	return false;
192	}
193	//-----------------------------------------------------------------------
194	bool parseEmissive(String& params, MaterialScriptContext& context)
195	{
196	StringVector vecparams = StringUtil::split(params, " \t");
197	// Must be 1, 3 or 4 parameters
198	if (vecparams.size() == 1) {
199	if(vecparams[0] == "vertexcolour") {
200	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() \| TVC_EMISSIVE);
201	} else {
202	logParseError(
203	"Bad emissive attribute, single parameter flag must be 'vertexcolour'",
204	context);
205	}
206	}
207	else if (vecparams.size() == 3 \|\| vecparams.size() == 4)
208	{
209	context.pass->setSelfIllumination( _parseColourValue(vecparams) );
210	context.pass->setVertexColourTracking(context.pass->getVertexColourTracking() & ~TVC_EMISSIVE);
211	}
212	else
213	{
214	logParseError(
215	"Bad emissive attribute, wrong number of parameters (expected 1, 3 or 4)",
216	context);
217	}
218	return false;
219	}
220	//-----------------------------------------------------------------------
221	SceneBlendFactor convertBlendFactor(const String& param)
222	{
223	if (param == "one")
224	return SBF_ONE;
225	else if (param == "zero")
226	return SBF_ZERO;
227	else if (param == "dest_colour")
228	return SBF_DEST_COLOUR;
229	else if (param == "src_colour")
230	return SBF_SOURCE_COLOUR;
231	else if (param == "one_minus_dest_colour")
232	return SBF_ONE_MINUS_DEST_COLOUR;
233	else if (param == "one_minus_src_colour")
234	return SBF_ONE_MINUS_SOURCE_COLOUR;
235	else if (param == "dest_alpha")
236	return SBF_DEST_ALPHA;
237	else if (param == "src_alpha")
238	return SBF_SOURCE_ALPHA;
239	else if (param == "one_minus_dest_alpha")
240	return SBF_ONE_MINUS_DEST_ALPHA;
241	else if (param == "one_minus_src_alpha")
242	return SBF_ONE_MINUS_SOURCE_ALPHA;
243	else
244	{
245	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid blend factor.", "convertBlendFactor");
246	}
247
248
249	}
250	//-----------------------------------------------------------------------
251	bool parseSceneBlend(String& params, MaterialScriptContext& context)
252	{
253	StringUtil::toLowerCase(params);
254	StringVector vecparams = StringUtil::split(params, " \t");
255	// Should be 1 or 2 params
256	if (vecparams.size() == 1)
257	{
258	//simple
259	SceneBlendType stype;
260	if (vecparams[0] == "add")
261	stype = SBT_ADD;
262	else if (vecparams[0] == "modulate")
263	stype = SBT_MODULATE;
264	else if (vecparams[0] == "colour_blend")
265	stype = SBT_TRANSPARENT_COLOUR;
266	else if (vecparams[0] == "alpha_blend")
267	stype = SBT_TRANSPARENT_ALPHA;
268	else
269	{
270	logParseError(
271	"Bad scene_blend attribute, unrecognised parameter '" + vecparams[0] + "'",
272	context);
273	return false;
274	}
275	context.pass->setSceneBlending(stype);
276
277	}
278	else if (vecparams.size() == 2)
279	{
280	//src/dest
281	SceneBlendFactor src, dest;
282
283	try {
284	src = convertBlendFactor(vecparams[0]);
285	dest = convertBlendFactor(vecparams[1]);
286	context.pass->setSceneBlending(src,dest);
287	}
288	catch (Exception& e)
289	{
290	logParseError("Bad scene_blend attribute, " + e.getFullDescription(), context);
291	}
292
293	}
294	else
295	{
296	logParseError(
297	"Bad scene_blend attribute, wrong number of parameters (expected 1 or 2)",
298	context);
299	}
300
301	return false;
302
303	}
304	//-----------------------------------------------------------------------
305	CompareFunction convertCompareFunction(const String& param)
306	{
307	if (param == "always_fail")
308	return CMPF_ALWAYS_FAIL;
309	else if (param == "always_pass")
310	return CMPF_ALWAYS_PASS;
311	else if (param == "less")
312	return CMPF_LESS;
313	else if (param == "less_equal")
314	return CMPF_LESS_EQUAL;
315	else if (param == "equal")
316	return CMPF_EQUAL;
317	else if (param == "not_equal")
318	return CMPF_NOT_EQUAL;
319	else if (param == "greater_equal")
320	return CMPF_GREATER_EQUAL;
321	else if (param == "greater")
322	return CMPF_GREATER;
323	else
324	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid compare function", "convertCompareFunction");
325
326	}
327	//-----------------------------------------------------------------------
328	bool parseDepthCheck(String& params, MaterialScriptContext& context)
329	{
330	StringUtil::toLowerCase(params);
331	if (params == "on")
332	context.pass->setDepthCheckEnabled(true);
333	else if (params == "off")
334	context.pass->setDepthCheckEnabled(false);
335	else
336	logParseError(
337	"Bad depth_check attribute, valid parameters are 'on' or 'off'.",
338	context);
339
340	return false;
341	}
342	//-----------------------------------------------------------------------
343	bool parseDepthWrite(String& params, MaterialScriptContext& context)
344	{
345	StringUtil::toLowerCase(params);
346	if (params == "on")
347	context.pass->setDepthWriteEnabled(true);
348	else if (params == "off")
349	context.pass->setDepthWriteEnabled(false);
350	else
351	logParseError(
352	"Bad depth_write attribute, valid parameters are 'on' or 'off'.",
353	context);
354	return false;
355	}
356
357	//-----------------------------------------------------------------------
358	bool parseDepthFunc(String& params, MaterialScriptContext& context)
359	{
360	StringUtil::toLowerCase(params);
361	try {
362	CompareFunction func = convertCompareFunction(params);
363	context.pass->setDepthFunction(func);
364	}
365	catch (...)
366	{
367	logParseError("Bad depth_func attribute, invalid function parameter.", context);
368	}
369
370	return false;
371	}
372	//-----------------------------------------------------------------------
373	bool parseColourWrite(String& params, MaterialScriptContext& context)
374	{
375	StringUtil::toLowerCase(params);
376	if (params == "on")
377	context.pass->setColourWriteEnabled(true);
378	else if (params == "off")
379	context.pass->setColourWriteEnabled(false);
380	else
381	logParseError(
382	"Bad colour_write attribute, valid parameters are 'on' or 'off'.",
383	context);
384	return false;
385	}
386
387	//-----------------------------------------------------------------------
388	bool parseCullHardware(String& params, MaterialScriptContext& context)
389	{
390	StringUtil::toLowerCase(params);
391	if (params=="none")
392	context.pass->setCullingMode(CULL_NONE);
393	else if (params=="anticlockwise")
394	context.pass->setCullingMode(CULL_ANTICLOCKWISE);
395	else if (params=="clockwise")
396	context.pass->setCullingMode(CULL_CLOCKWISE);
397	else
398	logParseError(
399	"Bad cull_hardware attribute, valid parameters are "
400	"'none', 'clockwise' or 'anticlockwise'.", context);
401	return false;
402	}
403	//-----------------------------------------------------------------------
404	bool parseCullSoftware(String& params, MaterialScriptContext& context)
405	{
406	StringUtil::toLowerCase(params);
407	if (params=="none")
408	context.pass->setManualCullingMode(MANUAL_CULL_NONE);
409	else if (params=="back")
410	context.pass->setManualCullingMode(MANUAL_CULL_BACK);
411	else if (params=="front")
412	context.pass->setManualCullingMode(MANUAL_CULL_FRONT);
413	else
414	logParseError(
415	"Bad cull_software attribute, valid parameters are 'none', "
416	"'front' or 'back'.", context);
417	return false;
418	}
419	//-----------------------------------------------------------------------
420	bool parseLighting(String& params, MaterialScriptContext& context)
421	{
422	StringUtil::toLowerCase(params);
423	if (params=="on")
424	context.pass->setLightingEnabled(true);
425	else if (params=="off")
426	context.pass->setLightingEnabled(false);
427	else
428	logParseError(
429	"Bad lighting attribute, valid parameters are 'on' or 'off'.", context);
430	return false;
431	}
432	//-----------------------------------------------------------------------
433	bool parseMaxLights(String& params, MaterialScriptContext& context)
434	{
435	context.pass->setMaxSimultaneousLights(StringConverter::parseInt(params));
436	return false;
437	}
438	//-----------------------------------------------------------------------
439	void parseIterationLightTypes(String& params, MaterialScriptContext& context)
440	{
441	// Parse light type
442	if (params == "directional")
443	{
444	context.pass->setIteratePerLight(true, true, Light::LT_DIRECTIONAL);
445	}
446	else if (params == "point")
447	{
448	context.pass->setIteratePerLight(true, true, Light::LT_POINT);
449	}
450	else if (params == "spot")
451	{
452	context.pass->setIteratePerLight(true, true, Light::LT_SPOTLIGHT);
453	}
454	else
455	{
456	logParseError("Bad iteration attribute, valid values for light type parameter "
457	"are 'point' or 'directional' or 'spot'.", context);
458	}
459
460	}
461	//-----------------------------------------------------------------------
462	bool parseIteration(String& params, MaterialScriptContext& context)
463	{
464	// we could have more than one parameter
465	/** combinations could be:
466	iteration once
467	iteration once_per_light [light type]
468	iteration <number>
469	iteration <number> [per_light] [light type]
470	*/
471	StringUtil::toLowerCase(params);
472	StringVector vecparams = StringUtil::split(params, " \t");
473	if (vecparams.size() < 1 \|\| vecparams.size() > 3)
474	{
475	logParseError("Bad iteration attribute, expected 1 to 3 parameters.", context);
476	return false;
477	}
478
479	if (vecparams[0]=="once")
480	context.pass->setIteratePerLight(false);
481	else if (vecparams[0]=="once_per_light")
482	{
483	if (vecparams.size() == 2)
484	{
485	parseIterationLightTypes(vecparams[1], context);
486	}
487	else
488	{
489	context.pass->setIteratePerLight(true, false);
490	}
491
492	}
493	else // could be using form: <number> [per_light] [light type]
494	{
495	int passIterationCount = StringConverter::parseInt(vecparams[0]);
496	if (passIterationCount > 0)
497	{
498	context.pass->setPassIterationCount(passIterationCount);
499	if (vecparams.size() > 1)
500	{
501	if (vecparams[1] == "per_light")
502	{
503	if (vecparams.size() == 3)
504	{
505	parseIterationLightTypes(vecparams[2], context);
506	}
507	else
508	{
509	context.pass->setIteratePerLight(true, false);
510	}
511	}
512	else
513	logParseError(
514	"Bad iteration attribute, valid parameters are <number> [per_light] [light type].", context);
515	}
516	}
517	else
518	logParseError(
519	"Bad iteration attribute, valid parameters are 'once' or 'once_per_light' or <number> [per_light] [light type].", context);
520	}
521	return false;
522	}
523	//-----------------------------------------------------------------------
524	bool parsePointSize(String& params, MaterialScriptContext& context)
525	{
526	context.pass->setPointSize(StringConverter::parseReal(params));
527	return false;
528	}
529	//-----------------------------------------------------------------------
530	bool parsePointSprites(String& params, MaterialScriptContext& context)
531	{
532	if (params=="on")
533	context.pass->setPointSpritesEnabled(true);
534	else if (params=="off")
535	context.pass->setPointSpritesEnabled(false);
536	else
537	logParseError(
538	"Bad point_sprites attribute, valid parameters are 'on' or 'off'.", context);
539
540	return false;
541	}
542	//-----------------------------------------------------------------------
543	bool parsePointAttenuation(String& params, MaterialScriptContext& context)
544	{
545	StringVector vecparams = StringUtil::split(params, " \t");
546	if (vecparams.size() != 1 && vecparams.size() != 4)
547	{
548	logParseError("Bad point_size_attenuation attribute, 1 or 4 parameters expected", context);
549	return false;
550	}
551	if (vecparams[0] == "off")
552	{
553	context.pass->setPointAttenuation(false);
554	}
555	else if (vecparams[0] == "on")
556	{
557	if (vecparams.size() == 4)
558	{
559	context.pass->setPointAttenuation(true,
560	StringConverter::parseReal(vecparams[1]),
561	StringConverter::parseReal(vecparams[2]),
562	StringConverter::parseReal(vecparams[3]));
563	}
564	else
565	{
566	context.pass->setPointAttenuation(true);
567	}
568	}
569
570	return false;
571	}
572	//-----------------------------------------------------------------------
573	bool parsePointSizeMin(String& params, MaterialScriptContext& context)
574	{
575	context.pass->setPointMinSize(
576	StringConverter::parseReal(params));
577	return false;
578	}
579	//-----------------------------------------------------------------------
580	bool parsePointSizeMax(String& params, MaterialScriptContext& context)
581	{
582	context.pass->setPointMaxSize(
583	StringConverter::parseReal(params));
584	return false;
585	}
586	//-----------------------------------------------------------------------
587	bool parseFogging(String& params, MaterialScriptContext& context)
588	{
589	StringUtil::toLowerCase(params);
590	StringVector vecparams = StringUtil::split(params, " \t");
591	if (vecparams[0]=="true")
592	{
593	// if true, we need to see if they supplied all arguments, or just the 1... if just the one,
594	// Assume they want to disable the default fog from effecting this material.
595	if( vecparams.size() == 8 )
596	{
597	FogMode mFogtype;
598	if( vecparams[1] == "none" )
599	mFogtype = FOG_NONE;
600	else if( vecparams[1] == "linear" )
601	mFogtype = FOG_LINEAR;
602	else if( vecparams[1] == "exp" )
603	mFogtype = FOG_EXP;
604	else if( vecparams[1] == "exp2" )
605	mFogtype = FOG_EXP2;
606	else
607	{
608	logParseError(
609	"Bad fogging attribute, valid parameters are "
610	"'none', 'linear', 'exp', or 'exp2'.", context);
611	return false;
612	}
613
614	context.pass->setFog(
615	true,
616	mFogtype,
617	ColourValue(
618	StringConverter::parseReal(vecparams[2]),
619	StringConverter::parseReal(vecparams[3]),
620	StringConverter::parseReal(vecparams[4])),
621	StringConverter::parseReal(vecparams[5]),
622	StringConverter::parseReal(vecparams[6]),
623	StringConverter::parseReal(vecparams[7])
624	);
625	}
626	else
627	{
628	context.pass->setFog(true);
629	}
630	}
631	else if (vecparams[0]=="false")
632	context.pass->setFog(false);
633	else
634	logParseError(
635	"Bad fog_override attribute, valid parameters are 'true' or 'false'.",
636	context);
637
638	return false;
639	}
640	//-----------------------------------------------------------------------
641	bool parseShading(String& params, MaterialScriptContext& context)
642	{
643	StringUtil::toLowerCase(params);
644	if (params=="flat")
645	context.pass->setShadingMode(SO_FLAT);
646	else if (params=="gouraud")
647	context.pass->setShadingMode(SO_GOURAUD);
648	else if (params=="phong")
649	context.pass->setShadingMode(SO_PHONG);
650	else
651	logParseError("Bad shading attribute, valid parameters are 'flat', "
652	"'gouraud' or 'phong'.", context);
653
654	return false;
655	}
656	//-----------------------------------------------------------------------
657	bool parsePolygonMode(String& params, MaterialScriptContext& context)
658	{
659	StringUtil::toLowerCase(params);
660	if (params=="solid")
661	context.pass->setPolygonMode(PM_SOLID);
662	else if (params=="wireframe")
663	context.pass->setPolygonMode(PM_WIREFRAME);
664	else if (params=="points")
665	context.pass->setPolygonMode(PM_POINTS);
666	else
667	logParseError("Bad polygon_mode attribute, valid parameters are 'solid', "
668	"'wireframe' or 'points'.", context);
669
670	return false;
671	}
672	//-----------------------------------------------------------------------
673	bool parseFiltering(String& params, MaterialScriptContext& context)
674	{
675	StringUtil::toLowerCase(params);
676	StringVector vecparams = StringUtil::split(params, " \t");
677	// Must be 1 or 3 parameters
678	if (vecparams.size() == 1)
679	{
680	// Simple format
681	if (vecparams[0]=="none")
682	context.textureUnit->setTextureFiltering(TFO_NONE);
683	else if (vecparams[0]=="bilinear")
684	context.textureUnit->setTextureFiltering(TFO_BILINEAR);
685	else if (vecparams[0]=="trilinear")
686	context.textureUnit->setTextureFiltering(TFO_TRILINEAR);
687	else if (vecparams[0]=="anisotropic")
688	context.textureUnit->setTextureFiltering(TFO_ANISOTROPIC);
689	else
690	{
691	logParseError("Bad filtering attribute, valid parameters for simple format are "
692	"'none', 'bilinear', 'trilinear' or 'anisotropic'.", context);
693	return false;
694	}
695	}
696	else if (vecparams.size() == 3)
697	{
698	// Complex format
699	context.textureUnit->setTextureFiltering(
700	convertFiltering(vecparams[0]),
701	convertFiltering(vecparams[1]),
702	convertFiltering(vecparams[2]));
703
704
705	}
706	else
707	{
708	logParseError(
709	"Bad filtering attribute, wrong number of parameters (expected 1 or 3)",
710	context);
711	}
712
713	return false;
714	}
715	//-----------------------------------------------------------------------
716	// Texture layer attributes
717	bool parseTexture(String& params, MaterialScriptContext& context)
718	{
719	StringVector vecparams = StringUtil::split(params, " \t");
720	const size_t numParams = vecparams.size();
721	if (numParams > 4)
722	{
723	logParseError("Invalid texture attribute - expected only 1, 2, 3 or 4 parameters.",
724	context);
725	}
726	TextureType tt = TEX_TYPE_2D;
727	int mips = MIP_UNLIMITED; // When passed to TextureManager::load, this means default to default number of mipmaps
728	bool isAlpha = false;
729	if (numParams >= 2)
730	{
731	StringUtil::toLowerCase(vecparams[1]);
732	if (vecparams[1] == "1d")
733	{
734	tt = TEX_TYPE_1D;
735	}
736	else if (vecparams[1] == "2d")
737	{
738	tt = TEX_TYPE_2D;
739	}
740	else if (vecparams[1] == "3d")
741	{
742	tt = TEX_TYPE_3D;
743	}
744	else if (vecparams[1] == "cubic")
745	{
746	tt = TEX_TYPE_CUBE_MAP;
747	}
748	else
749	{
750	logParseError("Invalid texture type - "+vecparams[1]+".",
751	context);
752	}
753	}
754	if (numParams >= 3)
755	{
756	StringUtil::toLowerCase(vecparams[2]);
757	if (vecparams[2] == "unlimited")
758	{
759	mips = MIP_UNLIMITED;
760	}
761	else
762	{
763	mips = StringConverter::parseInt(vecparams[2]);
764	}
765	}
766	if (numParams >= 4)
767	{
768	StringUtil::toLowerCase(vecparams[3]);
769	if (vecparams[3] == "alpha")
770	{
771	isAlpha = true;
772	}
773	}
774	context.textureUnit->setTextureName(vecparams[0], tt, mips, isAlpha);
775	return false;
776	}
777	//-----------------------------------------------------------------------
778	bool parseAnimTexture(String& params, MaterialScriptContext& context)
779	{
780	StringVector vecparams = StringUtil::split(params, " \t");
781	size_t numParams = vecparams.size();
782	// Determine which form it is
783	// Must have at least 3 params though
784	if (numParams < 3)
785	{
786	logParseError("Bad anim_texture attribute, wrong number of parameters "
787	"(expected at least 3)", context);
788	return false;
789	}
790	if (numParams == 3 && StringConverter::parseInt(vecparams[1]) != 0 )
791	{
792	// First form using base name & number of frames
793	context.textureUnit->setAnimatedTextureName(
794	vecparams[0],
795	StringConverter::parseInt(vecparams[1]),
796	StringConverter::parseReal(vecparams[2]));
797	}
798	else
799	{
800	// Second form using individual names
801	context.textureUnit->setAnimatedTextureName(
802	(String*)&vecparams[0],
803	numParams-1,
804	StringConverter::parseReal(vecparams[numParams-1]));
805	}
806	return false;
807
808	}
809	//-----------------------------------------------------------------------
810	bool parseCubicTexture(String& params, MaterialScriptContext& context)
811	{
812
813	StringVector vecparams = StringUtil::split(params, " \t");
814	size_t numParams = vecparams.size();
815
816	// Get final param
817	bool useUVW;
818	String& uvOpt = vecparams[numParams-1];
819	StringUtil::toLowerCase(uvOpt);
820	if (uvOpt == "combineduvw")
821	useUVW = true;
822	else if (uvOpt == "separateuv")
823	useUVW = false;
824	else
825	{
826	logParseError("Bad cubic_texture attribute, final parameter must be "
827	"'combinedUVW' or 'separateUV'.", context);
828	return false;
829	}
830	// Determine which form it is
831	if (numParams == 2)
832	{
833	// First form using base name
834	context.textureUnit->setCubicTextureName(vecparams[0], useUVW);
835	}
836	else if (numParams == 7)
837	{
838	// Second form using individual names
839	// Can use vecparams[0] as array start point
840	context.textureUnit->setCubicTextureName((String*)&vecparams[0], useUVW);
841	}
842	else
843	{
844	logParseError(
845	"Bad cubic_texture attribute, wrong number of parameters (expected 2 or 7)",
846	context);
847	return false;
848	}
849
850	return false;
851	}
852	//-----------------------------------------------------------------------
853	bool parseTexCoord(String& params, MaterialScriptContext& context)
854	{
855	context.textureUnit->setTextureCoordSet(
856	StringConverter::parseInt(params));
857
858	return false;
859	}
860	//-----------------------------------------------------------------------
861	TextureUnitState::TextureAddressingMode convTexAddressMode(const String& params, MaterialScriptContext& context)
862	{
863	if (params=="wrap")
864	return TextureUnitState::TAM_WRAP;
865	else if (params=="mirror")
866	return TextureUnitState::TAM_MIRROR;
867	else if (params=="clamp")
868	return TextureUnitState::TAM_CLAMP;
869	else if (params=="border")
870	return TextureUnitState::TAM_BORDER;
871	else
872	logParseError("Bad tex_address_mode attribute, valid parameters are "
873	"'wrap', 'mirror', 'clamp' or 'border'.", context);
874	// default
875	return TextureUnitState::TAM_WRAP;
876	}
877	//-----------------------------------------------------------------------
878	bool parseTexAddressMode(String& params, MaterialScriptContext& context)
879	{
880	StringUtil::toLowerCase(params);
881
882	StringVector vecparams = StringUtil::split(params, " \t");
883	size_t numParams = vecparams.size();
884
885	if (numParams > 3 \|\| numParams < 1)
886	{
887	logParseError("Invalid number of parameters to tex_address_mode"
888	" - must be between 1 and 3", context);
889	}
890	if (numParams == 1)
891	{
892	// Single-parameter option
893	context.textureUnit->setTextureAddressingMode(
894	convTexAddressMode(vecparams[0], context));
895	}
896	else
897	{
898	// 2-3 parameter option
899	TextureUnitState::UVWAddressingMode uvw;
900	uvw.u = convTexAddressMode(vecparams[0], context);
901	uvw.v = convTexAddressMode(vecparams[1], context);
902	if (numParams == 3)
903	{
904	// w
905	uvw.w = convTexAddressMode(vecparams[2], context);
906	}
907	else
908	{
909	uvw.w = TextureUnitState::TAM_WRAP;
910	}
911	context.textureUnit->setTextureAddressingMode(uvw);
912	}
913	return false;
914	}
915	//-----------------------------------------------------------------------
916	bool parseTexBorderColour(String& params, MaterialScriptContext& context)
917	{
918	StringVector vecparams = StringUtil::split(params, " \t");
919	// Must be 3 or 4 parameters
920	if (vecparams.size() == 3 \|\| vecparams.size() == 4)
921	{
922	context.textureUnit->setTextureBorderColour( _parseColourValue(vecparams) );
923	}
924	else
925	{
926	logParseError(
927	"Bad tex_border_colour attribute, wrong number of parameters (expected 3 or 4)",
928	context);
929	}
930	return false;
931	}
932	//-----------------------------------------------------------------------
933	bool parseColourOp(String& params, MaterialScriptContext& context)
934	{
935	StringUtil::toLowerCase(params);
936	if (params=="replace")
937	context.textureUnit->setColourOperation(LBO_REPLACE);
938	else if (params=="add")
939	context.textureUnit->setColourOperation(LBO_ADD);
940	else if (params=="modulate")
941	context.textureUnit->setColourOperation(LBO_MODULATE);
942	else if (params=="alpha_blend")
943	context.textureUnit->setColourOperation(LBO_ALPHA_BLEND);
944	else
945	logParseError("Bad colour_op attribute, valid parameters are "
946	"'replace', 'add', 'modulate' or 'alpha_blend'.", context);
947
948	return false;
949	}
950	//-----------------------------------------------------------------------
951	bool parseAlphaRejection(String& params, MaterialScriptContext& context)
952	{
953	StringUtil::toLowerCase(params);
954	StringVector vecparams = StringUtil::split(params, " \t");
955	if (vecparams.size() != 2)
956	{
957	logParseError(
958	"Bad alpha_rejection attribute, wrong number of parameters (expected 2)",
959	context);
960	return false;
961	}
962
963	CompareFunction cmp;
964	try {
965	cmp = convertCompareFunction(vecparams[0]);
966	}
967	catch (...)
968	{
969	logParseError("Bad alpha_rejection attribute, invalid compare function.", context);
970	return false;
971	}
972
973	context.pass->setAlphaRejectSettings(cmp, StringConverter::parseInt(vecparams[1]));
974
975	return false;
976	}
977	//-----------------------------------------------------------------------
978	LayerBlendOperationEx convertBlendOpEx(const String& param)
979	{
980	if (param == "source1")
981	return LBX_SOURCE1;
982	else if (param == "source2")
983	return LBX_SOURCE2;
984	else if (param == "modulate")
985	return LBX_MODULATE;
986	else if (param == "modulate_x2")
987	return LBX_MODULATE_X2;
988	else if (param == "modulate_x4")
989	return LBX_MODULATE_X4;
990	else if (param == "add")
991	return LBX_ADD;
992	else if (param == "add_signed")
993	return LBX_ADD_SIGNED;
994	else if (param == "add_smooth")
995	return LBX_ADD_SMOOTH;
996	else if (param == "subtract")
997	return LBX_SUBTRACT;
998	else if (param == "blend_diffuse_colour")
999	return LBX_BLEND_DIFFUSE_COLOUR;
1000	else if (param == "blend_diffuse_alpha")
1001	return LBX_BLEND_DIFFUSE_ALPHA;
1002	else if (param == "blend_texture_alpha")
1003	return LBX_BLEND_TEXTURE_ALPHA;
1004	else if (param == "blend_current_alpha")
1005	return LBX_BLEND_CURRENT_ALPHA;
1006	else if (param == "blend_manual")
1007	return LBX_BLEND_MANUAL;
1008	else if (param == "dotproduct")
1009	return LBX_DOTPRODUCT;
1010	else
1011	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid blend function", "convertBlendOpEx");
1012	}
1013	//-----------------------------------------------------------------------
1014	LayerBlendSource convertBlendSource(const String& param)
1015	{
1016	if (param == "src_current")
1017	return LBS_CURRENT;
1018	else if (param == "src_texture")
1019	return LBS_TEXTURE;
1020	else if (param == "src_diffuse")
1021	return LBS_DIFFUSE;
1022	else if (param == "src_specular")
1023	return LBS_SPECULAR;
1024	else if (param == "src_manual")
1025	return LBS_MANUAL;
1026	else
1027	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid blend source", "convertBlendSource");
1028	}
1029	//-----------------------------------------------------------------------
1030	bool parseColourOpEx(String& params, MaterialScriptContext& context)
1031	{
1032	StringUtil::toLowerCase(params);
1033	StringVector vecparams = StringUtil::split(params, " \t");
1034	size_t numParams = vecparams.size();
1035
1036	if (numParams < 3 \|\| numParams > 10)
1037	{
1038	logParseError(
1039	"Bad colour_op_ex attribute, wrong number of parameters (expected 3 to 10)",
1040	context);
1041	return false;
1042	}
1043	LayerBlendOperationEx op;
1044	LayerBlendSource src1, src2;
1045	Real manual = 0.0;
1046	ColourValue colSrc1 = ColourValue::White;
1047	ColourValue colSrc2 = ColourValue::White;
1048
1049	try {
1050	op = convertBlendOpEx(vecparams[0]);
1051	src1 = convertBlendSource(vecparams[1]);
1052	src2 = convertBlendSource(vecparams[2]);
1053
1054	if (op == LBX_BLEND_MANUAL)
1055	{
1056	if (numParams < 4)
1057	{
1058	logParseError("Bad colour_op_ex attribute, wrong number of parameters "
1059	"(expected 4 for manual blend)", context);
1060	return false;
1061	}
1062	manual = StringConverter::parseReal(vecparams[3]);
1063	}
1064
1065	if (src1 == LBS_MANUAL)
1066	{
1067	unsigned int parIndex = 3;
1068	if (op == LBX_BLEND_MANUAL)
1069	parIndex++;
1070
1071	if (numParams < parIndex + 3)
1072	{
1073	logParseError("Bad colour_op_ex attribute, wrong number of parameters "
1074	"(expected " + StringConverter::toString(parIndex + 3) + ")", context);
1075	return false;
1076	}
1077
1078	colSrc1.r = StringConverter::parseReal(vecparams[parIndex++]);
1079	colSrc1.g = StringConverter::parseReal(vecparams[parIndex++]);
1080	colSrc1.b = StringConverter::parseReal(vecparams[parIndex++]);
1081	if (numParams > parIndex)
1082	{
1083	colSrc1.a = StringConverter::parseReal(vecparams[parIndex]);
1084	}
1085	else
1086	{
1087	colSrc1.a = 1.0f;
1088	}
1089	}
1090
1091	if (src2 == LBS_MANUAL)
1092	{
1093	unsigned int parIndex = 3;
1094	if (op == LBX_BLEND_MANUAL)
1095	parIndex++;
1096	if (src1 == LBS_MANUAL)
1097	parIndex += 3;
1098
1099	if (numParams < parIndex + 3)
1100	{
1101	logParseError("Bad colour_op_ex attribute, wrong number of parameters "
1102	"(expected " + StringConverter::toString(parIndex + 3) + ")", context);
1103	return false;
1104	}
1105
1106	colSrc2.r = StringConverter::parseReal(vecparams[parIndex++]);
1107	colSrc2.g = StringConverter::parseReal(vecparams[parIndex++]);
1108	colSrc2.b = StringConverter::parseReal(vecparams[parIndex++]);
1109	if (numParams > parIndex)
1110	{
1111	colSrc2.a = StringConverter::parseReal(vecparams[parIndex]);
1112	}
1113	else
1114	{
1115	colSrc2.a = 1.0f;
1116	}
1117	}
1118	}
1119	catch (Exception& e)
1120	{
1121	logParseError("Bad colour_op_ex attribute, " + e.getFullDescription(), context);
1122	return false;
1123	}
1124
1125	context.textureUnit->setColourOperationEx(op, src1, src2, colSrc1, colSrc2, manual);
1126	return false;
1127	}
1128	//-----------------------------------------------------------------------
1129	bool parseColourOpFallback(String& params, MaterialScriptContext& context)
1130	{
1131	StringUtil::toLowerCase(params);
1132	StringVector vecparams = StringUtil::split(params, " \t");
1133	if (vecparams.size() != 2)
1134	{
1135	logParseError("Bad colour_op_multipass_fallback attribute, wrong number "
1136	"of parameters (expected 2)", context);
1137	return false;
1138	}
1139
1140	//src/dest
1141	SceneBlendFactor src, dest;
1142
1143	try {
1144	src = convertBlendFactor(vecparams[0]);
1145	dest = convertBlendFactor(vecparams[1]);
1146	context.textureUnit->setColourOpMultipassFallback(src,dest);
1147	}
1148	catch (Exception& e)
1149	{
1150	logParseError("Bad colour_op_multipass_fallback attribute, "
1151	+ e.getFullDescription(), context);
1152	}
1153	return false;
1154	}
1155	//-----------------------------------------------------------------------
1156	bool parseAlphaOpEx(String& params, MaterialScriptContext& context)
1157	{
1158	StringUtil::toLowerCase(params);
1159	StringVector vecparams = StringUtil::split(params, " \t");
1160	size_t numParams = vecparams.size();
1161	if (numParams < 3 \|\| numParams > 6)
1162	{
1163	logParseError("Bad alpha_op_ex attribute, wrong number of parameters "
1164	"(expected 3 to 6)", context);
1165	return false;
1166	}
1167	LayerBlendOperationEx op;
1168	LayerBlendSource src1, src2;
1169	Real manual = 0.0;
1170	Real arg1 = 1.0, arg2 = 1.0;
1171
1172	try {
1173	op = convertBlendOpEx(vecparams[0]);
1174	src1 = convertBlendSource(vecparams[1]);
1175	src2 = convertBlendSource(vecparams[2]);
1176	if (op == LBX_BLEND_MANUAL)
1177	{
1178	if (numParams != 4)
1179	{
1180	logParseError("Bad alpha_op_ex attribute, wrong number of parameters "
1181	"(expected 4 for manual blend)", context);
1182	return false;
1183	}
1184	manual = StringConverter::parseReal(vecparams[3]);
1185	}
1186	if (src1 == LBS_MANUAL)
1187	{
1188	unsigned int parIndex = 3;
1189	if (op == LBX_BLEND_MANUAL)
1190	parIndex++;
1191
1192	if (numParams < parIndex)
1193	{
1194	logParseError(
1195	"Bad alpha_op_ex attribute, wrong number of parameters (expected " +
1196	StringConverter::toString(parIndex - 1) + ")", context);
1197	return false;
1198	}
1199
1200	arg1 = StringConverter::parseReal(vecparams[parIndex]);
1201	}
1202
1203	if (src2 == LBS_MANUAL)
1204	{
1205	unsigned int parIndex = 3;
1206	if (op == LBX_BLEND_MANUAL)
1207	parIndex++;
1208	if (src1 == LBS_MANUAL)
1209	parIndex++;
1210
1211	if (numParams < parIndex)
1212	{
1213	logParseError(
1214	"Bad alpha_op_ex attribute, wrong number of parameters "
1215	"(expected " + StringConverter::toString(parIndex - 1) + ")", context);
1216	return false;
1217	}
1218
1219	arg2 = StringConverter::parseReal(vecparams[parIndex]);
1220	}
1221	}
1222	catch (Exception& e)
1223	{
1224	logParseError("Bad alpha_op_ex attribute, " + e.getFullDescription(), context);
1225	return false;
1226	}
1227
1228	context.textureUnit->setAlphaOperation(op, src1, src2, arg1, arg2, manual);
1229	return false;
1230	}
1231	//-----------------------------------------------------------------------
1232	bool parseEnvMap(String& params, MaterialScriptContext& context)
1233	{
1234	StringUtil::toLowerCase(params);
1235	if (params=="off")
1236	context.textureUnit->setEnvironmentMap(false);
1237	else if (params=="spherical")
1238	context.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_CURVED);
1239	else if (params=="planar")
1240	context.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_PLANAR);
1241	else if (params=="cubic_reflection")
1242	context.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_REFLECTION);
1243	else if (params=="cubic_normal")
1244	context.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_NORMAL);
1245	else
1246	logParseError("Bad env_map attribute, valid parameters are 'off', "
1247	"'spherical', 'planar', 'cubic_reflection' and 'cubic_normal'.", context);
1248
1249	return false;
1250	}
1251	//-----------------------------------------------------------------------
1252	bool parseScroll(String& params, MaterialScriptContext& context)
1253	{
1254	StringVector vecparams = StringUtil::split(params, " \t");
1255	if (vecparams.size() != 2)
1256	{
1257	logParseError("Bad scroll attribute, wrong number of parameters (expected 2)", context);
1258	return false;
1259	}
1260	context.textureUnit->setTextureScroll(
1261	StringConverter::parseReal(vecparams[0]),
1262	StringConverter::parseReal(vecparams[1]));
1263
1264
1265	return false;
1266	}
1267	//-----------------------------------------------------------------------
1268	bool parseScrollAnim(String& params, MaterialScriptContext& context)
1269	{
1270	StringVector vecparams = StringUtil::split(params, " \t");
1271	if (vecparams.size() != 2)
1272	{
1273	logParseError("Bad scroll_anim attribute, wrong number of "
1274	"parameters (expected 2)", context);
1275	return false;
1276	}
1277	context.textureUnit->setScrollAnimation(
1278	StringConverter::parseReal(vecparams[0]),
1279	StringConverter::parseReal(vecparams[1]));
1280
1281	return false;
1282	}
1283	//-----------------------------------------------------------------------
1284	bool parseRotate(String& params, MaterialScriptContext& context)
1285	{
1286	context.textureUnit->setTextureRotate(
1287	StringConverter::parseAngle(params));
1288
1289	return false;
1290	}
1291	//-----------------------------------------------------------------------
1292	bool parseRotateAnim(String& params, MaterialScriptContext& context)
1293	{
1294	context.textureUnit->setRotateAnimation(
1295	StringConverter::parseReal(params));
1296
1297	return false;
1298	}
1299	//-----------------------------------------------------------------------
1300	bool parseScale(String& params, MaterialScriptContext& context)
1301	{
1302	StringVector vecparams = StringUtil::split(params, " \t");
1303	if (vecparams.size() != 2)
1304	{
1305	logParseError("Bad scale attribute, wrong number of parameters (expected 2)", context);
1306	return false;
1307	}
1308	context.textureUnit->setTextureScale(
1309	StringConverter::parseReal(vecparams[0]),
1310	StringConverter::parseReal(vecparams[1]));
1311
1312	return false;
1313	}
1314	//-----------------------------------------------------------------------
1315	bool parseWaveXform(String& params, MaterialScriptContext& context)
1316	{
1317	StringUtil::toLowerCase(params);
1318	StringVector vecparams = StringUtil::split(params, " \t");
1319
1320	if (vecparams.size() != 6)
1321	{
1322	logParseError("Bad wave_xform attribute, wrong number of parameters "
1323	"(expected 6)", context);
1324	return false;
1325	}
1326	TextureUnitState::TextureTransformType ttype;
1327	WaveformType waveType;
1328	// Check transform type
1329	if (vecparams[0]=="scroll_x")
1330	ttype = TextureUnitState::TT_TRANSLATE_U;
1331	else if (vecparams[0]=="scroll_y")
1332	ttype = TextureUnitState::TT_TRANSLATE_V;
1333	else if (vecparams[0]=="rotate")
1334	ttype = TextureUnitState::TT_ROTATE;
1335	else if (vecparams[0]=="scale_x")
1336	ttype = TextureUnitState::TT_SCALE_U;
1337	else if (vecparams[0]=="scale_y")
1338	ttype = TextureUnitState::TT_SCALE_V;
1339	else
1340	{
1341	logParseError("Bad wave_xform attribute, parameter 1 must be 'scroll_x', "
1342	"'scroll_y', 'rotate', 'scale_x' or 'scale_y'", context);
1343	return false;
1344	}
1345	// Check wave type
1346	if (vecparams[1]=="sine")
1347	waveType = WFT_SINE;
1348	else if (vecparams[1]=="triangle")
1349	waveType = WFT_TRIANGLE;
1350	else if (vecparams[1]=="square")
1351	waveType = WFT_SQUARE;
1352	else if (vecparams[1]=="sawtooth")
1353	waveType = WFT_SAWTOOTH;
1354	else if (vecparams[1]=="inverse_sawtooth")
1355	waveType = WFT_INVERSE_SAWTOOTH;
1356	else
1357	{
1358	logParseError("Bad wave_xform attribute, parameter 2 must be 'sine', "
1359	"'triangle', 'square', 'sawtooth' or 'inverse_sawtooth'", context);
1360	return false;
1361	}
1362
1363	context.textureUnit->setTransformAnimation(
1364	ttype,
1365	waveType,
1366	StringConverter::parseReal(vecparams[2]),
1367	StringConverter::parseReal(vecparams[3]),
1368	StringConverter::parseReal(vecparams[4]),
1369	StringConverter::parseReal(vecparams[5]) );
1370
1371	return false;
1372	}
1373	//-----------------------------------------------------------------------
1374	bool parseTransform(String& params, MaterialScriptContext& context)
1375	{
1376	StringVector vecparams = StringUtil::split(params, " \t");
1377	if (vecparams.size() != 16)
1378	{
1379	logParseError("Bad transform attribute, wrong number of parameters (expected 16)", context);
1380	return false;
1381	}
1382	Matrix4 xform(
1383	StringConverter::parseReal(vecparams[0]),
1384	StringConverter::parseReal(vecparams[1]),
1385	StringConverter::parseReal(vecparams[2]),
1386	StringConverter::parseReal(vecparams[3]),
1387	StringConverter::parseReal(vecparams[4]),
1388	StringConverter::parseReal(vecparams[5]),
1389	StringConverter::parseReal(vecparams[6]),
1390	StringConverter::parseReal(vecparams[7]),
1391	StringConverter::parseReal(vecparams[8]),
1392	StringConverter::parseReal(vecparams[9]),
1393	StringConverter::parseReal(vecparams[10]),
1394	StringConverter::parseReal(vecparams[11]),
1395	StringConverter::parseReal(vecparams[12]),
1396	StringConverter::parseReal(vecparams[13]),
1397	StringConverter::parseReal(vecparams[14]),
1398	StringConverter::parseReal(vecparams[15]) );
1399	context.textureUnit->setTextureTransform(xform);
1400
1401
1402	return false;
1403	}
1404	//-----------------------------------------------------------------------
1405	bool parseDepthBias(String& params, MaterialScriptContext& context)
1406	{
1407	context.pass->setDepthBias(
1408	StringConverter::parseReal(params));
1409
1410	return false;
1411	}
1412	//-----------------------------------------------------------------------
1413	bool parseAnisotropy(String& params, MaterialScriptContext& context)
1414	{
1415	context.textureUnit->setTextureAnisotropy(
1416	StringConverter::parseInt(params));
1417
1418	return false;
1419	}
1420	//-----------------------------------------------------------------------
1421	bool parseTextureAlias(String& params, MaterialScriptContext& context)
1422	{
1423	context.textureUnit->setTextureNameAlias(params);
1424
1425	return false;
1426	}
1427	//-----------------------------------------------------------------------
1428	bool parseLodDistances(String& params, MaterialScriptContext& context)
1429	{
1430	StringVector vecparams = StringUtil::split(params, " \t");
1431
1432	// iterate over the parameters and parse distances out of them
1433	Material::LodDistanceList lodList;
1434	StringVector::iterator i, iend;
1435	iend = vecparams.end();
1436	for (i = vecparams.begin(); i != iend; ++i)
1437	{
1438	lodList.push_back(StringConverter::parseReal(*i));
1439	}
1440
1441	context.material->setLodLevels(lodList);
1442
1443	return false;
1444	}
1445	//-----------------------------------------------------------------------
1446	bool parseLodIndex(String& params, MaterialScriptContext& context)
1447	{
1448	context.technique->setLodIndex(StringConverter::parseInt(params));
1449	return false;
1450	}
1451	//-----------------------------------------------------------------------
1452	bool parseScheme(String& params, MaterialScriptContext& context)
1453	{
1454	context.technique->setSchemeName(params);
1455	return false;
1456	}
1457	//-----------------------------------------------------------------------
1458	bool parseSetTextureAlias(String& params, MaterialScriptContext& context)
1459	{
1460	StringVector vecparams = StringUtil::split(params, " \t");
1461	if (vecparams.size() != 2)
1462	{
1463	logParseError("Wrong number of parameters for texture_alias, expected 2", context);
1464	return false;
1465	}
1466	// first parameter is alias name and second paramater is texture name
1467	context.textureAliases[vecparams[0]] = vecparams[1];
1468
1469	return false;
1470	}
1471
1472	//-----------------------------------------------------------------------
1473	void processManualProgramParam(size_t index, const String& commandname,
1474	StringVector& vecparams, MaterialScriptContext& context)
1475	{
1476	// NB we assume that the first element of vecparams is taken up with either
1477	// the index or the parameter name, which we ignore
1478
1479	// Determine type
1480	size_t start, dims, roundedDims, i;
1481	bool isReal;
1482	bool isMatrix4x4 = false;
1483
1484	StringUtil::toLowerCase(vecparams[1]);
1485
1486	if (vecparams[1] == "matrix4x4")
1487	{
1488	dims = 16;
1489	isReal = true;
1490	isMatrix4x4 = true;
1491	}
1492	else if ((start = vecparams[1].find("float")) != String::npos)
1493	{
1494	// find the dimensionality
1495	start = vecparams[1].find_first_not_of("float");
1496	// Assume 1 if not specified
1497	if (start == String::npos)
1498	{
1499	dims = 1;
1500	}
1501	else
1502	{
1503	dims = StringConverter::parseInt(vecparams[1].substr(start));
1504	}
1505	isReal = true;
1506	}
1507	else if ((start = vecparams[1].find("int")) != String::npos)
1508	{
1509	// find the dimensionality
1510	start = vecparams[1].find_first_not_of("int");
1511	// Assume 1 if not specified
1512	if (start == String::npos)
1513	{
1514	dims = 1;
1515	}
1516	else
1517	{
1518	dims = StringConverter::parseInt(vecparams[1].substr(start));
1519	}
1520	isReal = false;
1521	}
1522	else
1523	{
1524	logParseError("Invalid " + commandname + " attribute - unrecognised "
1525	"parameter type " + vecparams[1], context);
1526	return;
1527	}
1528
1529	if (vecparams.size() != 2 + dims)
1530	{
1531	logParseError("Invalid " + commandname + " attribute - you need " +
1532	StringConverter::toString(2 + dims) + " parameters for a parameter of "
1533	"type " + vecparams[1], context);
1534	}
1535
1536	// Round dims to multiple of 4
1537	if (dims %4 != 0)
1538	{
1539	roundedDims = dims + 4 - (dims % 4);
1540	}
1541	else
1542	{
1543	roundedDims = dims;
1544	}
1545
1546	// set the name of the parameter if it exists
1547	String paramName = (commandname == "param_named") ? vecparams[0] : "";
1548
1549	// Now parse all the values
1550	if (isReal)
1551	{
1552	Real* realBuffer = new Real[roundedDims];
1553	// Do specified values
1554	for (i = 0; i < dims; ++i)
1555	{
1556	realBuffer[i] = StringConverter::parseReal(vecparams[i+2]);
1557	}
1558	// Fill up to multiple of 4 with zero
1559	for (; i < roundedDims; ++i)
1560	{
1561	realBuffer[i] = 0.0f;
1562
1563	}
1564
1565	if (isMatrix4x4)
1566	{
1567	// its a Matrix4x4 so pass as a Matrix4
1568	// use specialized setConstant that takes a matrix so matrix is transposed if required
1569	Matrix4 m4x4(
1570	realBuffer[0], realBuffer[1], realBuffer[2], realBuffer[3],
1571	realBuffer[4], realBuffer[5], realBuffer[6], realBuffer[7],
1572	realBuffer[8], realBuffer[9], realBuffer[10], realBuffer[11],
1573	realBuffer[12], realBuffer[13], realBuffer[14], realBuffer[15]
1574	);
1575	context.programParams->setConstant(index, m4x4);
1576	}
1577	else
1578	{
1579	// Set
1580	context.programParams->setConstant(index, realBuffer, roundedDims * 0.25);
1581
1582	}
1583
1584
1585	delete [] realBuffer;
1586	// log the parameter
1587	context.programParams->addConstantDefinition(paramName, index, dims, GpuProgramParameters::ET_REAL);
1588	}
1589	else
1590	{
1591	int* intBuffer = new int[roundedDims];
1592	// Do specified values
1593	for (i = 0; i < dims; ++i)
1594	{
1595	intBuffer[i] = StringConverter::parseInt(vecparams[i+2]);
1596	}
1597	// Fill to multiple of 4 with 0
1598	for (; i < roundedDims; ++i)
1599	{
1600	intBuffer[i] = 0;
1601	}
1602	// Set
1603	context.programParams->setConstant(index, intBuffer, roundedDims * 0.25);
1604	delete [] intBuffer;
1605	// log the parameter
1606	context.programParams->addConstantDefinition(paramName, index, dims, GpuProgramParameters::ET_INT);
1607	}
1608	}
1609	//-----------------------------------------------------------------------
1610	void processAutoProgramParam(size_t index, const String& commandname,
1611	StringVector& vecparams, MaterialScriptContext& context)
1612	{
1613	// NB we assume that the first element of vecparams is taken up with either
1614	// the index or the parameter name, which we ignore
1615
1616	// make sure param is in lower case
1617	StringUtil::toLowerCase(vecparams[1]);
1618
1619	// lookup the param to see if its a valid auto constant
1620	const GpuProgramParameters::AutoConstantDefinition* autoConstantDef =
1621	context.programParams->getAutoConstantDefinition(vecparams[1]);
1622
1623	// exit with error msg if the auto constant definition wasn't found
1624	if (!autoConstantDef)
1625	{
1626	logParseError("Invalid " + commandname + " attribute - "
1627	+ vecparams[1], context);
1628	return;
1629	}
1630
1631	// add AutoConstant based on the type of data it uses
1632	switch (autoConstantDef->dataType)
1633	{
1634	case GpuProgramParameters::ACDT_NONE:
1635	context.programParams->setAutoConstant(index, autoConstantDef->acType, 0);
1636	break;
1637
1638	case GpuProgramParameters::ACDT_INT:
1639	{
1640	// Special case animation_parametric, we need to keep track of number of times used
1641	if (autoConstantDef->acType == GpuProgramParameters::ACT_ANIMATION_PARAMETRIC)
1642	{
1643	context.programParams->setAutoConstant(
1644	index, autoConstantDef->acType, context.numAnimationParametrics++);
1645	}
1646	else
1647	{
1648
1649	if (vecparams.size() != 3)
1650	{
1651	logParseError("Invalid " + commandname + " attribute - "
1652	"expected 3 parameters.", context);
1653	return;
1654	}
1655
1656	size_t extraParam = StringConverter::parseInt(vecparams[2]);
1657	context.programParams->setAutoConstant(
1658	index, autoConstantDef->acType, extraParam);
1659	}
1660	}
1661	break;
1662
1663	case GpuProgramParameters::ACDT_REAL:
1664	{
1665	// special handling for time
1666	if (autoConstantDef->acType == GpuProgramParameters::ACT_TIME \|\|
1667	autoConstantDef->acType == GpuProgramParameters::ACT_FRAME_TIME)
1668	{
1669	Real factor = 1.0f;
1670	if (vecparams.size() == 3)
1671	{
1672	factor = StringConverter::parseReal(vecparams[2]);
1673	}
1674
1675	context.programParams->setAutoConstantReal(index, autoConstantDef->acType, factor);
1676	}
1677	else // normal processing for auto constants that take an extra real value
1678	{
1679	if (vecparams.size() != 3)
1680	{
1681	logParseError("Invalid " + commandname + " attribute - "
1682	"expected 3 parameters.", context);
1683	return;
1684	}
1685
1686	Real rData = StringConverter::parseReal(vecparams[2]);
1687	context.programParams->setAutoConstantReal(index, autoConstantDef->acType, rData);
1688	}
1689	}
1690	break;
1691
1692	} // end switch
1693
1694	String paramName = (commandname == "param_named_auto") ? vecparams[0] : "";
1695	// add constant definition based on AutoConstant
1696	// make element count 0 so that proper allocation occurs when AutoState is set up
1697	size_t constantIndex = context.programParams->addConstantDefinition(
1698	paramName, index, 0, autoConstantDef->elementType);
1699	// update constant definition auto settings
1700	// since an autoconstant was just added, its the last one in the container
1701	size_t autoIndex = context.programParams->getAutoConstantCount() - 1;
1702	// setup autoState which will allocate the proper amount of storage required by constant entries
1703	context.programParams->setConstantDefinitionAutoState(constantIndex, true, autoIndex);
1704
1705	}
1706
1707	//-----------------------------------------------------------------------
1708	bool parseParamIndexed(String& params, MaterialScriptContext& context)
1709	{
1710	// NB skip this if the program is not supported or could not be found
1711	if (context.program.isNull() \|\| !context.program->isSupported())
1712	{
1713	return false;
1714	}
1715
1716	StringUtil::toLowerCase(params);
1717	StringVector vecparams = StringUtil::split(params, " \t");
1718	if (vecparams.size() < 3)
1719	{
1720	logParseError("Invalid param_indexed attribute - expected at least 3 parameters.",
1721	context);
1722	return false;
1723	}
1724
1725	// Get start index
1726	size_t index = StringConverter::parseInt(vecparams[0]);
1727
1728	processManualProgramParam(index, "param_indexed", vecparams, context);
1729
1730	return false;
1731	}
1732	//-----------------------------------------------------------------------
1733	bool parseParamIndexedAuto(String& params, MaterialScriptContext& context)
1734	{
1735	// NB skip this if the program is not supported or could not be found
1736	if (context.program.isNull() \|\| !context.program->isSupported())
1737	{
1738	return false;
1739	}
1740
1741	StringUtil::toLowerCase(params);
1742	StringVector vecparams = StringUtil::split(params, " \t");
1743	if (vecparams.size() != 2 && vecparams.size() != 3)
1744	{
1745	logParseError("Invalid param_indexed_auto attribute - expected 2 or 3 parameters.",
1746	context);
1747	return false;
1748	}
1749
1750	// Get start index
1751	size_t index = StringConverter::parseInt(vecparams[0]);
1752
1753	processAutoProgramParam(index, "param_indexed_auto", vecparams, context);
1754
1755	return false;
1756	}
1757	//-----------------------------------------------------------------------
1758	bool parseParamNamed(String& params, MaterialScriptContext& context)
1759	{
1760	// NB skip this if the program is not supported or could not be found
1761	if (context.program.isNull() \|\| !context.program->isSupported())
1762	{
1763	return false;
1764	}
1765
1766	StringVector vecparams = StringUtil::split(params, " \t");
1767	if (vecparams.size() < 3)
1768	{
1769	logParseError("Invalid param_named attribute - expected at least 3 parameters.",
1770	context);
1771	return false;
1772	}
1773
1774	// Get start index from name
1775	size_t index;
1776	try {
1777	index = context.programParams->getParamIndex(vecparams[0]);
1778	}
1779	catch (Exception& e)
1780	{
1781	logParseError("Invalid param_named attribute - " + e.getFullDescription(), context);
1782	return false;
1783	}
1784
1785	// TEST
1786	/*
1787	LogManager::getSingleton().logMessage("SETTING PARAMETER " + vecparams[0] + " as index " +
1788	StringConverter::toString(index));
1789	*/
1790	processManualProgramParam(index, "param_named", vecparams, context);
1791
1792	return false;
1793	}
1794	//-----------------------------------------------------------------------
1795	bool parseParamNamedAuto(String& params, MaterialScriptContext& context)
1796	{
1797	// NB skip this if the program is not supported or could not be found
1798	if (context.program.isNull() \|\| !context.program->isSupported())
1799	{
1800	return false;
1801	}
1802
1803	StringVector vecparams = StringUtil::split(params, " \t");
1804	if (vecparams.size() != 2 && vecparams.size() != 3)
1805	{
1806	logParseError("Invalid param_indexed_auto attribute - expected 2 or 3 parameters.",
1807	context);
1808	return false;
1809	}
1810
1811	// Get start index from name
1812	size_t index;
1813	try {
1814	index = context.programParams->getParamIndex(vecparams[0]);
1815	}
1816	catch (Exception& e)
1817	{
1818	logParseError("Invalid param_named_auto attribute - " + e.getFullDescription(), context);
1819	return false;
1820	}
1821
1822	processAutoProgramParam(index, "param_named_auto", vecparams, context);
1823
1824	return false;
1825	}
1826	//-----------------------------------------------------------------------
1827	bool parseMaterial(String& params, MaterialScriptContext& context)
1828	{
1829	// nfz:
1830	// check params for reference to parent material to copy from
1831	// syntax: material name : parentMaterialName
1832	// check params for a colon after the first name and extract the parent name
1833	StringVector vecparams = StringUtil::split(params, ":", 1);
1834	MaterialPtr basematerial;
1835
1836	// Create a brand new material
1837	if (vecparams.size() >= 2)
1838	{
1839	// if a second parameter exists then assume its the name of the base material
1840	// that this new material should clone from
1841	StringUtil::trim(vecparams[1]);
1842	// make sure base material exists
1843	basematerial = MaterialManager::getSingleton().getByName(vecparams[1]);
1844	// if it doesn't exist then report error in log and just create a new material
1845	if (basematerial.isNull())
1846	{
1847	logParseError("parent material: " + vecparams[1] + " not found for new material:"
1848	+ vecparams[0], context);
1849	}
1850	}
1851
1852	// get rid of leading and trailing white space from material name
1853	StringUtil::trim(vecparams[0]);
1854
1855	context.material =
1856	MaterialManager::getSingleton().create(vecparams[0], context.groupName);
1857
1858	if (!basematerial.isNull())
1859	{
1860	// copy parent material details to new material
1861	basematerial->copyDetailsTo(context.material);
1862	}
1863	else
1864	{
1865	// Remove pre-created technique from defaults
1866	context.material->removeAllTechniques();
1867	}
1868
1869	context.material->_notifyOrigin(context.filename);
1870
1871	// update section
1872	context.section = MSS_MATERIAL;
1873
1874	// Return TRUE because this must be followed by a {
1875	return true;
1876	}
1877	//-----------------------------------------------------------------------
1878	bool parseTechnique(String& params, MaterialScriptContext& context)
1879	{
1880
1881	// if params is not empty then see if the technique name already exists
1882	if (!params.empty() && (context.material->getNumTechniques() > 0))
1883	{
1884	// find the technique with name = params
1885	Technique * foundTechnique = context.material->getTechnique(params);
1886	if (foundTechnique)
1887	{
1888	// figure out technique index by iterating through technique container
1889	// would be nice if each technique remembered its index
1890	int count = 0;
1891	Material::TechniqueIterator i = context.material->getTechniqueIterator();
1892	while(i.hasMoreElements())
1893	{
1894	if (foundTechnique == i.peekNext())
1895	break;
1896	i.moveNext();
1897	++count;
1898	}
1899
1900	context.techLev = count;
1901	}
1902	else
1903	{
1904	// name was not found so a new technique is needed
1905	// position technique level to the end index
1906	// a new technique will be created later on
1907	context.techLev = context.material->getNumTechniques();
1908	}
1909
1910	}
1911	else
1912	{
1913	// no name was given in the script so a new technique will be created
1914	// Increase technique level depth
1915	++context.techLev;
1916	}
1917
1918	// Create a new technique if it doesn't already exist
1919	if (context.material->getNumTechniques() > context.techLev)
1920	{
1921	context.technique = context.material->getTechnique(context.techLev);
1922	}
1923	else
1924	{
1925	context.technique = context.material->createTechnique();
1926	if (!params.empty())
1927	context.technique->setName(params);
1928	}
1929
1930	// update section
1931	context.section = MSS_TECHNIQUE;
1932
1933	// Return TRUE because this must be followed by a {
1934	return true;
1935	}
1936	//-----------------------------------------------------------------------
1937	bool parsePass(String& params, MaterialScriptContext& context)
1938	{
1939	// if params is not empty then see if the pass name already exists
1940	if (!params.empty() && (context.technique->getNumPasses() > 0))
1941	{
1942	// find the pass with name = params
1943	Pass * foundPass = context.technique->getPass(params);
1944	if (foundPass)
1945	{
1946	context.passLev = foundPass->getIndex();
1947	}
1948	else
1949	{
1950	// name was not found so a new pass is needed
1951	// position pass level to the end index
1952	// a new pass will be created later on
1953	context.passLev = context.technique->getNumPasses();
1954	}
1955
1956	}
1957	else
1958	{
1959	//Increase pass level depth
1960	++context.passLev;
1961	}
1962
1963	if (context.technique->getNumPasses() > context.passLev)
1964	{
1965	context.pass = context.technique->getPass(context.passLev);
1966	}
1967	else
1968	{
1969	// Create a new pass
1970	context.pass = context.technique->createPass();
1971	if (!params.empty())
1972	context.pass->setName(params);
1973	}
1974
1975	// update section
1976	context.section = MSS_PASS;
1977
1978	// Return TRUE because this must be followed by a {
1979	return true;
1980	}
1981	//-----------------------------------------------------------------------
1982	bool parseTextureUnit(String& params, MaterialScriptContext& context)
1983	{
1984	// if params is a name then see if that texture unit exists
1985	// if not then log the warning and just move on to the next TU from current
1986	if (!params.empty() && (context.pass->getNumTextureUnitStates() > 0))
1987	{
1988	// specifying a TUS name in the script for a TU means that a specific TU is being requested
1989	// try to get the specific TU
1990	// if the index requested is not valid, just creat a new TU
1991	// find the TUS with name = params
1992	TextureUnitState * foundTUS = context.pass->getTextureUnitState(params);
1993	if (foundTUS)
1994	{
1995	context.stateLev = context.pass->getTextureUnitStateIndex(foundTUS);
1996	}
1997	else
1998	{
1999	// name was not found so a new TUS is needed
2000	// position TUS level to the end index
2001	// a new TUS will be created later on
2002	context.stateLev = context.pass->getNumTextureUnitStates();
2003	}
2004	}
2005	else
2006	{
2007	//Increase Texture Unit State level depth
2008	++context.stateLev;
2009	}
2010
2011	if (context.pass->getNumTextureUnitStates() > static_cast<size_t>(context.stateLev))
2012	{
2013	context.textureUnit = context.pass->getTextureUnitState(context.stateLev);
2014	}
2015	else
2016	{
2017	// Create a new texture unit
2018	context.textureUnit = context.pass->createTextureUnitState();
2019	if (!params.empty())
2020	context.textureUnit->setName(params);
2021	}
2022	// update section
2023	context.section = MSS_TEXTUREUNIT;
2024
2025	// Return TRUE because this must be followed by a {
2026	return true;
2027	}
2028
2029	//-----------------------------------------------------------------------
2030	bool parseVertexProgramRef(String& params, MaterialScriptContext& context)
2031	{
2032	// update section
2033	context.section = MSS_PROGRAM_REF;
2034
2035	// check if pass has a vertex program already
2036	if (context.pass->hasVertexProgram())
2037	{
2038	// if existing pass vertex program has same name as params
2039	// or params is empty then use current vertex program
2040	if (params.empty() \|\| (context.pass->getVertexProgramName() == params))
2041	{
2042	context.program = context.pass->getVertexProgram();
2043	}
2044	}
2045
2046	// if context.program was not set then try to get the vertex program using the name
2047	// passed in params
2048	if (context.program.isNull())
2049	{
2050	context.program = GpuProgramManager::getSingleton().getByName(params);
2051	if (context.program.isNull())
2052	{
2053	// Unknown program
2054	logParseError("Invalid vertex_program_ref entry - vertex program "
2055	+ params + " has not been defined.", context);
2056	return true;
2057	}
2058
2059	context.isProgramShadowCaster = false;
2060	context.isVertexProgramShadowReceiver = false;
2061	context.isFragmentProgramShadowReceiver = false;
2062
2063	// Set the vertex program for this pass
2064	context.pass->setVertexProgram(params);
2065	}
2066
2067	// Create params? Skip this if program is not supported
2068	if (context.program->isSupported())
2069	{
2070	context.programParams = context.pass->getVertexProgramParameters();
2071	context.numAnimationParametrics = 0;
2072	}
2073
2074	// Return TRUE because this must be followed by a {
2075	return true;
2076	}
2077	//-----------------------------------------------------------------------
2078	bool parseShadowCasterVertexProgramRef(String& params, MaterialScriptContext& context)
2079	{
2080	// update section
2081	context.section = MSS_PROGRAM_REF;
2082
2083	context.program = GpuProgramManager::getSingleton().getByName(params);
2084	if (context.program.isNull())
2085	{
2086	// Unknown program
2087	logParseError("Invalid shadow_caster_vertex_program_ref entry - vertex program "
2088	+ params + " has not been defined.", context);
2089	return true;
2090	}
2091
2092	context.isProgramShadowCaster = true;
2093	context.isVertexProgramShadowReceiver = false;
2094	context.isFragmentProgramShadowReceiver = false;
2095
2096	// Set the vertex program for this pass
2097	context.pass->setShadowCasterVertexProgram(params);
2098
2099	// Create params? Skip this if program is not supported
2100	if (context.program->isSupported())
2101	{
2102	context.programParams = context.pass->getShadowCasterVertexProgramParameters();
2103	context.numAnimationParametrics = 0;
2104	}
2105
2106	// Return TRUE because this must be followed by a {
2107	return true;
2108	}
2109	//-----------------------------------------------------------------------
2110	bool parseShadowReceiverVertexProgramRef(String& params, MaterialScriptContext& context)
2111	{
2112	// update section
2113	context.section = MSS_PROGRAM_REF;
2114
2115	context.program = GpuProgramManager::getSingleton().getByName(params);
2116	if (context.program.isNull())
2117	{
2118	// Unknown program
2119	logParseError("Invalid shadow_receiver_vertex_program_ref entry - vertex program "
2120	+ params + " has not been defined.", context);
2121	return true;
2122	}
2123
2124
2125	context.isProgramShadowCaster = false;
2126	context.isVertexProgramShadowReceiver = true;
2127	context.isFragmentProgramShadowReceiver = false;
2128
2129	// Set the vertex program for this pass
2130	context.pass->setShadowReceiverVertexProgram(params);
2131
2132	// Create params? Skip this if program is not supported
2133	if (context.program->isSupported())
2134	{
2135	context.programParams = context.pass->getShadowReceiverVertexProgramParameters();
2136	context.numAnimationParametrics = 0;
2137	}
2138
2139	// Return TRUE because this must be followed by a {
2140	return true;
2141	}
2142	//-----------------------------------------------------------------------
2143	bool parseShadowReceiverFragmentProgramRef(String& params, MaterialScriptContext& context)
2144	{
2145	// update section
2146	context.section = MSS_PROGRAM_REF;
2147
2148	context.program = GpuProgramManager::getSingleton().getByName(params);
2149	if (context.program.isNull())
2150	{
2151	// Unknown program
2152	logParseError("Invalid shadow_receiver_fragment_program_ref entry - fragment program "
2153	+ params + " has not been defined.", context);
2154	return true;
2155	}
2156
2157
2158	context.isProgramShadowCaster = false;
2159	context.isVertexProgramShadowReceiver = false;
2160	context.isFragmentProgramShadowReceiver = true;
2161
2162	// Set the vertex program for this pass
2163	context.pass->setShadowReceiverFragmentProgram(params);
2164
2165	// Create params? Skip this if program is not supported
2166	if (context.program->isSupported())
2167	{
2168	context.programParams = context.pass->getShadowReceiverFragmentProgramParameters();
2169	context.numAnimationParametrics = 0;
2170	}
2171
2172	// Return TRUE because this must be followed by a {
2173	return true;
2174	}
2175	//-----------------------------------------------------------------------
2176	bool parseFragmentProgramRef(String& params, MaterialScriptContext& context)
2177	{
2178	// update section
2179	context.section = MSS_PROGRAM_REF;
2180
2181	// check if pass has a fragment program already
2182	if (context.pass->hasFragmentProgram())
2183	{
2184	// if existing pass fragment program has same name as params
2185	// or params is empty then use current fragment program
2186	if (params.empty() \|\| (context.pass->getFragmentProgramName() == params))
2187	{
2188	context.program = context.pass->getFragmentProgram();
2189	}
2190	}
2191
2192	// if context.program was not set then try to get the fragment program using the name
2193	// passed in params
2194	if (context.program.isNull())
2195	{
2196	context.program = GpuProgramManager::getSingleton().getByName(params);
2197	if (context.program.isNull())
2198	{
2199	// Unknown program
2200	logParseError("Invalid fragment_program_ref entry - fragment program "
2201	+ params + " has not been defined.", context);
2202	return true;
2203	}
2204
2205	// Set the vertex program for this pass
2206	context.pass->setFragmentProgram(params);
2207	}
2208
2209	// Create params? Skip this if program is not supported
2210	if (context.program->isSupported())
2211	{
2212	context.programParams = context.pass->getFragmentProgramParameters();
2213	context.numAnimationParametrics = 0;
2214	}
2215
2216	// Return TRUE because this must be followed by a {
2217	return true;
2218	}
2219	//-----------------------------------------------------------------------
2220	bool parseVertexProgram(String& params, MaterialScriptContext& context)
2221	{
2222	// update section
2223	context.section = MSS_PROGRAM;
2224
2225	// Create new program definition-in-progress
2226	context.programDef = new MaterialScriptProgramDefinition();
2227	context.programDef->progType = GPT_VERTEX_PROGRAM;
2228	context.programDef->supportsSkeletalAnimation = false;
2229	context.programDef->supportsMorphAnimation = false;
2230	context.programDef->supportsPoseAnimation = 0;
2231
2232	// Get name and language code
2233	StringVector vecparams = StringUtil::split(params, " \t");
2234	if (vecparams.size() != 2)
2235	{
2236	logParseError("Invalid vertex_program entry - expected "
2237	"2 parameters.", context);
2238	return true;
2239	}
2240	// Name, preserve case
2241	context.programDef->name = vecparams[0];
2242	// language code, make lower case
2243	context.programDef->language = vecparams[1];
2244	StringUtil::toLowerCase(context.programDef->language);
2245
2246	// Return TRUE because this must be followed by a {
2247	return true;
2248	}
2249	//-----------------------------------------------------------------------
2250	bool parseFragmentProgram(String& params, MaterialScriptContext& context)
2251	{
2252	// update section
2253	context.section = MSS_PROGRAM;
2254
2255	// Create new program definition-in-progress
2256	context.programDef = new MaterialScriptProgramDefinition();
2257	context.programDef->progType = GPT_FRAGMENT_PROGRAM;
2258	context.programDef->supportsSkeletalAnimation = false;
2259	context.programDef->supportsMorphAnimation = false;
2260	context.programDef->supportsPoseAnimation = 0;
2261
2262	// Get name and language code
2263	StringVector vecparams = StringUtil::split(params, " \t");
2264	if (vecparams.size() != 2)
2265	{
2266	logParseError("Invalid fragment_program entry - expected "
2267	"2 parameters.", context);
2268	return true;
2269	}
2270	// Name, preserve case
2271	context.programDef->name = vecparams[0];
2272	// language code, make lower case
2273	context.programDef->language = vecparams[1];
2274	StringUtil::toLowerCase(context.programDef->language);
2275
2276	// Return TRUE because this must be followed by a {
2277	return true;
2278
2279	}
2280	//-----------------------------------------------------------------------
2281	bool parseProgramSource(String& params, MaterialScriptContext& context)
2282	{
2283	// Source filename, preserve case
2284	context.programDef->source = params;
2285
2286	return false;
2287	}
2288	//-----------------------------------------------------------------------
2289	bool parseProgramSkeletalAnimation(String& params, MaterialScriptContext& context)
2290	{
2291	// Source filename, preserve case
2292	context.programDef->supportsSkeletalAnimation
2293	= StringConverter::parseBool(params);
2294
2295	return false;
2296	}
2297	//-----------------------------------------------------------------------
2298	bool parseProgramMorphAnimation(String& params, MaterialScriptContext& context)
2299	{
2300	// Source filename, preserve case
2301	context.programDef->supportsMorphAnimation
2302	= StringConverter::parseBool(params);
2303
2304	return false;
2305	}
2306	//-----------------------------------------------------------------------
2307	bool parseProgramPoseAnimation(String& params, MaterialScriptContext& context)
2308	{
2309	// Source filename, preserve case
2310	context.programDef->supportsPoseAnimation
2311	= StringConverter::parseInt(params);
2312
2313	return false;
2314	}
2315	//-----------------------------------------------------------------------
2316	bool parseProgramSyntax(String& params, MaterialScriptContext& context)
2317	{
2318	// Syntax code, make lower case
2319	StringUtil::toLowerCase(params);
2320	context.programDef->syntax = params;
2321
2322	return false;
2323	}
2324	//-----------------------------------------------------------------------
2325	bool parseProgramCustomParameter(String& params, MaterialScriptContext& context)
2326	{
2327	// This params object does not have the command stripped
2328	// Lower case the command, but not the value incase it's relevant
2329	// Split only up to first delimiter, program deals with the rest
2330	StringVector vecparams = StringUtil::split(params, " \t", 1);
2331	if (vecparams.size() != 2)
2332	{
2333	logParseError("Invalid custom program parameter entry; "
2334	"there must be a parameter name and at least one value.",
2335	context);
2336	return false;
2337	}
2338
2339	context.programDef->customParameters[vecparams[0]] = vecparams[1];
2340
2341	return false;
2342	}
2343
2344	//-----------------------------------------------------------------------
2345	bool parseTextureSource(String& params, MaterialScriptContext& context)
2346	{
2347	StringUtil::toLowerCase(params);
2348	StringVector vecparams = StringUtil::split(params, " \t");
2349	if (vecparams.size() != 1)
2350	logParseError("Invalid texture source attribute - expected 1 parameter.", context);
2351	//The only param should identify which ExternalTextureSource is needed
2352	ExternalTextureSourceManager::getSingleton().setCurrentPlugIn( vecparams[0] );
2353
2354	if( ExternalTextureSourceManager::getSingleton().getCurrentPlugIn() != 0 )
2355	{
2356	String tps;
2357	tps = StringConverter::toString( context.techLev ) + " "
2358	+ StringConverter::toString( context.passLev ) + " "
2359	+ StringConverter::toString( context.stateLev);
2360
2361	ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->setParameter( "set_T_P_S", tps );
2362	}
2363
2364	// update section
2365	context.section = MSS_TEXTURESOURCE;
2366	// Return TRUE because this must be followed by a {
2367	return true;
2368	}
2369
2370	//-----------------------------------------------------------------------
2371	bool parseTextureCustomParameter(String& params, MaterialScriptContext& context)
2372	{
2373	// This params object does not have the command stripped
2374	// Split only up to first delimiter, program deals with the rest
2375	StringVector vecparams = StringUtil::split(params, " \t", 1);
2376	if (vecparams.size() != 2)
2377	{
2378	logParseError("Invalid texture parameter entry; "
2379	"there must be a parameter name and at least one value.",
2380	context);
2381	return false;
2382	}
2383
2384	if( ExternalTextureSourceManager::getSingleton().getCurrentPlugIn() != 0 )
2385	////First is command, next could be a string with one or more values
2386	ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->setParameter( vecparams[0], vecparams[1] );
2387
2388	return false;
2389	}
2390	//-----------------------------------------------------------------------
2391	bool parseReceiveShadows(String& params, MaterialScriptContext& context)
2392	{
2393	StringUtil::toLowerCase(params);
2394	if (params == "on")
2395	context.material->setReceiveShadows(true);
2396	else if (params == "off")
2397	context.material->setReceiveShadows(false);
2398	else
2399	logParseError(
2400	"Bad receive_shadows attribute, valid parameters are 'on' or 'off'.",
2401	context);
2402
2403	return false;
2404
2405	}
2406	//-----------------------------------------------------------------------
2407	bool parseDefaultParams(String& params, MaterialScriptContext& context)
2408	{
2409	context.section = MSS_DEFAULT_PARAMETERS;
2410	// Should be a brace next
2411	return true;
2412	}
2413
2414	//-----------------------------------------------------------------------
2415	bool parseTransparencyCastsShadows(String& params, MaterialScriptContext& context)
2416	{
2417	StringUtil::toLowerCase(params);
2418	if (params == "on")
2419	context.material->setTransparencyCastsShadows(true);
2420	else if (params == "off")
2421	context.material->setTransparencyCastsShadows(false);
2422	else
2423	logParseError(
2424	"Bad transparency_casts_shadows attribute, valid parameters are 'on' or 'off'.",
2425	context);
2426
2427	return false;
2428
2429	}
2430	//-----------------------------------------------------------------------
2431	//-----------------------------------------------------------------------
2432	MaterialSerializer::MaterialSerializer()
2433	{
2434	// Set up root attribute parsers
2435	mRootAttribParsers.insert(AttribParserList::value_type("material", (ATTRIBUTE_PARSER)parseMaterial));
2436	mRootAttribParsers.insert(AttribParserList::value_type("vertex_program", (ATTRIBUTE_PARSER)parseVertexProgram));
2437	mRootAttribParsers.insert(AttribParserList::value_type("fragment_program", (ATTRIBUTE_PARSER)parseFragmentProgram));
2438
2439	// Set up material attribute parsers
2440	mMaterialAttribParsers.insert(AttribParserList::value_type("lod_distances", (ATTRIBUTE_PARSER)parseLodDistances));
2441	mMaterialAttribParsers.insert(AttribParserList::value_type("receive_shadows", (ATTRIBUTE_PARSER)parseReceiveShadows));
2442	mMaterialAttribParsers.insert(AttribParserList::value_type("transparency_casts_shadows", (ATTRIBUTE_PARSER)parseTransparencyCastsShadows));
2443	mMaterialAttribParsers.insert(AttribParserList::value_type("technique", (ATTRIBUTE_PARSER)parseTechnique));
2444	mMaterialAttribParsers.insert(AttribParserList::value_type("set_texture_alias", (ATTRIBUTE_PARSER)parseSetTextureAlias));
2445
2446	// Set up technique attribute parsers
2447	mTechniqueAttribParsers.insert(AttribParserList::value_type("lod_index", (ATTRIBUTE_PARSER)parseLodIndex));
2448	mTechniqueAttribParsers.insert(AttribParserList::value_type("scheme", (ATTRIBUTE_PARSER)parseScheme));
2449	mTechniqueAttribParsers.insert(AttribParserList::value_type("pass", (ATTRIBUTE_PARSER)parsePass));
2450
2451	// Set up pass attribute parsers
2452	mPassAttribParsers.insert(AttribParserList::value_type("ambient", (ATTRIBUTE_PARSER)parseAmbient));
2453	mPassAttribParsers.insert(AttribParserList::value_type("diffuse", (ATTRIBUTE_PARSER)parseDiffuse));
2454	mPassAttribParsers.insert(AttribParserList::value_type("specular", (ATTRIBUTE_PARSER)parseSpecular));
2455	mPassAttribParsers.insert(AttribParserList::value_type("emissive", (ATTRIBUTE_PARSER)parseEmissive));
2456	mPassAttribParsers.insert(AttribParserList::value_type("scene_blend", (ATTRIBUTE_PARSER)parseSceneBlend));
2457	mPassAttribParsers.insert(AttribParserList::value_type("depth_check", (ATTRIBUTE_PARSER)parseDepthCheck));
2458	mPassAttribParsers.insert(AttribParserList::value_type("depth_write", (ATTRIBUTE_PARSER)parseDepthWrite));
2459	mPassAttribParsers.insert(AttribParserList::value_type("depth_func", (ATTRIBUTE_PARSER)parseDepthFunc));
2460	mPassAttribParsers.insert(AttribParserList::value_type("alpha_rejection", (ATTRIBUTE_PARSER)parseAlphaRejection));
2461	mPassAttribParsers.insert(AttribParserList::value_type("colour_write", (ATTRIBUTE_PARSER)parseColourWrite));
2462	mPassAttribParsers.insert(AttribParserList::value_type("cull_hardware", (ATTRIBUTE_PARSER)parseCullHardware));
2463	mPassAttribParsers.insert(AttribParserList::value_type("cull_software", (ATTRIBUTE_PARSER)parseCullSoftware));
2464	mPassAttribParsers.insert(AttribParserList::value_type("lighting", (ATTRIBUTE_PARSER)parseLighting));
2465	mPassAttribParsers.insert(AttribParserList::value_type("fog_override", (ATTRIBUTE_PARSER)parseFogging));
2466	mPassAttribParsers.insert(AttribParserList::value_type("shading", (ATTRIBUTE_PARSER)parseShading));
2467	mPassAttribParsers.insert(AttribParserList::value_type("polygon_mode", (ATTRIBUTE_PARSER)parsePolygonMode));
2468	mPassAttribParsers.insert(AttribParserList::value_type("depth_bias", (ATTRIBUTE_PARSER)parseDepthBias));
2469	mPassAttribParsers.insert(AttribParserList::value_type("texture_unit", (ATTRIBUTE_PARSER)parseTextureUnit));
2470	mPassAttribParsers.insert(AttribParserList::value_type("vertex_program_ref", (ATTRIBUTE_PARSER)parseVertexProgramRef));
2471	mPassAttribParsers.insert(AttribParserList::value_type("shadow_caster_vertex_program_ref", (ATTRIBUTE_PARSER)parseShadowCasterVertexProgramRef));
2472	mPassAttribParsers.insert(AttribParserList::value_type("shadow_receiver_vertex_program_ref", (ATTRIBUTE_PARSER)parseShadowReceiverVertexProgramRef));
2473	mPassAttribParsers.insert(AttribParserList::value_type("shadow_receiver_fragment_program_ref", (ATTRIBUTE_PARSER)parseShadowReceiverFragmentProgramRef));
2474	mPassAttribParsers.insert(AttribParserList::value_type("fragment_program_ref", (ATTRIBUTE_PARSER)parseFragmentProgramRef));
2475	mPassAttribParsers.insert(AttribParserList::value_type("max_lights", (ATTRIBUTE_PARSER)parseMaxLights));
2476	mPassAttribParsers.insert(AttribParserList::value_type("iteration", (ATTRIBUTE_PARSER)parseIteration));
2477	mPassAttribParsers.insert(AttribParserList::value_type("point_size", (ATTRIBUTE_PARSER)parsePointSize));
2478	mPassAttribParsers.insert(AttribParserList::value_type("point_sprites", (ATTRIBUTE_PARSER)parsePointSprites));
2479	mPassAttribParsers.insert(AttribParserList::value_type("point_size_attenuation", (ATTRIBUTE_PARSER)parsePointAttenuation));
2480	mPassAttribParsers.insert(AttribParserList::value_type("point_size_min", (ATTRIBUTE_PARSER)parsePointSizeMin));
2481	mPassAttribParsers.insert(AttribParserList::value_type("point_size_max", (ATTRIBUTE_PARSER)parsePointSizeMax));
2482
2483	// Set up texture unit attribute parsers
2484	mTextureUnitAttribParsers.insert(AttribParserList::value_type("texture_source", (ATTRIBUTE_PARSER)parseTextureSource));
2485	mTextureUnitAttribParsers.insert(AttribParserList::value_type("texture", (ATTRIBUTE_PARSER)parseTexture));
2486	mTextureUnitAttribParsers.insert(AttribParserList::value_type("anim_texture", (ATTRIBUTE_PARSER)parseAnimTexture));
2487	mTextureUnitAttribParsers.insert(AttribParserList::value_type("cubic_texture", (ATTRIBUTE_PARSER)parseCubicTexture));
2488	mTextureUnitAttribParsers.insert(AttribParserList::value_type("tex_coord_set", (ATTRIBUTE_PARSER)parseTexCoord));
2489	mTextureUnitAttribParsers.insert(AttribParserList::value_type("tex_address_mode", (ATTRIBUTE_PARSER)parseTexAddressMode));
2490	mTextureUnitAttribParsers.insert(AttribParserList::value_type("tex_border_colour", (ATTRIBUTE_PARSER)parseTexBorderColour));
2491	mTextureUnitAttribParsers.insert(AttribParserList::value_type("colour_op", (ATTRIBUTE_PARSER)parseColourOp));
2492	mTextureUnitAttribParsers.insert(AttribParserList::value_type("colour_op_ex", (ATTRIBUTE_PARSER)parseColourOpEx));
2493	mTextureUnitAttribParsers.insert(AttribParserList::value_type("colour_op_multipass_fallback", (ATTRIBUTE_PARSER)parseColourOpFallback));
2494	mTextureUnitAttribParsers.insert(AttribParserList::value_type("alpha_op_ex", (ATTRIBUTE_PARSER)parseAlphaOpEx));
2495	mTextureUnitAttribParsers.insert(AttribParserList::value_type("env_map", (ATTRIBUTE_PARSER)parseEnvMap));
2496	mTextureUnitAttribParsers.insert(AttribParserList::value_type("scroll", (ATTRIBUTE_PARSER)parseScroll));
2497	mTextureUnitAttribParsers.insert(AttribParserList::value_type("scroll_anim", (ATTRIBUTE_PARSER)parseScrollAnim));
2498	mTextureUnitAttribParsers.insert(AttribParserList::value_type("rotate", (ATTRIBUTE_PARSER)parseRotate));
2499	mTextureUnitAttribParsers.insert(AttribParserList::value_type("rotate_anim", (ATTRIBUTE_PARSER)parseRotateAnim));
2500	mTextureUnitAttribParsers.insert(AttribParserList::value_type("scale", (ATTRIBUTE_PARSER)parseScale));
2501	mTextureUnitAttribParsers.insert(AttribParserList::value_type("wave_xform", (ATTRIBUTE_PARSER)parseWaveXform));
2502	mTextureUnitAttribParsers.insert(AttribParserList::value_type("transform", (ATTRIBUTE_PARSER)parseTransform));
2503	mTextureUnitAttribParsers.insert(AttribParserList::value_type("filtering", (ATTRIBUTE_PARSER)parseFiltering));
2504	mTextureUnitAttribParsers.insert(AttribParserList::value_type("max_anisotropy", (ATTRIBUTE_PARSER)parseAnisotropy));
2505	mTextureUnitAttribParsers.insert(AttribParserList::value_type("texture_alias", (ATTRIBUTE_PARSER)parseTextureAlias));
2506
2507	// Set up program reference attribute parsers
2508	mProgramRefAttribParsers.insert(AttribParserList::value_type("param_indexed", (ATTRIBUTE_PARSER)parseParamIndexed));
2509	mProgramRefAttribParsers.insert(AttribParserList::value_type("param_indexed_auto", (ATTRIBUTE_PARSER)parseParamIndexedAuto));
2510	mProgramRefAttribParsers.insert(AttribParserList::value_type("param_named", (ATTRIBUTE_PARSER)parseParamNamed));
2511	mProgramRefAttribParsers.insert(AttribParserList::value_type("param_named_auto", (ATTRIBUTE_PARSER)parseParamNamedAuto));
2512
2513	// Set up program definition attribute parsers
2514	mProgramAttribParsers.insert(AttribParserList::value_type("source", (ATTRIBUTE_PARSER)parseProgramSource));
2515	mProgramAttribParsers.insert(AttribParserList::value_type("syntax", (ATTRIBUTE_PARSER)parseProgramSyntax));
2516	mProgramAttribParsers.insert(AttribParserList::value_type("includes_skeletal_animation", (ATTRIBUTE_PARSER)parseProgramSkeletalAnimation));
2517	mProgramAttribParsers.insert(AttribParserList::value_type("includes_morph_animation", (ATTRIBUTE_PARSER)parseProgramMorphAnimation));
2518	mProgramAttribParsers.insert(AttribParserList::value_type("includes_pose_animation", (ATTRIBUTE_PARSER)parseProgramPoseAnimation));
2519	mProgramAttribParsers.insert(AttribParserList::value_type("default_params", (ATTRIBUTE_PARSER)parseDefaultParams));
2520
2521	// Set up program default param attribute parsers
2522	mProgramDefaultParamAttribParsers.insert(AttribParserList::value_type("param_indexed", (ATTRIBUTE_PARSER)parseParamIndexed));
2523	mProgramDefaultParamAttribParsers.insert(AttribParserList::value_type("param_indexed_auto", (ATTRIBUTE_PARSER)parseParamIndexedAuto));
2524	mProgramDefaultParamAttribParsers.insert(AttribParserList::value_type("param_named", (ATTRIBUTE_PARSER)parseParamNamed));
2525	mProgramDefaultParamAttribParsers.insert(AttribParserList::value_type("param_named_auto", (ATTRIBUTE_PARSER)parseParamNamedAuto));
2526
2527	mScriptContext.section = MSS_NONE;
2528	mScriptContext.material.setNull();
2529	mScriptContext.technique = 0;
2530	mScriptContext.pass = 0;
2531	mScriptContext.textureUnit = 0;
2532	mScriptContext.program.setNull();
2533	mScriptContext.lineNo = 0;
2534	mScriptContext.filename = "";
2535	mScriptContext.techLev = -1;
2536	mScriptContext.passLev = -1;
2537	mScriptContext.stateLev = -1;
2538
2539	mBuffer = "";
2540	}
2541
2542	//-----------------------------------------------------------------------
2543	void MaterialSerializer::parseScript(DataStreamPtr& stream, const String& groupName)
2544	{
2545	String line;
2546	bool nextIsOpenBrace = false;
2547
2548	mScriptContext.section = MSS_NONE;
2549	mScriptContext.material.setNull();
2550	mScriptContext.technique = 0;
2551	mScriptContext.pass = 0;
2552	mScriptContext.textureUnit = 0;
2553	mScriptContext.program.setNull();
2554	mScriptContext.lineNo = 0;
2555	mScriptContext.techLev = -1;
2556	mScriptContext.passLev = -1;
2557	mScriptContext.stateLev = -1;
2558	mScriptContext.filename = stream->getName();
2559	mScriptContext.groupName = groupName;
2560	while(!stream->eof())
2561	{
2562	line = stream->getLine();
2563	mScriptContext.lineNo++;
2564
2565	// DEBUG LINE
2566	// LogManager::getSingleton().logMessage("About to attempt line(#" +
2567	// StringConverter::toString(mScriptContext.lineNo) + "): " + line);
2568
2569	// Ignore comments & blanks
2570	if (!(line.length() == 0 \|\| line.substr(0,2) == "//"))
2571	{
2572	if (nextIsOpenBrace)
2573	{
2574	// NB, parser will have changed context already
2575	if (line != "{")
2576	{
2577	logParseError("Expecting '{' but got " +
2578	line + " instead.", mScriptContext);
2579	}
2580	nextIsOpenBrace = false;
2581	}
2582	else
2583	{
2584	nextIsOpenBrace = parseScriptLine(line);
2585	}
2586
2587	}
2588	}
2589
2590	// Check all braces were closed
2591	if (mScriptContext.section != MSS_NONE)
2592	{
2593	logParseError("Unexpected end of file.", mScriptContext);
2594	}
2595
2596	// Make sure we invalidate our context shared pointer (don't wanna hold on)
2597	mScriptContext.material.setNull();
2598
2599	}
2600	//-----------------------------------------------------------------------
2601	bool MaterialSerializer::parseScriptLine(String& line)
2602	{
2603	switch(mScriptContext.section)
2604	{
2605	case MSS_NONE:
2606	if (line == "}")
2607	{
2608	logParseError("Unexpected terminating brace.", mScriptContext);
2609	return false;
2610	}
2611	else
2612	{
2613	// find & invoke a parser
2614	return invokeParser(line, mRootAttribParsers);
2615	}
2616	break;
2617	case MSS_MATERIAL:
2618	if (line == "}")
2619	{
2620	// End of material
2621	// if texture aliases were found, pass them to the material
2622	// to update texture names used in Texture unit states
2623	if (!mScriptContext.textureAliases.empty())
2624	{
2625	// request material to update all texture names in TUS's
2626	// that use texture aliases in the list
2627	mScriptContext.material->applyTextureAliases(mScriptContext.textureAliases);
2628	}
2629
2630	mScriptContext.section = MSS_NONE;
2631	mScriptContext.material.setNull();
2632	//Reset all levels for next material
2633	mScriptContext.passLev = -1;
2634	mScriptContext.stateLev= -1;
2635	mScriptContext.techLev = -1;
2636	mScriptContext.textureAliases.clear();
2637	}
2638	else
2639	{
2640	// find & invoke a parser
2641	return invokeParser(line, mMaterialAttribParsers);
2642	}
2643	break;
2644	case MSS_TECHNIQUE:
2645	if (line == "}")
2646	{
2647	// End of technique
2648	mScriptContext.section = MSS_MATERIAL;
2649	mScriptContext.technique = NULL;
2650	mScriptContext.passLev = -1; //Reset pass level (yes, the pass level)
2651	}
2652	else
2653	{
2654	// find & invoke a parser
2655	return invokeParser(line, mTechniqueAttribParsers);
2656	}
2657	break;
2658	case MSS_PASS:
2659	if (line == "}")
2660	{
2661	// End of pass
2662	mScriptContext.section = MSS_TECHNIQUE;
2663	mScriptContext.pass = NULL;
2664	mScriptContext.stateLev = -1; //Reset state level (yes, the state level)
2665	}
2666	else
2667	{
2668	// find & invoke a parser
2669	return invokeParser(line, mPassAttribParsers);
2670	}
2671	break;
2672	case MSS_TEXTUREUNIT:
2673	if (line == "}")
2674	{
2675	// End of texture unit
2676	mScriptContext.section = MSS_PASS;
2677	mScriptContext.textureUnit = NULL;
2678	}
2679	else
2680	{
2681	// find & invoke a parser
2682	return invokeParser(line, mTextureUnitAttribParsers);
2683	}
2684	break;
2685	case MSS_TEXTURESOURCE:
2686	if( line == "}" )
2687	{
2688	//End texture source section
2689	//Finish creating texture here
2690	String sMaterialName = mScriptContext.material->getName();
2691	if( ExternalTextureSourceManager::getSingleton().getCurrentPlugIn() != 0)
2692	ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->
2693	createDefinedTexture( sMaterialName, mScriptContext.groupName );
2694	//Revert back to texture unit
2695	mScriptContext.section = MSS_TEXTUREUNIT;
2696	}
2697	else
2698	{
2699	// custom texture parameter, use original line
2700	parseTextureCustomParameter(line, mScriptContext);
2701	}
2702	break;
2703	case MSS_PROGRAM_REF:
2704	if (line == "}")
2705	{
2706	// End of program
2707	mScriptContext.section = MSS_PASS;
2708	mScriptContext.program.setNull();
2709	}
2710	else
2711	{
2712	// find & invoke a parser
2713	return invokeParser(line, mProgramRefAttribParsers);
2714	}
2715	break;
2716	case MSS_PROGRAM:
2717	// Program definitions are slightly different, they are deferred
2718	// until all the information required is known
2719	if (line == "}")
2720	{
2721	// End of program
2722	finishProgramDefinition();
2723	mScriptContext.section = MSS_NONE;
2724	delete mScriptContext.programDef;
2725	mScriptContext.defaultParamLines.clear();
2726	mScriptContext.programDef = NULL;
2727	}
2728	else
2729	{
2730	// find & invoke a parser
2731	// do this manually because we want to call a custom
2732	// routine when the parser is not found
2733	// First, split line on first divisor only
2734	StringVector splitCmd = StringUtil::split(line, " \t", 1);
2735	// Find attribute parser
2736	AttribParserList::iterator iparser = mProgramAttribParsers.find(splitCmd[0]);
2737	if (iparser == mProgramAttribParsers.end())
2738	{
2739	// custom parameter, use original line
2740	parseProgramCustomParameter(line, mScriptContext);
2741	}
2742	else
2743	{
2744	String cmd = splitCmd.size() >= 2? splitCmd[1]:StringUtil::BLANK;
2745	// Use parser with remainder
2746	return iparser->second(cmd, mScriptContext );
2747	}
2748
2749	}
2750	break;
2751	case MSS_DEFAULT_PARAMETERS:
2752	if (line == "}")
2753	{
2754	// End of default parameters
2755	mScriptContext.section = MSS_PROGRAM;
2756	}
2757	else
2758	{
2759	// Save default parameter lines up until we finalise the program
2760	mScriptContext.defaultParamLines.push_back(line);
2761	}
2762
2763
2764	break;
2765	};
2766
2767	return false;
2768	}
2769	//-----------------------------------------------------------------------
2770	void MaterialSerializer::finishProgramDefinition(void)
2771	{
2772	// Now it is time to create the program and propagate the parameters
2773	MaterialScriptProgramDefinition* def = mScriptContext.programDef;
2774	GpuProgramPtr gp;
2775	if (def->language == "asm")
2776	{
2777	// Native assembler
2778	// Validate
2779	if (def->source.empty())
2780	{
2781	logParseError("Invalid program definition for " + def->name +
2782	", you must specify a source file.", mScriptContext);
2783	}
2784	if (def->syntax.empty())
2785	{
2786	logParseError("Invalid program definition for " + def->name +
2787	", you must specify a syntax code.", mScriptContext);
2788	}
2789	// Create
2790	gp = GpuProgramManager::getSingleton().
2791	createProgram(def->name, mScriptContext.groupName, def->source,
2792	def->progType, def->syntax);
2793
2794	}
2795	else
2796	{
2797	// High-level program
2798	// Validate
2799	if (def->source.empty())
2800	{
2801	logParseError("Invalid program definition for " + def->name +
2802	", you must specify a source file.", mScriptContext);
2803	}
2804	// Create
2805	try
2806	{
2807	HighLevelGpuProgramPtr hgp = HighLevelGpuProgramManager::getSingleton().
2808	createProgram(def->name, mScriptContext.groupName,
2809	def->language, def->progType);
2810	// Assign to generalised version
2811	gp = hgp;
2812	// Set source file
2813	hgp->setSourceFile(def->source);
2814
2815	// Set custom parameters
2816	std::map<String, String>::const_iterator i, iend;
2817	iend = def->customParameters.end();
2818	for (i = def->customParameters.begin(); i != iend; ++i)
2819	{
2820	if (!hgp->setParameter(i->first, i->second))
2821	{
2822	logParseError("Error in program " + def->name +
2823	" parameter " + i->first + " is not valid.", mScriptContext);
2824	}
2825	}
2826	}
2827	catch (Exception& e)
2828	{
2829	logParseError("Could not create GPU program '"
2830	+ def->name + "', error reported was: " + e.getFullDescription(), mScriptContext);
2831	mScriptContext.program.setNull();
2832	mScriptContext.programParams.setNull();
2833	return;
2834	}
2835	}
2836	// Set skeletal animation option
2837	gp->setSkeletalAnimationIncluded(def->supportsSkeletalAnimation);
2838	// Set morph animation option
2839	gp->setMorphAnimationIncluded(def->supportsMorphAnimation);
2840	// Set pose animation option
2841	gp->setPoseAnimationIncluded(def->supportsPoseAnimation);
2842	// set origin
2843	gp->_notifyOrigin(mScriptContext.filename);
2844
2845	// Set up to receive default parameters
2846	if (gp->isSupported()
2847	&& !mScriptContext.defaultParamLines.empty())
2848	{
2849	mScriptContext.programParams = gp->getDefaultParameters();
2850	mScriptContext.numAnimationParametrics = 0;
2851	mScriptContext.program = gp;
2852	StringVector::iterator i, iend;
2853	iend = mScriptContext.defaultParamLines.end();
2854	for (i = mScriptContext.defaultParamLines.begin();
2855	i != iend; ++i)
2856	{
2857	// find & invoke a parser
2858	// do this manually because we want to call a custom
2859	// routine when the parser is not found
2860	// First, split line on first divisor only
2861	StringVector splitCmd = StringUtil::split(*i, " \t", 1);
2862	// Find attribute parser
2863	AttribParserList::iterator iparser
2864	= mProgramDefaultParamAttribParsers.find(splitCmd[0]);
2865	if (iparser != mProgramDefaultParamAttribParsers.end())
2866	{
2867	String cmd = splitCmd.size() >= 2? splitCmd[1]:StringUtil::BLANK;
2868	// Use parser with remainder
2869	iparser->second(cmd, mScriptContext );
2870	}
2871
2872	}
2873	// Reset
2874	mScriptContext.program.setNull();
2875	mScriptContext.programParams.setNull();
2876	}
2877
2878	}
2879	//-----------------------------------------------------------------------
2880	bool MaterialSerializer::invokeParser(String& line, AttribParserList& parsers)
2881	{
2882	// First, split line on first divisor only
2883	StringVector splitCmd(StringUtil::split(line, " \t", 1));
2884
2885	// Find attribute parser
2886	AttribParserList::iterator iparser = parsers.find(splitCmd[0]);
2887	if (iparser == parsers.end())
2888	{
2889	// BAD command. BAD!
2890	logParseError("Unrecognised command: " + splitCmd[0], mScriptContext);
2891	return false;
2892	}
2893	else
2894	{
2895	String cmd;
2896	if(splitCmd.size() >= 2)
2897	cmd = splitCmd[1];
2898	// Use parser, make sure we have 2 params before using splitCmd[1]
2899	return iparser->second( cmd, mScriptContext );
2900	}
2901	}
2902	//-----------------------------------------------------------------------
2903	void MaterialSerializer::exportMaterial(const MaterialPtr& pMat, const String &fileName, bool exportDefaults,
2904	const bool includeProgDef, const String& programFilename)
2905	{
2906	clearQueue();
2907	mDefaults = exportDefaults;
2908	writeMaterial(pMat);
2909	exportQueued(fileName, includeProgDef, programFilename);
2910	}
2911	//-----------------------------------------------------------------------
2912	void MaterialSerializer::exportQueued(const String &fileName, const bool includeProgDef, const String& programFilename)
2913	{
2914	// write out gpu program definitions to the buffer
2915	writeGpuPrograms();
2916
2917	if (mBuffer == "")
2918	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Queue is empty !", "MaterialSerializer::exportQueued");
2919
2920	LogManager::getSingleton().logMessage("MaterialSerializer : writing material(s) to material script : " + fileName, LML_CRITICAL);
2921	FILE *fp;
2922	fp = fopen(fileName.c_str(), "w");
2923	if (!fp)
2924	OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE, "Cannot create material file.",
2925	"MaterialSerializer::export");
2926
2927	// output gpu program definitions to material script file if includeProgDef is true
2928	if (includeProgDef && !mGpuProgramBuffer.empty())
2929	{
2930	fputs(mGpuProgramBuffer.c_str(), fp);
2931	}
2932
2933	// output main buffer holding material script
2934	fputs(mBuffer.c_str(), fp);
2935	fclose(fp);
2936
2937	// write program script if program filename and program definitions
2938	// were not included in material script
2939	if (!includeProgDef && !mGpuProgramBuffer.empty() && !programFilename.empty())
2940	{
2941	FILE *fp;
2942	fp = fopen(programFilename.c_str(), "w");
2943	if (!fp)
2944	OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE, "Cannot create program material file.",
2945	"MaterialSerializer::export");
2946	fputs(mGpuProgramBuffer.c_str(), fp);
2947	fclose(fp);
2948	}
2949
2950	LogManager::getSingleton().logMessage("MaterialSerializer : done.", LML_CRITICAL);
2951	clearQueue();
2952	}
2953	//-----------------------------------------------------------------------
2954	void MaterialSerializer::queueForExport(const MaterialPtr& pMat,
2955	bool clearQueued, bool exportDefaults)
2956	{
2957	if (clearQueued)
2958	clearQueue();
2959
2960	mDefaults = exportDefaults;
2961	writeMaterial(pMat);
2962	}
2963	//-----------------------------------------------------------------------
2964	void MaterialSerializer::clearQueue()
2965	{
2966	mBuffer = "";
2967	mGpuProgramBuffer = "";
2968	mGpuProgramDefinitionContainer.clear();
2969	}
2970	//-----------------------------------------------------------------------
2971	const String &MaterialSerializer::getQueuedAsString() const
2972	{
2973	return mBuffer;
2974	}
2975	//-----------------------------------------------------------------------
2976	void MaterialSerializer::writeMaterial(const MaterialPtr& pMat)
2977	{
2978	LogManager::getSingleton().logMessage("MaterialSerializer : writing material " + pMat->getName() + " to queue.", LML_CRITICAL);
2979	// Material name
2980	writeAttribute(0, "material " + pMat->getName());
2981	beginSection(0);
2982	{
2983	// Write LOD information
2984	Material::LodDistanceIterator distIt = pMat->getLodDistanceIterator();
2985	// Skip zero value
2986	if (distIt.hasMoreElements())
2987	distIt.getNext();
2988	String attributeVal;
2989	while (distIt.hasMoreElements())
2990	{
2991	Real sqdist = distIt.getNext();
2992	attributeVal.append(StringConverter::toString(Math::Sqrt(sqdist)));
2993	if (distIt.hasMoreElements())
2994	attributeVal.append(" ");
2995	}
2996	if (!attributeVal.empty())
2997	{
2998	writeAttribute(1, "lod_distances");
2999	writeValue(attributeVal);
3000	}
3001
3002
3003	// Shadow receive
3004	if (mDefaults \|\|
3005	pMat->getReceiveShadows() != true)
3006	{
3007	writeAttribute(1, "receive_shadows");
3008	writeValue(pMat->getReceiveShadows() ? "on" : "off");
3009	}
3010
3011	// When rendering shadows, treat transparent things as opaque?
3012	if (mDefaults \|\|
3013	pMat->getTransparencyCastsShadows() == true)
3014	{
3015	writeAttribute(1, "transparency_casts_shadows");
3016	writeValue(pMat->getTransparencyCastsShadows() ? "on" : "off");
3017	}
3018
3019	// Iterate over techniques
3020	Material::TechniqueIterator it = pMat->getTechniqueIterator();
3021	while (it.hasMoreElements())
3022	{
3023	writeTechnique(it.getNext());
3024	mBuffer += "\n";
3025	}
3026	}
3027	endSection(0);
3028	mBuffer += "\n";
3029	}
3030	//-----------------------------------------------------------------------
3031	void MaterialSerializer::writeTechnique(const Technique* pTech)
3032	{
3033	// Technique header
3034	writeAttribute(1, "technique");
3035	// only output technique name if it exists.
3036	if (!pTech->getName().empty())
3037	writeValue(pTech->getName());
3038
3039	beginSection(1);
3040	{
3041	// Lod index
3042	if (mDefaults \|\|
3043	pTech->getLodIndex() != 0)
3044	{
3045	writeAttribute(2, "lod_index");
3046	writeValue(StringConverter::toString(pTech->getLodIndex()));
3047	}
3048
3049	// Scheme name
3050	if (mDefaults \|\|
3051	pTech->getSchemeName() != MaterialManager::DEFAULT_SCHEME_NAME)
3052	{
3053	writeAttribute(2, "scheme");
3054	writeValue(pTech->getSchemeName());
3055	}
3056
3057	// Iterate over passes
3058	Technique::PassIterator it = const_cast<Technique*>(pTech)->getPassIterator();
3059	while (it.hasMoreElements())
3060	{
3061	writePass(it.getNext());
3062	mBuffer += "\n";
3063	}
3064	}
3065	endSection(1);
3066
3067	}
3068	//-----------------------------------------------------------------------
3069	void MaterialSerializer::writePass(const Pass* pPass)
3070	{
3071	writeAttribute(2, "pass");
3072	// only output pass name if its not the default name
3073	if (pPass->getName() != StringConverter::toString(pPass->getIndex()))
3074	writeValue(pPass->getName());
3075
3076	beginSection(2);
3077	{
3078	//lighting
3079	if (mDefaults \|\|
3080	pPass->getLightingEnabled() != true)
3081	{
3082	writeAttribute(3, "lighting");
3083	writeValue(pPass->getLightingEnabled() ? "on" : "off");
3084	}
3085	// max_lights
3086	if (mDefaults \|\|
3087	pPass->getMaxSimultaneousLights() != OGRE_MAX_SIMULTANEOUS_LIGHTS)
3088	{
3089	writeAttribute(3, "max_lights");
3090	writeValue(StringConverter::toString(pPass->getMaxSimultaneousLights()));
3091	}
3092	// iteration
3093	if (mDefaults \|\|
3094	pPass->getIteratePerLight() \|\| (pPass->getPassIterationCount() > 0))
3095	{
3096	writeAttribute(3, "iteration");
3097	// pass iteration count
3098	if (pPass->getPassIterationCount() > 0)
3099	{
3100	writeValue(StringConverter::toString(pPass->getPassIterationCount()));
3101	if (pPass->getIteratePerLight())
3102	writeValue("per_light");
3103	}
3104	else
3105	{
3106	writeValue(pPass->getIteratePerLight() ? "once_per_light" : "once");
3107	}
3108
3109	if (pPass->getIteratePerLight() && pPass->getRunOnlyForOneLightType())
3110	{
3111	switch (pPass->getOnlyLightType())
3112	{
3113	case Light::LT_DIRECTIONAL:
3114	writeValue("directional");
3115	break;
3116	case Light::LT_POINT:
3117	writeValue("point");
3118	break;
3119	case Light::LT_SPOTLIGHT:
3120	writeValue("spot");
3121	break;
3122	};
3123	}
3124	}
3125
3126
3127	if (pPass->getLightingEnabled())
3128	{
3129	// Ambient
3130	if (mDefaults \|\|
3131	pPass->getAmbient().r != 1 \|\|
3132	pPass->getAmbient().g != 1 \|\|
3133	pPass->getAmbient().b != 1 \|\|
3134	pPass->getAmbient().a != 1 \|\|
3135	(pPass->getVertexColourTracking() & TVC_AMBIENT))
3136	{
3137	writeAttribute(3, "ambient");
3138	if (pPass->getVertexColourTracking() & TVC_AMBIENT)
3139	writeValue("vertexcolour");
3140	else
3141	writeColourValue(pPass->getAmbient(), true);
3142	}
3143
3144	// Diffuse
3145	if (mDefaults \|\|
3146	pPass->getDiffuse().r != 1 \|\|
3147	pPass->getDiffuse().g != 1 \|\|
3148	pPass->getDiffuse().b != 1 \|\|
3149	pPass->getDiffuse().a != 1 \|\|
3150	(pPass->getVertexColourTracking() & TVC_DIFFUSE))
3151	{
3152	writeAttribute(3, "diffuse");
3153	if (pPass->getVertexColourTracking() & TVC_DIFFUSE)
3154	writeValue("vertexcolour");
3155	else
3156	writeColourValue(pPass->getDiffuse(), true);
3157	}
3158
3159	// Specular
3160	if (mDefaults \|\|
3161	pPass->getSpecular().r != 0 \|\|
3162	pPass->getSpecular().g != 0 \|\|
3163	pPass->getSpecular().b != 0 \|\|
3164	pPass->getSpecular().a != 1 \|\|
3165	pPass->getShininess() != 0 \|\|
3166	(pPass->getVertexColourTracking() & TVC_SPECULAR))
3167	{
3168	writeAttribute(3, "specular");
3169	if (pPass->getVertexColourTracking() & TVC_SPECULAR)
3170	{
3171	writeValue("vertexcolour");
3172	}
3173	else
3174	{
3175	writeColourValue(pPass->getSpecular(), true);
3176	}
3177	writeValue(StringConverter::toString(pPass->getShininess()));
3178
3179	}
3180
3181	// Emissive
3182	if (mDefaults \|\|
3183	pPass->getSelfIllumination().r != 0 \|\|
3184	pPass->getSelfIllumination().g != 0 \|\|
3185	pPass->getSelfIllumination().b != 0 \|\|
3186	pPass->getSelfIllumination().a != 1 \|\|
3187	(pPass->getVertexColourTracking() & TVC_EMISSIVE))
3188	{
3189	writeAttribute(3, "emissive");
3190	if (pPass->getVertexColourTracking() & TVC_EMISSIVE)
3191	writeValue("vertexcolour");
3192	else
3193	writeColourValue(pPass->getSelfIllumination(), true);
3194	}
3195	}
3196
3197	// Point size
3198	if (mDefaults \|\|
3199	pPass->getPointSize() != 1.0)
3200	{
3201	writeAttribute(3, "point_size");
3202	writeValue(StringConverter::toString(pPass->getPointSize()));
3203	}
3204
3205	// Point sprites
3206	if (mDefaults \|\|
3207	pPass->getPointSpritesEnabled())
3208	{
3209	writeAttribute(3, "point_sprites");
3210	writeValue(pPass->getPointSpritesEnabled() ? "on" : "off");
3211	}
3212
3213	// Point attenuation
3214	if (mDefaults \|\|
3215	pPass->isPointAttenuationEnabled())
3216	{
3217	writeAttribute(3, "point_size_attenuation");
3218	writeValue(pPass->isPointAttenuationEnabled() ? "on" : "off");
3219	if (pPass->isPointAttenuationEnabled() &&
3220	(pPass->getPointAttenuationConstant() != 0.0 \|\|
3221	pPass->getPointAttenuationLinear() != 1.0 \|\|
3222	pPass->getPointAttenuationQuadratic() != 0.0))
3223	{
3224	writeValue(StringConverter::toString(pPass->getPointAttenuationConstant()));
3225	writeValue(StringConverter::toString(pPass->getPointAttenuationLinear()));
3226	writeValue(StringConverter::toString(pPass->getPointAttenuationQuadratic()));
3227	}
3228	}
3229
3230	// Point min size
3231	if (mDefaults \|\|
3232	pPass->getPointMinSize() != 0.0)
3233	{
3234	writeAttribute(3, "point_size_min");
3235	writeValue(StringConverter::toString(pPass->getPointMinSize()));
3236	}
3237
3238	// Point max size
3239	if (mDefaults \|\|
3240	pPass->getPointMaxSize() != 0.0)
3241	{
3242	writeAttribute(3, "point_size_max");
3243	writeValue(StringConverter::toString(pPass->getPointMaxSize()));
3244	}
3245
3246	// scene blend factor
3247	if (mDefaults \|\|
3248	pPass->getSourceBlendFactor() != SBF_ONE \|\|
3249	pPass->getDestBlendFactor() != SBF_ZERO)
3250	{
3251	writeAttribute(3, "scene_blend");
3252	writeSceneBlendFactor(pPass->getSourceBlendFactor(), pPass->getDestBlendFactor());
3253	}
3254
3255
3256	//depth check
3257	if (mDefaults \|\|
3258	pPass->getDepthCheckEnabled() != true)
3259	{
3260	writeAttribute(3, "depth_check");
3261	writeValue(pPass->getDepthCheckEnabled() ? "on" : "off");
3262	}
3263	// alpha_rejection
3264	if (mDefaults \|\|
3265	pPass->getAlphaRejectFunction() != CMPF_ALWAYS_PASS \|\|
3266	pPass->getAlphaRejectValue() != 0)
3267	{
3268	writeAttribute(3, "alpha_rejection");
3269	writeCompareFunction(pPass->getAlphaRejectFunction());
3270	writeValue(StringConverter::toString(pPass->getAlphaRejectValue()));
3271	}
3272
3273
3274	//depth write
3275	if (mDefaults \|\|
3276	pPass->getDepthWriteEnabled() != true)
3277	{
3278	writeAttribute(3, "depth_write");
3279	writeValue(pPass->getDepthWriteEnabled() ? "on" : "off");
3280	}
3281
3282	//depth function
3283	if (mDefaults \|\|
3284	pPass->getDepthFunction() != CMPF_LESS_EQUAL)
3285	{
3286	writeAttribute(3, "depth_func");
3287	writeCompareFunction(pPass->getDepthFunction());
3288	}
3289
3290	//depth bias
3291	if (mDefaults \|\|
3292	pPass->getDepthBias() != 0)
3293	{
3294	writeAttribute(3, "depth_bias");
3295	writeValue(StringConverter::toString(pPass->getDepthBias()));
3296	}
3297
3298	// hardware culling mode
3299	if (mDefaults \|\|
3300	pPass->getCullingMode() != CULL_CLOCKWISE)
3301	{
3302	CullingMode hcm = pPass->getCullingMode();
3303	writeAttribute(3, "cull_hardware");
3304	switch (hcm)
3305	{
3306	case CULL_NONE :
3307	writeValue("none");
3308	break;
3309	case CULL_CLOCKWISE :
3310	writeValue("clockwise");
3311	break;
3312	case CULL_ANTICLOCKWISE :
3313	writeValue("anticlockwise");
3314	break;
3315	}
3316	}
3317
3318	// software culling mode
3319	if (mDefaults \|\|
3320	pPass->getManualCullingMode() != MANUAL_CULL_BACK)
3321	{
3322	ManualCullingMode scm = pPass->getManualCullingMode();
3323	writeAttribute(3, "cull_software");
3324	switch (scm)
3325	{
3326	case MANUAL_CULL_NONE :
3327	writeValue("none");
3328	break;
3329	case MANUAL_CULL_BACK :
3330	writeValue("back");
3331	break;
3332	case MANUAL_CULL_FRONT :
3333	writeValue("front");
3334	break;
3335	}
3336	}
3337
3338	//shading
3339	if (mDefaults \|\|
3340	pPass->getShadingMode() != SO_GOURAUD)
3341	{
3342	writeAttribute(3, "shading");
3343	switch (pPass->getShadingMode())
3344	{
3345	case SO_FLAT:
3346	writeValue("flat");
3347	break;
3348	case SO_GOURAUD:
3349	writeValue("gouraud");
3350	break;
3351	case SO_PHONG:
3352	writeValue("phong");
3353	break;
3354	}
3355	}
3356
3357
3358	if (mDefaults \|\|
3359	pPass->getPolygonMode() != PM_SOLID)
3360	{
3361	writeAttribute(3, "polygon_mode");
3362	switch (pPass->getPolygonMode())
3363	{
3364	case PM_POINTS:
3365	writeValue("points");
3366	break;
3367	case PM_WIREFRAME:
3368	writeValue("wireframe");
3369	break;
3370	case PM_SOLID:
3371	writeValue("solid");
3372	break;
3373	}
3374	}
3375
3376	//fog override
3377	if (mDefaults \|\|
3378	pPass->getFogOverride() != false)
3379	{
3380	writeAttribute(3, "fog_override");
3381	writeValue(pPass->getFogOverride() ? "true" : "false");
3382	if (pPass->getFogOverride())
3383	{
3384	switch (pPass->getFogMode())
3385	{
3386	case FOG_NONE:
3387	writeValue("none");
3388	break;
3389	case FOG_LINEAR:
3390	writeValue("linear");
3391	break;
3392	case FOG_EXP2:
3393	writeValue("exp2");
3394	break;
3395	case FOG_EXP:
3396	writeValue("exp");
3397	break;
3398	}
3399
3400	if (pPass->getFogMode() != FOG_NONE)
3401	{
3402	writeColourValue(pPass->getFogColour());
3403	writeValue(StringConverter::toString(pPass->getFogDensity()));
3404	writeValue(StringConverter::toString(pPass->getFogStart()));
3405	writeValue(StringConverter::toString(pPass->getFogEnd()));
3406	}
3407	}
3408	}
3409
3410	// nfz
3411
3412	// GPU Vertex and Fragment program references and parameters
3413	if (pPass->hasVertexProgram())
3414	{
3415	writeVertexProgramRef(pPass);
3416	}
3417
3418	if (pPass->hasFragmentProgram())
3419	{
3420	writeFragmentProgramRef(pPass);
3421	}
3422
3423	if (pPass->hasShadowCasterVertexProgram())
3424	{
3425	writeShadowCasterVertexProgramRef(pPass);
3426	}
3427
3428	if (pPass->hasShadowReceiverVertexProgram())
3429	{
3430	writeShadowReceiverVertexProgramRef(pPass);
3431	}
3432
3433	if (pPass->hasShadowReceiverFragmentProgram())
3434	{
3435	writeShadowReceiverFragmentProgramRef(pPass);
3436	}
3437
3438	// Nested texture layers
3439	Pass::TextureUnitStateIterator it = const_cast<Pass*>(pPass)->getTextureUnitStateIterator();
3440	while(it.hasMoreElements())
3441	{
3442	writeTextureUnit(it.getNext());
3443	}
3444	}
3445	endSection(2);
3446	LogManager::getSingleton().logMessage("MaterialSerializer : done.", LML_CRITICAL);
3447	}
3448	//-----------------------------------------------------------------------
3449	String MaterialSerializer::convertFiltering(FilterOptions fo)
3450	{
3451	switch (fo)
3452	{
3453	case FO_NONE:
3454	return "none";
3455	case FO_POINT:
3456	return "point";
3457	case FO_LINEAR:
3458	return "linear";
3459	case FO_ANISOTROPIC:
3460	return "anisotropic";
3461	}
3462
3463	return "point";
3464	}
3465	//-----------------------------------------------------------------------
3466	String convertTexAddressMode(TextureUnitState::TextureAddressingMode tam)
3467	{
3468	switch (tam)
3469	{
3470	case TextureUnitState::TAM_BORDER:
3471	return "border";
3472	case TextureUnitState::TAM_CLAMP:
3473	return "clamp";
3474	case TextureUnitState::TAM_MIRROR:
3475	return "mirror";
3476	case TextureUnitState::TAM_WRAP:
3477	return "wrap";
3478	}
3479
3480	return "wrap";
3481	}
3482	//-----------------------------------------------------------------------
3483	void MaterialSerializer::writeTextureUnit(const TextureUnitState *pTex)
3484	{
3485	LogManager::getSingleton().logMessage("MaterialSerializer : parsing texture layer.", LML_CRITICAL);
3486	mBuffer += "\n";
3487	writeAttribute(3, "texture_unit");
3488	// only write out name if its not equal to the default name
3489	if (pTex->getName() != StringConverter::toString(pTex->getParent()->getTextureUnitStateIndex(pTex)))
3490	writeValue(pTex->getName());
3491
3492	beginSection(3);
3493	{
3494	// texture_alias
3495	if (!pTex->getTextureNameAlias().empty())
3496	{
3497	writeAttribute(4, "texture_alias");
3498	writeValue(pTex->getTextureNameAlias());
3499	}
3500
3501	//texture name
3502	if (pTex->getNumFrames() == 1 && pTex->getTextureName() != "" && !pTex->isCubic())
3503	{
3504	writeAttribute(4, "texture");
3505	writeValue(pTex->getTextureName());
3506
3507	switch (pTex->getTextureType())
3508	{
3509	case TEX_TYPE_1D:
3510	writeValue("1d");
3511	break;
3512	case TEX_TYPE_2D:
3513	// nothing, this is the default
3514	break;
3515	case TEX_TYPE_3D:
3516	writeValue("3d");
3517	break;
3518	case TEX_TYPE_CUBE_MAP:
3519	// nothing, deal with this as cubic_texture since it copes with all variants
3520	break;
3521	default:
3522	break;
3523	};
3524	}
3525
3526	//anim. texture
3527	if (pTex->getNumFrames() > 1 && !pTex->isCubic())
3528	{
3529	writeAttribute(4, "anim_texture");
3530	for (unsigned int n = 0; n < pTex->getNumFrames(); n++)
3531	writeValue(pTex->getFrameTextureName(n));
3532	writeValue(StringConverter::toString(pTex->getAnimationDuration()));
3533	}
3534
3535	//cubic texture
3536	if (pTex->isCubic())
3537	{
3538	writeAttribute(4, "cubic_texture");
3539	for (unsigned int n = 0; n < pTex->getNumFrames(); n++)
3540	writeValue(pTex->getFrameTextureName(n));
3541
3542	//combinedUVW/separateUW
3543	if (pTex->getTextureType() == TEX_TYPE_CUBE_MAP)
3544	writeValue("combinedUVW");
3545	else
3546	writeValue("separateUV");
3547	}
3548
3549	//anisotropy level
3550	if (mDefaults \|\|
3551	pTex->getTextureAnisotropy() != 1)
3552	{
3553	writeAttribute(4, "max_anisotropy");
3554	writeValue(StringConverter::toString(pTex->getTextureAnisotropy()));
3555	}
3556
3557	//texture coordinate set
3558	if (mDefaults \|\|
3559	pTex->getTextureCoordSet() != 0)
3560	{
3561	writeAttribute(4, "tex_coord_set");
3562	writeValue(StringConverter::toString(pTex->getTextureCoordSet()));
3563	}
3564
3565	//addressing mode
3566	const TextureUnitState::UVWAddressingMode& uvw =
3567	pTex->getTextureAddressingMode();
3568	if (mDefaults \|\|
3569	uvw.u != Ogre::TextureUnitState::TAM_WRAP \|\|
3570	uvw.v != Ogre::TextureUnitState::TAM_WRAP \|\|
3571	uvw.w != Ogre::TextureUnitState::TAM_WRAP )
3572	{
3573	writeAttribute(4, "tex_address_mode");
3574	if (uvw.u == uvw.v && uvw.u == uvw.w)
3575	{
3576	writeValue(convertTexAddressMode(uvw.u));
3577	}
3578	else
3579	{
3580	writeValue(convertTexAddressMode(uvw.u));
3581	writeValue(convertTexAddressMode(uvw.v));
3582	if (uvw.w != TextureUnitState::TAM_WRAP)
3583	{
3584	writeValue(convertTexAddressMode(uvw.w));
3585	}
3586	}
3587	}
3588
3589	//border colour
3590	const ColourValue& borderColour =
3591	pTex->getTextureBorderColour();
3592	if (mDefaults \|\|
3593	borderColour != ColourValue::Black)
3594	{
3595	writeAttribute(4, "tex_border_colour");
3596	writeColourValue(borderColour, true);
3597	}
3598
3599	//filtering
3600	if (mDefaults \|\|
3601	pTex->getTextureFiltering(FT_MIN) != FO_LINEAR \|\|
3602	pTex->getTextureFiltering(FT_MAG) != FO_LINEAR \|\|
3603	pTex->getTextureFiltering(FT_MIP) != FO_POINT)
3604	{
3605	writeAttribute(4, "filtering");
3606	writeValue(
3607	convertFiltering(pTex->getTextureFiltering(FT_MIN))
3608	+ " "
3609	+ convertFiltering(pTex->getTextureFiltering(FT_MAG))
3610	+ " "
3611	+ convertFiltering(pTex->getTextureFiltering(FT_MIP)));
3612	}
3613
3614	// colour_op_ex
3615	if (mDefaults \|\|
3616	pTex->getColourBlendMode().operation != LBX_MODULATE \|\|
3617	pTex->getColourBlendMode().source1 != LBS_TEXTURE \|\|
3618	pTex->getColourBlendMode().source2 != LBS_CURRENT)
3619	{
3620	writeAttribute(4, "colour_op_ex");
3621	writeLayerBlendOperationEx(pTex->getColourBlendMode().operation);
3622	writeLayerBlendSource(pTex->getColourBlendMode().source1);
3623	writeLayerBlendSource(pTex->getColourBlendMode().source2);
3624	if (pTex->getColourBlendMode().operation == LBX_BLEND_MANUAL)
3625	writeValue(StringConverter::toString(pTex->getColourBlendMode().factor));
3626	if (pTex->getColourBlendMode().source1 == LBS_MANUAL)
3627	writeColourValue(pTex->getColourBlendMode().colourArg1, false);
3628	if (pTex->getColourBlendMode().source2 == LBS_MANUAL)
3629	writeColourValue(pTex->getColourBlendMode().colourArg2, false);
3630
3631	//colour_op_multipass_fallback
3632	writeAttribute(4, "colour_op_multipass_fallback");
3633	writeSceneBlendFactor(pTex->getColourBlendFallbackSrc());
3634	writeSceneBlendFactor(pTex->getColourBlendFallbackDest());
3635	}
3636
3637	// alpha_op_ex
3638	if (mDefaults \|\|
3639	pTex->getAlphaBlendMode().operation != LBX_MODULATE \|\|
3640	pTex->getAlphaBlendMode().source1 != LBS_TEXTURE \|\|
3641	pTex->getAlphaBlendMode().source2 != LBS_CURRENT)
3642	{
3643	writeAttribute(4, "alpha_op_ex");
3644	writeLayerBlendOperationEx(pTex->getAlphaBlendMode().operation);
3645	writeLayerBlendSource(pTex->getAlphaBlendMode().source1);
3646	writeLayerBlendSource(pTex->getAlphaBlendMode().source2);
3647	if (pTex->getAlphaBlendMode().operation == LBX_BLEND_MANUAL)
3648	writeValue(StringConverter::toString(pTex->getAlphaBlendMode().factor));
3649	else if (pTex->getAlphaBlendMode().source1 == LBS_MANUAL)
3650	writeValue(StringConverter::toString(pTex->getAlphaBlendMode().alphaArg1));
3651	else if (pTex->getAlphaBlendMode().source2 == LBS_MANUAL)
3652	writeValue(StringConverter::toString(pTex->getAlphaBlendMode().alphaArg2));
3653	}
3654
3655	bool individualTransformElems = false;
3656	// rotate
3657	if (mDefaults \|\|
3658	pTex->getTextureRotate() != Radian(0))
3659	{
3660	writeAttribute(4, "rotate");
3661	writeValue(StringConverter::toString(pTex->getTextureRotate().valueDegrees()));
3662	individualTransformElems = true;
3663	}
3664
3665	// scroll
3666	if (mDefaults \|\|
3667	pTex->getTextureUScroll() != 0 \|\|
3668	pTex->getTextureVScroll() != 0 )
3669	{
3670	writeAttribute(4, "scroll");
3671	writeValue(StringConverter::toString(pTex->getTextureUScroll()));
3672	writeValue(StringConverter::toString(pTex->getTextureVScroll()));
3673	individualTransformElems = true;
3674	}
3675	// scale
3676	if (mDefaults \|\|
3677	pTex->getTextureUScale() != 1.0 \|\|
3678	pTex->getTextureVScale() != 1.0 )
3679	{
3680	writeAttribute(4, "scale");
3681	writeValue(StringConverter::toString(pTex->getTextureUScale()));
3682	writeValue(StringConverter::toString(pTex->getTextureVScale()));
3683	individualTransformElems = true;
3684	}
3685
3686	// free transform
3687	if (!individualTransformElems &&
3688	(mDefaults \|\|
3689	pTex->getTextureTransform() != Matrix4::IDENTITY))
3690	{
3691	writeAttribute(4, "transform");
3692	const Matrix4& xform = pTex->getTextureTransform();
3693	for (int row = 0; row < 4; ++row)
3694	{
3695	for (int col = 0; col < 4; ++col)
3696	{
3697	writeValue(StringConverter::toString(xform[row][col]));
3698	}
3699	}
3700	}
3701
3702	// Used to store the u and v speeds of scroll animation effects
3703	float scrollAnimU = 0;
3704	float scrollAnimV = 0;
3705
3706	EffectMap m_ef = pTex->getEffects();
3707	if (!m_ef.empty())
3708	{
3709	EffectMap::const_iterator it;
3710	for (it = m_ef.begin(); it != m_ef.end(); ++it)
3711	{
3712	const TextureUnitState::TextureEffect& ef = it->second;
3713	switch (ef.type)
3714	{
3715	case TextureUnitState::ET_ENVIRONMENT_MAP :
3716	writeEnvironmentMapEffect(ef, pTex);
3717	break;
3718	case TextureUnitState::ET_ROTATE :
3719	writeRotationEffect(ef, pTex);
3720	break;
3721	case TextureUnitState::ET_UVSCROLL :
3722	scrollAnimU = scrollAnimV = ef.arg1;
3723	break;
3724	case TextureUnitState::ET_USCROLL :
3725	scrollAnimU = ef.arg1;
3726	break;
3727	case TextureUnitState::ET_VSCROLL :
3728	scrollAnimV = ef.arg1;
3729	break;
3730	case TextureUnitState::ET_TRANSFORM :
3731	writeTransformEffect(ef, pTex);
3732	break;
3733	default:
3734	break;
3735	}
3736	}
3737	}
3738
3739	// u and v scroll animation speeds merged, if present serialize scroll_anim
3740	if(scrollAnimU \|\| scrollAnimV) {
3741	TextureUnitState::TextureEffect texEffect;
3742	texEffect.arg1 = scrollAnimU;
3743	texEffect.arg2 = scrollAnimV;
3744	writeScrollEffect(texEffect, pTex);
3745	}
3746	}
3747	endSection(3);
3748
3749	}
3750	//-----------------------------------------------------------------------
3751	void MaterialSerializer::writeEnvironmentMapEffect(const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex)
3752	{
3753	writeAttribute(4, "env_map");
3754	switch (effect.subtype)
3755	{
3756	case TextureUnitState::ENV_PLANAR:
3757	writeValue("planar");
3758	break;
3759	case TextureUnitState::ENV_CURVED:
3760	writeValue("spherical");
3761	break;
3762	case TextureUnitState::ENV_NORMAL:
3763	writeValue("cubic_normal");
3764	break;
3765	case TextureUnitState::ENV_REFLECTION:
3766	writeValue("cubic_reflection");
3767	break;
3768	}
3769	}
3770	//-----------------------------------------------------------------------
3771	void MaterialSerializer::writeRotationEffect(const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex)
3772	{
3773	if (effect.arg1)
3774	{
3775	writeAttribute(4, "rotate_anim");
3776	writeValue(StringConverter::toString(effect.arg1));
3777	}
3778	}
3779	//-----------------------------------------------------------------------
3780	void MaterialSerializer::writeTransformEffect(const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex)
3781	{
3782	writeAttribute(4, "wave_xform");
3783
3784	switch (effect.subtype)
3785	{
3786	case TextureUnitState::TT_ROTATE:
3787	writeValue("rotate");
3788	break;
3789	case TextureUnitState::TT_SCALE_U:
3790	writeValue("scale_x");
3791	break;
3792	case TextureUnitState::TT_SCALE_V:
3793	writeValue("scale_y");
3794	break;
3795	case TextureUnitState::TT_TRANSLATE_U:
3796	writeValue("scroll_x");
3797	break;
3798	case TextureUnitState::TT_TRANSLATE_V:
3799	writeValue("scroll_y");
3800	break;
3801	}
3802
3803	switch (effect.waveType)
3804	{
3805	case WFT_INVERSE_SAWTOOTH:
3806	writeValue("inverse_sawtooth");
3807	break;
3808	case WFT_SAWTOOTH:
3809	writeValue("sawtooth");
3810	break;
3811	case WFT_SINE:
3812	writeValue("sine");
3813	break;
3814	case WFT_SQUARE:
3815	writeValue("square");
3816	break;
3817	case WFT_TRIANGLE:
3818	writeValue("triangle");
3819	break;
3820	}
3821
3822	writeValue(StringConverter::toString(effect.base));
3823	writeValue(StringConverter::toString(effect.frequency));
3824	writeValue(StringConverter::toString(effect.phase));
3825	writeValue(StringConverter::toString(effect.amplitude));
3826	}
3827	//-----------------------------------------------------------------------
3828	void MaterialSerializer::writeScrollEffect(
3829	const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex)
3830	{
3831	if (effect.arg1 \|\| effect.arg2)
3832	{
3833	writeAttribute(4, "scroll_anim");
3834	writeValue(StringConverter::toString(effect.arg1));
3835	writeValue(StringConverter::toString(effect.arg2));
3836	}
3837	}
3838	//-----------------------------------------------------------------------
3839	void MaterialSerializer::writeSceneBlendFactor(const SceneBlendFactor sbf)
3840	{
3841	switch (sbf)
3842	{
3843	case SBF_DEST_ALPHA:
3844	writeValue("dest_alpha");
3845	break;
3846	case SBF_DEST_COLOUR:
3847	writeValue("dest_colour");
3848	break;
3849	case SBF_ONE:
3850	writeValue("one");
3851	break;
3852	case SBF_ONE_MINUS_DEST_ALPHA:
3853	writeValue("one_minus_dest_alpha");
3854	break;
3855	case SBF_ONE_MINUS_DEST_COLOUR:
3856	writeValue("one_minus_dest_colour");
3857	break;
3858	case SBF_ONE_MINUS_SOURCE_ALPHA:
3859	writeValue("one_minus_src_alpha");
3860	break;
3861	case SBF_ONE_MINUS_SOURCE_COLOUR:
3862	writeValue("one_minus_src_colour");
3863	break;
3864	case SBF_SOURCE_ALPHA:
3865	writeValue("src_alpha");
3866	break;
3867	case SBF_SOURCE_COLOUR:
3868	writeValue("src_colour");
3869	break;
3870	case SBF_ZERO:
3871	writeValue("zero");
3872	break;
3873	}
3874	}
3875	//-----------------------------------------------------------------------
3876	void MaterialSerializer::writeSceneBlendFactor(const SceneBlendFactor sbf_src, const SceneBlendFactor sbf_dst)
3877	{
3878	if (sbf_src == SBF_ONE && sbf_dst == SBF_ONE )
3879	writeValue("add");
3880	else if (sbf_src == SBF_DEST_COLOUR && sbf_dst == SBF_ZERO)
3881	writeValue("modulate");
3882	else if (sbf_src == SBF_SOURCE_COLOUR && sbf_dst == SBF_ONE_MINUS_SOURCE_COLOUR)
3883	writeValue("colour_blend");
3884	else if (sbf_src == SBF_SOURCE_ALPHA && sbf_dst == SBF_ONE_MINUS_SOURCE_ALPHA)
3885	writeValue("alpha_blend");
3886	else
3887	{
3888	writeSceneBlendFactor(sbf_src);
3889	writeSceneBlendFactor(sbf_dst);
3890	}
3891	}
3892	//-----------------------------------------------------------------------
3893	void MaterialSerializer::writeCompareFunction(const CompareFunction cf)
3894	{
3895	switch (cf)
3896	{
3897	case CMPF_ALWAYS_FAIL:
3898	writeValue("always_fail");
3899	break;
3900	case CMPF_ALWAYS_PASS:
3901	writeValue("always_pass");
3902	break;
3903	case CMPF_EQUAL:
3904	writeValue("equal");
3905	break;
3906	case CMPF_GREATER:
3907	writeValue("greater");
3908	break;
3909	case CMPF_GREATER_EQUAL:
3910	writeValue("greater_equal");
3911	break;
3912	case CMPF_LESS:
3913	writeValue("less");
3914	break;
3915	case CMPF_LESS_EQUAL:
3916	writeValue("less_equal");
3917	break;
3918	case CMPF_NOT_EQUAL:
3919	writeValue("not_equal");
3920	break;
3921	}
3922	}
3923	//-----------------------------------------------------------------------
3924	void MaterialSerializer::writeColourValue(const ColourValue &colour, bool writeAlpha)
3925	{
3926	writeValue(StringConverter::toString(colour.r));
3927	writeValue(StringConverter::toString(colour.g));
3928	writeValue(StringConverter::toString(colour.b));
3929	if (writeAlpha)
3930	writeValue(StringConverter::toString(colour.a));
3931	}
3932	//-----------------------------------------------------------------------
3933	void MaterialSerializer::writeLayerBlendOperationEx(const LayerBlendOperationEx op)
3934	{
3935	switch (op)
3936	{
3937	case LBX_ADD:
3938	writeValue("add");
3939	break;
3940	case LBX_ADD_SIGNED:
3941	writeValue("add_signed");
3942	break;
3943	case LBX_ADD_SMOOTH:
3944	writeValue("add_smooth");
3945	break;
3946	case LBX_BLEND_CURRENT_ALPHA:
3947	writeValue("blend_current_alpha");
3948	break;
3949	case LBX_BLEND_DIFFUSE_COLOUR:
3950	writeValue("blend_diffuse_colour");
3951	break;
3952	case LBX_BLEND_DIFFUSE_ALPHA:
3953	writeValue("blend_diffuse_alpha");
3954	break;
3955	case LBX_BLEND_MANUAL:
3956	writeValue("blend_manual");
3957	break;
3958	case LBX_BLEND_TEXTURE_ALPHA:
3959	writeValue("blend_texture_alpha");
3960	break;
3961	case LBX_MODULATE:
3962	writeValue("modulate");
3963	break;
3964	case LBX_MODULATE_X2:
3965	writeValue("modulate_x2");
3966	break;
3967	case LBX_MODULATE_X4:
3968	writeValue("modulate_x4");
3969	break;
3970	case LBX_SOURCE1:
3971	writeValue("source1");
3972	break;
3973	case LBX_SOURCE2:
3974	writeValue("source2");
3975	break;
3976	case LBX_SUBTRACT:
3977	writeValue("subtract");
3978	break;
3979	case LBX_DOTPRODUCT:
3980	writeValue("dotproduct");
3981	break;
3982	}
3983	}
3984	//-----------------------------------------------------------------------
3985	void MaterialSerializer::writeLayerBlendSource(const LayerBlendSource lbs)
3986	{
3987	switch (lbs)
3988	{
3989	case LBS_CURRENT:
3990	writeValue("src_current");
3991	break;
3992	case LBS_DIFFUSE:
3993	writeValue("src_diffuse");
3994	break;
3995	case LBS_MANUAL:
3996	writeValue("src_manual");
3997	break;
3998	case LBS_SPECULAR:
3999	writeValue("src_specular");
4000	break;
4001	case LBS_TEXTURE:
4002	writeValue("src_texture");
4003	break;
4004	}
4005	}
4006
4007	// nfz
4008	//-----------------------------------------------------------------------
4009	void MaterialSerializer::writeVertexProgramRef(const Pass* pPass)
4010	{
4011	writeGpuProgramRef("vertex_program_ref",
4012	pPass->getVertexProgram(), pPass->getVertexProgramParameters());
4013	}
4014	//-----------------------------------------------------------------------
4015	void MaterialSerializer::writeShadowCasterVertexProgramRef(const Pass* pPass)
4016	{
4017	writeGpuProgramRef("shadow_caster_vertex_program_ref",
4018	pPass->getShadowCasterVertexProgram(), pPass->getShadowCasterVertexProgramParameters());
4019	}
4020	//-----------------------------------------------------------------------
4021	void MaterialSerializer::writeShadowReceiverVertexProgramRef(const Pass* pPass)
4022	{
4023	writeGpuProgramRef("shadow_receiver_vertex_program_ref",
4024	pPass->getShadowReceiverVertexProgram(), pPass->getShadowReceiverVertexProgramParameters());
4025	}
4026	//-----------------------------------------------------------------------
4027	void MaterialSerializer::writeShadowReceiverFragmentProgramRef(const Pass* pPass)
4028	{
4029	writeGpuProgramRef("shadow_receiver_fragment_program_ref",
4030	pPass->getShadowReceiverFragmentProgram(), pPass->getShadowReceiverFragmentProgramParameters());
4031	}
4032	//-----------------------------------------------------------------------
4033	void MaterialSerializer::writeFragmentProgramRef(const Pass* pPass)
4034	{
4035	writeGpuProgramRef("fragment_program_ref",
4036	pPass->getFragmentProgram(), pPass->getFragmentProgramParameters());
4037	}
4038	//-----------------------------------------------------------------------
4039	void MaterialSerializer::writeGpuProgramRef(const String& attrib,
4040	const GpuProgramPtr& program, const GpuProgramParametersSharedPtr& params)
4041	{
4042	mBuffer += "\n";
4043	writeAttribute(3, attrib);
4044	writeValue(program->getName());
4045	beginSection(3);
4046	{
4047	// write out paramters
4048	GpuProgramParameters* defaultParams= 0;
4049	// does the GPU program have default parameters?
4050	if (program->hasDefaultParameters())
4051	defaultParams = program->getDefaultParameters().getPointer();
4052
4053	writeGPUProgramParameters(params, defaultParams);
4054	}
4055	endSection(3);
4056
4057	// add to GpuProgram contatiner
4058	mGpuProgramDefinitionContainer.insert(program->getName());
4059	}
4060	//-----------------------------------------------------------------------
4061	static bool isConstantRealValsEqual(const GpuProgramParameters::RealConstantEntry* constEntry,
4062	const GpuProgramParameters::RealConstantEntry* defaultEntry, const size_t elementCount)
4063	{
4064	assert(constEntry && defaultEntry);
4065	// assume values are equal
4066	bool isEqual = false;
4067
4068	if (constEntry && defaultEntry)
4069	{
4070	// assume values are equal
4071	isEqual = true;
4072	size_t currentIndex = 0;
4073	// iterate through real constants
4074	while ((currentIndex < elementCount) && isEqual)
4075	{
4076	// compare the values within the constant entry
4077	size_t idx = 0;
4078	while ((idx < 4) && (currentIndex < elementCount) && isEqual)
4079	{
4080	if (constEntry->val[idx] != defaultEntry->val[idx])
4081	isEqual = false;
4082	++idx;
4083	++currentIndex;
4084	}
4085	++constEntry;
4086	++defaultEntry;
4087	}
4088
4089	}
4090
4091	return isEqual;
4092	}
4093
4094	//-----------------------------------------------------------------------
4095	static bool isConstantIntValsEqual(const GpuProgramParameters::IntConstantEntry* constEntry,
4096	const GpuProgramParameters::IntConstantEntry* defaultEntry, const size_t elementCount)
4097	{
4098	assert(constEntry && defaultEntry);
4099	// assume values are equal
4100	bool isEqual = false;
4101
4102	if (constEntry && defaultEntry)
4103	{
4104	// assume values are equal
4105	isEqual = true;
4106	size_t currentIndex = 0;
4107	// iterate through real constants
4108	while ((currentIndex < elementCount) && isEqual)
4109	{
4110	// compare the values within the constant entry
4111	size_t idx = 0;
4112	while ((idx < 4) && (currentIndex < elementCount) && isEqual)
4113	{
4114	if (constEntry->val[idx] != defaultEntry->val[idx])
4115	isEqual = false;
4116	++idx;
4117	++currentIndex;
4118	}
4119	++constEntry;
4120	++defaultEntry;
4121	}
4122
4123	}
4124
4125	return isEqual;
4126	}
4127
4128
4129	//-----------------------------------------------------------------------
4130	void MaterialSerializer::writeGPUProgramParameters(
4131	const GpuProgramParametersSharedPtr& params,
4132	GpuProgramParameters* defaultParams, const int level,
4133	const bool useMainBuffer)
4134	{
4135	// iterate through the constant definitions
4136	const size_t paramCount = params->getNumConstantDefinitions();
4137	size_t paramIndex = 0;
4138	while (paramIndex < paramCount)
4139	{
4140	// get the constant definition
4141	const GpuProgramParameters::ConstantDefinition* constDef =
4142	params->getConstantDefinition(paramIndex);
4143	// only output if the constant definition exists and its actually being used
4144	// assume its being used if elementCount > 0
4145	if (constDef && constDef->elementCount)
4146	{
4147	// don't duplicate constants that are defined as a default parameter
4148	bool defaultExist = false;
4149	if (defaultParams)
4150	{
4151	// find matching default parameter
4152	const GpuProgramParameters::ConstantDefinition* defaultConstDef =
4153	defaultParams->findMatchingConstantDefinition(
4154	constDef->name, constDef->entryIndex, constDef->elementType);
4155
4156	if (defaultConstDef)
4157	{
4158	// check all the elements for being equal
4159	// auto settings must be the same to be equal
4160	if ((defaultConstDef->isAuto && constDef->isAuto) &&
4161	(defaultConstDef->autoIndex == constDef->autoIndex))
4162	{
4163	defaultExist = true;
4164	}
4165	else // check the values
4166	{
4167	if (constDef->elementType == GpuProgramParameters::ET_REAL)
4168	{
4169	const GpuProgramParameters::RealConstantEntry* constEntry =
4170	params->getRealConstantEntry(constDef->entryIndex);
4171
4172	if (!constEntry)
4173	// no constant entry found so pretend default value exist and don't output anything
4174	defaultExist = true;
4175	else
4176	{
4177	const GpuProgramParameters::RealConstantEntry* defaultEntry =
4178	defaultParams->getRealConstantEntry(defaultConstDef->entryIndex);
4179	// compare current pass gpu parameter value with defualt entry parameter values
4180	// only ouput if they are different
4181	defaultExist = isConstantRealValsEqual(constEntry, defaultEntry, constDef->elementCount);
4182	}
4183	}
4184	else // dealing with int
4185	{
4186	const GpuProgramParameters::IntConstantEntry* constEntry =
4187	params->getIntConstantEntry(constDef->entryIndex);
4188
4189	if (!constEntry)
4190	// no constant entry found so pretend default value exist and don't output anything
4191	defaultExist = true;
4192	else
4193	{
4194	const GpuProgramParameters::IntConstantEntry* defaultEntry =
4195	defaultParams->getIntConstantEntry(defaultConstDef->entryIndex);
4196
4197	// compare current pass gpu parameter values with defualt entry parameter values
4198	// only ouput if they are different
4199	defaultExist = isConstantIntValsEqual(constEntry, defaultEntry, constDef->elementCount);
4200	}
4201	}
4202
4203	}
4204	}
4205
4206	}
4207
4208	if (!defaultExist)
4209	{
4210	String label;
4211	// is the param named
4212	if (!constDef->name.empty())
4213	label = "param_named";
4214	else
4215	label = "param_indexed";
4216	// is it auto
4217	if (constDef->isAuto)
4218	label += "_auto";
4219
4220	writeAttribute(level, label, useMainBuffer);
4221	// output param name or index
4222	if (!constDef->name.empty())
4223	writeValue(constDef->name, useMainBuffer);
4224	else
4225	writeValue(StringConverter::toString(constDef->entryIndex), useMainBuffer);
4226
4227	// if auto output auto type name and data if needed
4228	if (constDef->isAuto)
4229	{
4230	// get the auto constant entry associated with this constant definition
4231	const GpuProgramParameters::AutoConstantEntry* autoEntry =
4232	params->getAutoConstantEntry(constDef->autoIndex);
4233
4234	if (autoEntry)
4235	{
4236	const GpuProgramParameters::AutoConstantDefinition* autoConstDef =
4237	GpuProgramParameters::getAutoConstantDefinition(autoEntry->paramType);
4238
4239	assert(autoConstDef && "Bad auto constant Definition Table");
4240	// output auto constant name
4241	writeValue(autoConstDef->name, useMainBuffer);
4242	// output data if it uses it
4243	switch(autoConstDef->dataType)
4244	{
4245	case GpuProgramParameters::ACDT_REAL:
4246	writeValue(StringConverter::toString(autoEntry->fData), useMainBuffer);
4247	break;
4248
4249	case GpuProgramParameters::ACDT_INT:
4250	writeValue(StringConverter::toString(autoEntry->data), useMainBuffer);
4251	break;
4252	}
4253	}
4254	}
4255	else // not auto so output all the values used
4256	{
4257	String countLabel;
4258	const size_t elementCount = constDef->elementCount;
4259	// get starting index for constant
4260	size_t entryIndex = constDef->entryIndex;
4261	size_t currentIndex = 0;
4262
4263	// only write a number if > 1
4264	if (elementCount > 1)
4265	countLabel = StringConverter::toString(elementCount);
4266
4267	if (constDef->elementType == GpuProgramParameters::ET_REAL)
4268	{
4269	writeValue("float" + countLabel, useMainBuffer);
4270	// iterate through real constants
4271	while (currentIndex < elementCount)
4272	{
4273	// get the constant entry
4274	const GpuProgramParameters::RealConstantEntry* constEntry =
4275	params->getRealConstantEntry(entryIndex);
4276
4277	// output the values within the constant entry
4278	size_t idx = 0;
4279	while ((idx < 4) && (currentIndex < elementCount))
4280	{
4281	writeValue(StringConverter::toString(constEntry->val[idx]), useMainBuffer);
4282	++idx;
4283	++currentIndex;
4284	}
4285	++entryIndex;
4286	}
4287
4288	}
4289	else
4290	{
4291	writeValue("int" + countLabel, useMainBuffer);
4292	// iterate through int constants
4293	while (currentIndex < elementCount)
4294	{
4295	// get the constant entry
4296	const GpuProgramParameters::IntConstantEntry* constEntry =
4297	params->getIntConstantEntry(entryIndex + currentIndex);
4298
4299	// output the values within the constant entry
4300	size_t idx = 0;
4301	while ((idx < 4) && (currentIndex < elementCount))
4302	{
4303	writeValue(StringConverter::toString(constEntry->val[idx]), useMainBuffer);
4304	++idx;
4305	++currentIndex;
4306	}
4307	++entryIndex;
4308	}
4309
4310	}
4311	}
4312	} // end if (!defaultExist)
4313
4314	} // end if
4315
4316	++paramIndex;
4317
4318	} // end while
4319
4320	}
4321
4322	//-----------------------------------------------------------------------
4323	void MaterialSerializer::writeGpuPrograms(void)
4324	{
4325	// iterate through gpu program names in container
4326	GpuProgramDefIterator currentDef = mGpuProgramDefinitionContainer.begin();
4327	GpuProgramDefIterator endDef = mGpuProgramDefinitionContainer.end();
4328
4329	while (currentDef != endDef)
4330	{
4331	// get gpu program from gpu program manager
4332	GpuProgramPtr program = GpuProgramManager::getSingleton().getByName((*currentDef));
4333	// write gpu program definition type to buffer
4334	// check program type for vertex program
4335	// write program type
4336	mGpuProgramBuffer += "\n";
4337	writeAttribute(0, program->getParameter("type"), false);
4338
4339	// write program name
4340	writeValue( program->getName(), false);
4341	// write program language
4342	const String language = program->getLanguage();
4343	writeValue( language, false );
4344	// write opening braces
4345	beginSection(0, false);
4346	{
4347	// write program source + filenmae
4348	writeAttribute(1, "source", false);
4349	writeValue(program->getSourceFile(), false);
4350	// write special parameters based on language
4351	const ParameterList& params = program->getParameters();
4352	ParameterList::const_iterator currentParam = params.begin();
4353	ParameterList::const_iterator endParam = params.end();
4354
4355	while (currentParam != endParam)
4356	{
4357	if (currentParam->name != "type")
4358	{
4359	String paramstr = program->getParameter(currentParam->name);
4360	if ((currentParam->name == "includes_skeletal_animation")
4361	&& (paramstr == "false"))
4362	paramstr = "";
4363	if ((currentParam->name == "includes_morph_animation")
4364	&& (paramstr == "false"))
4365	paramstr = "";
4366
4367	if ((language != "asm") && (currentParam->name == "syntax"))
4368	paramstr = "";
4369
4370	if (!paramstr.empty())
4371	{
4372	writeAttribute(1, currentParam->name, false);
4373	writeValue(paramstr, false);
4374	}
4375	}
4376	++currentParam;
4377	}
4378
4379	// write default parameters
4380	if (program->hasDefaultParameters())
4381	{
4382	mGpuProgramBuffer += "\n";
4383	GpuProgramParametersSharedPtr gpuDefaultParams = program->getDefaultParameters();
4384	writeAttribute(1, "default_params", false);
4385	beginSection(1, false);
4386	writeGPUProgramParameters(gpuDefaultParams, 0, 2, false);
4387	endSection(1, false);
4388	}
4389	}
4390	// write closing braces
4391	endSection(0, false);
4392
4393	++currentDef;
4394
4395	}
4396
4397	mGpuProgramBuffer += "\n";
4398	}
4399
4400	}

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

Context Navigation

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

Download in other formats: