Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/OgreMain/src/OgreMaterialScriptCompiler.cpp @ 1

Last change on this file since 1 was 1, checked in by landauf, 17 years ago

File size: 125.5 KB

Rev	Line
[1]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://www.ogre3d.org
	6
	7	Copyright (c) 2000-2006 Torus Knot Software Ltd
	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	You may alternatively use this source under the terms of a specific version of
	25	the OGRE Unrestricted License provided you have obtained such a license from
	26	Torus Knot Software Ltd.
	27	-----------------------------------------------------------------------------
	28	*/
	29	#include "OgreStableHeaders.h"
	30	#include "OgreMaterialScriptCompiler.h"
	31	#include "OgreStringConverter.h"
	32	#include "OgreLogManager.h"
	33	#include "OgreException.h"
	34	#include "OgreBlendMode.h"
	35	#include "OgreGpuProgram.h"
	36	#include "OgreTechnique.h"
	37	#include "OgrePass.h"
	38	#include "OgreMaterialManager.h"
	39	#include "OgreGpuProgramManager.h"
	40	#include "OgreHighLevelGpuProgramManager.h"
	41	#include "OgreExternalTextureSourceManager.h"
	42
	43	namespace Ogre {
	44
	45	//-----------------------------------------------------------------------
	46	// Static definitions
	47	//-----------------------------------------------------------------------
	48	MaterialScriptCompiler::TokenActionMap MaterialScriptCompiler::mTokenActionMap;
	49
	50	//-----------------------------------------------------------------------
	51	const String& MaterialScriptCompiler::getClientBNFGrammer(void) const
	52	{
	53	// simplified Backus - Naur Form (BNF) grammer for material scripts
	54	static const String materialScript_BNF =
	55	"<Script> ::= {<Script_Properties>} \n"
	56
	57	"<Script_Properties> ::= <Material> \| <Vertex_Program> \| <Fragment_Program> \n"
	58
	59	"<Material> ::= 'material' <Flex_Label> [<Material_Clone>] '{' {<Material_Properties>} '}' \n"
	60
	61	"<Material_Properties> ::= <Technique> \| <Set_Texture_Alias> \| "
	62	" <Lod_Distances> \| <Receive_Shadows> \| "
	63	" <Transparency_Casts_Shadows> \n"
	64
	65	" <Material_Clone> ::= ':' <Flex_Label> \n"
	66	" <Set_Texture_Alias> ::= 'set_texture_alias' <Label> [<Seperator>] <Label> \n"
	67	" <Lod_Distances> ::= 'lod_distances' <#distance> {<#distance>} \n"
	68	" <Receive_Shadows> ::= 'receive_shadows' <On_Off> \n"
	69	" <Transparency_Casts_Shadows> ::= 'transparency_casts_shadows' <On_Off> \n"
	70
	71	// Technique section rules
	72	"<Technique> ::= 'technique' [<Label>] '{' {<Technique_Properties>} '}' \n"
	73	" <Technique_Properties> ::= <Pass> \| <Lod_Index> \| <Scheme> \n"
	74	" <Lod_Index> ::= 'lod_index' <#value> \n"
	75	" <Scheme> ::= 'scheme' <Label> \n"
	76
	77	// Pass section rules
	78	" <Pass> ::= 'pass' [<Label>] '{' {<Pass_Properties>} '}' \n"
	79	" <Pass_Properties> ::= <Ambient> \| <Diffuse> \| <Specular> \| <Emissive> \| \n"
	80	" <Scene_Blend> \| <Depth_Check> \| <Depth_Write> \| \n"
	81	" <Texture_Unit> \| \n"
	82	" <Depth_Func> \| <Depth_Bias> \| <Alpha_Rejection> \| \n"
	83	" <Cull_Hardware> \| <Cull_Software> \| <Lighting> \| \n"
	84	" <GPU_Program_Ref> \| \n"
	85	" <Shading> \| <PolygonMode> \| <Fog_Override> \| <Colour_Write> \| \n"
	86	" <Max_Lights> \| <Start_Light> \| <Iteration> \| \n"
	87	" <Point_Sprites> \| <Point_Size_Attenuation> \| \n"
	88	" <Point_Size_Min> \| <Point_Size_Max> \| <Point_Size> \n"
	89
	90	" <Ambient> ::= 'ambient' <ColourOptions> \n"
	91	" <Diffuse> ::= 'diffuse' <ColourOptions> \n"
	92	" <Specular> ::= 'specular' <SpecularOptions> \n"
	93	" <SpecularOptions> ::= <Specular_Colour_Params> \| <Specular_Vertex> \n"
	94	" <Specular_Colour_Params> ::= <#red> <#green> <#blue> <#val> [<#val>] \n"
	95	" <Specular_Vertex> ::= 'vertexcolour' <#shininess> \n"
	96	" <Emissive> ::= 'emissive' <ColourOptions> \n"
	97
	98	" <ColourOptions> ::= <Colour_Params> \| 'vertexcolour' \n"
	99
	100	" <Scene_Blend> ::= 'scene_blend' <SceneBlend_Options> \n"
	101	" <SceneBlend_Options> ::= <Simple_Blend> \| <User_Blend> \n"
	102	" <Simple_Blend> ::= <Base_Blend> \| 'colour_blend' \n"
	103	" <Base_Blend> ::= 'alpha_blend' \| 'modulate' \| 'add' \n"
	104	" <User_Blend> ::= <Blend_Factor> <Blend_Factor> \n"
	105	" <Blend_Factor> ::= 'dest_colour' \| 'src_colour' \| \n"
	106	" 'one_minus_dest_colour' \| 'one_minus_src_colour' \| \n"
	107	" 'dest_alpha' \| 'src_alpha' \| 'one_minus_dest_alpha' \| \n"
	108	" 'one_minus_src_alpha' \| 'one' \| 'zero' \n"
	109
	110	" <Depth_Check> ::= 'depth_check' <On_Off> \n"
	111	" <Depth_Write> ::= 'depth_write' <On_Off> \n"
	112	" <Depth_Func> ::= 'depth_func' <Compare_Func> \n"
	113	" <Depth_Bias> ::= 'depth_bias' <#constant> [<#slopescale>] \n"
	114	" <Alpha_Rejection> ::= 'alpha_rejection' <Compare_Func> <#value> \n"
	115	" <Compare_Func> ::= 'always_fail' \| 'always_pass' \| 'less_equal' \| 'less' \| \n"
	116	" 'equal' \| 'not_equal' \| 'greater_equal' \| 'greater' \n"
	117	" <Cull_Hardware> ::= 'cull_hardware' <Cull_Hardware_Otions> \n"
	118	" <Cull_Hardware_Otions> ::= 'clockwise' \| 'anticlockwise' \| 'none' \n"
	119	" <Cull_Software> ::= 'cull_software' <Cull_Software_Otions> \n"
	120	" <Cull_Software_Otions> ::= 'back' \| 'front' \| 'none' \n"
	121	" <Lighting> ::= 'lighting' <On_Off> \n"
	122	" <Shading> ::= 'shading' <Shading_Options> \n"
	123	" <Shading_Options> ::= 'flat' \| 'gouraud' \| 'phong' \n"
	124	" <PolygonMode> ::= 'polygon_mode' <PolygonMode_Options> \n"
	125	" <PolygonMode_Options> ::= 'solid' \| 'wireframe' \| 'points' \n"
	126	" <Colour_Write> ::= 'colour_write' <On_Off> \n"
	127	" <Point_Size> ::= 'point_size' <#size> \n"
	128	" <Point_Sprites> ::= 'point_sprites' <On_Off> \n"
	129	" <Point_Size_Min> ::= 'point_size_min' <#size> \n"
	130	" <Point_Size_Max> ::= 'point_size_max' <#size> \n"
	131	" <Point_Size_Attenuation> ::= 'point_size_attenuation' <On_Off> [<Point_Size_Att_Params>] \n"
	132	" <Point_Size_Att_Params> ::= <#constant> <#linear> <#quadric> \n"
	133	" <Fog_Override> ::= 'fog_override' <Fog_Override_Options> \n"
	134	" <Fog_Override_Options> ::= 'false' \| <fog_true> \n"
	135	" <fog_true> ::= 'true' [<Fog_True_Params>] \n"
	136	" <Fog_True_Params> ::= 'none' \| <fog_True_Param_Option> \n"
	137	" <fog_True_Param_Option> ::= <fog_type> <#red> <#green> <#blue> <#fog_density> <#start> <#end> \n"
	138	" <fog_type> ::= 'linear' \| 'exp2' \| 'exp' \n"
	139	" <Max_Lights> ::= 'max_lights' <#number> \n"
	140	" <Start_Light> ::= 'start_light' <#number> \n"
	141	" <Iteration> ::= 'iteration' <Iteration_Options> \n"
	142	" <Iteration_Options> ::= <Iteration_Once_Params> \| 'once' \| <Iteration_Counted> \n"
	143	" <Iteration_Once_Params> ::= 'once_per_light' [<light_type>] \n"
	144	" <Iteration_Counted> ::= <#number> [<Per_Light_Options>] \n"
	145	" <Per_Light_Options> ::= <Per_Light> \| <Per_N_Lights> \n"
	146	" <Per_Light> ::= 'per_light' [<light_type>] \n"
	147	" <Per_N_Lights> ::= 'per_n_lights' <#num_lights> [<light_type>] \n"
	148	" <light_type> ::= 'point' \| 'directional' \| 'spot' \n"
	149	// Texture Unit section rules
	150	" <Texture_Unit> ::= 'texture_unit' [<Label>] '{' {<TUS_Properties>} '}' \n"
	151	" <TUS_Properties> ::= <Texture_Alias> \| <Texture> \| <Anim_Texture> \| <Cubic_Texture> \| \n"
	152	" <Tex_Coord_Set> \| <Tex_Address_Mode> \| <Tex_Border_Colour> \| <Filtering> \| \n"
	153	" <Max_Anisotropy> \| <MipMap_Bias> \| <Colour_Op_Ex> \| <Colour_Op_Multipass_Fallback> \| <Colour_Op> \| \n"
	154	" <Alpha_Op_Ex> \| <Env_Map> \| <Scroll_Anim> \| <Scroll> \| <Rotate_Anim> \| <Rotate> \| \n"
	155	" <Scale> \| <Wave_Xform> \| <Transform> \| <Binding_Type> \| <Content_Type> \n"
	156	" <Texture_Alias> ::= 'texture_alias' <Label> \n"
	157	" <Texture> ::= 'texture' <Label> {<Texture_Properties>} \n"
	158	" <Texture_Properties> ::= '1d' \| '2d' \| '3d' \| 'cubic' \| 'unlimited' \| 'alpha' \| <#mipmap> \n"
	159	" \| " + PixelUtil::getBNFExpressionOfPixelFormats(true) + " \n"
	160	" <Anim_Texture> ::= 'anim_texture' <Label> <Anim_Texture_Properties> \n"
	161	" <Anim_Texture_Properties> ::= <Numbered_Anim_Texture> \| <Seperate_Anim_Textures> \n"
	162	" <Numbered_Anim_Texture> ::= <#frames> <#duration> \n"
	163	" <Seperate_Anim_Textures> ::= <anim_frame> {<anim_frame>} \n"
	164	" <anim_frame> ::= (?!<TUS_Terminators>) <Label> [<Seperator>] \n"
	165	" <TUS_Terminators> ::= '}' \| 'texture_alias' \| 'texture' \| 'anim_texture' \| 'cubic_texture' \| \n"
	166	" 'tex_coord_set' \| 'tex_address_mode' \| 'tex_border_colour' \| \n"
	167	" 'filtering' \| 'max_anisotropy' \| 'mipmap_bias' \| 'colour_op' \| 'colour_op_ex' \| \n"
	168	" 'colour_op_multipass_fallback' \| 'alpha_op_ex' \| 'env_map' \| \n"
	169	" 'scroll' \| 'rotate' \| 'scale' \| 'wave_xform' \| 'transform' \| 'binding_type' \n"
	170	" <Cubic_Texture> ::= 'cubic_texture' <Label> <Cubic_Texture_Options> \n"
	171	" <Cubic_Texture_Options> ::= 'combineduvw' \| 'separateuv' \| <Cubic_Seperate> \n"
	172	" <Cubic_Seperate> ::= <Label> [<Seperator>] <Label> [<Seperator>] <Label> \n"
	173	" [<Seperator>] <Label> [<Seperator>] <Label> 'separateuv' \n"
	174	" <Tex_Coord_Set> ::= 'tex_coord_set' <#set_num> \n"
	175	" <Tex_Address_Mode> ::= 'tex_address_mode' <UVW_Mode> [<UVW_Mode>] [<UVW_Mode>] \n"
	176	" <UVW_Mode> ::= 'wrap' \| 'clamp' \| 'mirror' \| 'border' \n"
	177	" <Tex_Border_Colour> ::= 'tex_border_colour' <Colour_Params> \n"
	178	" <Filtering> ::= 'filtering' <Filtering_Options>"
	179	" <Filtering_Options> ::= <Simple_Filter> \| <Complex_Filter> \n"
	180	" <Simple_Filter> ::= 'bilinear' \| 'trilinear' \| 'anisotropic' \| 'none' \n"
	181	" <Complex_Filter> ::= <MinMagFilter> <MinMagFilter> <MipFilter> \n"
	182	" <MinMagFilter> ::= 'linear' \| 'point' \| 'anisotropic' \n"
	183	" <MipFilter> ::= 'linear' \| 'point' \| 'none' \n"
	184	" <Max_Anisotropy> ::= 'max_anisotropy' <#val> \n"
	185	" <MipMap_Bias> ::= 'mipmap_bias' <#val> \n"
	186	" <Colour_Op> ::= 'colour_op' <Colour_Op_Options> \n"
	187	" <Colour_Op_Options> ::= <Base_Blend> \| 'replace' \n"
	188	" <Colour_Op_Ex> ::= 'colour_op_ex' <Combine_Operation> <Source_Option> <Source_Option> {<#val>} \n"
	189	" <Combine_Operation> ::= 'source1' \| 'source2' \| 'modulate_x2' \| 'modulate_x4' \| \n"
	190	" 'modulate' \| 'add_signed' \| 'add_smooth' \| 'add' \| \n"
	191	" 'subtract' \| 'blend_diffuse_alpha' \| 'blend_texture_alpha' \| \n"
	192	" 'blend_current_alpha' \| 'blend_manual' \| 'dotproduct' \| \n"
	193	" 'blend_diffuse_colour' \n"
	194	" <Source_Option> ::= 'src_current' \| 'src_texture' \| 'src_diffuse' \| \n"
	195	" 'src_specular' \| 'src_manual' \n"
	196	" <Colour_Op_Multipass_Fallback> ::= 'colour_op_multipass_fallback' <Blend_Factor> <Blend_Factor> \n"
	197	" <Alpha_Op_Ex> ::= 'alpha_op_ex' <Combine_Operation> <Source_Option> <Source_Option> {<#val>} \n"
	198	" <Env_Map> ::= 'env_map' <Env_Map_Option> \n"
	199	" <Env_Map_Option> ::= 'spherical' \| 'planar' \| 'cubic_reflection' \| 'cubic_normal' \| 'off' \n"
	200	" <Scroll> ::= 'scroll' <#x> <#y> \n"
	201	" <Scroll_Anim> ::= 'scroll_anim' <#xspeed> <#yspeed> \n"
	202	" <Rotate> ::= 'rotate' <#angle> \n"
	203	" <Rotate_Anim> ::= 'rotate_anim' <#revs_per_second> \n"
	204	" <Scale> ::= 'scale' <#x> <#y> \n"
	205	" <Wave_Xform> ::= 'wave_xform' <Xform_Type> <Wave_Type> <#base> <#frequency> <#phase> <#amplitude> \n"
	206	" <Xform_Type> ::= 'scroll_x' \| 'scroll_y' \| 'rotate' \| 'scale_x' \| 'scale_y' \n"
	207	" <Wave_Type> ::= 'sine' \| 'triangle' \| 'square' \| 'sawtooth' \| 'inverse_sawtooth' \n"
	208	" <Transform> ::= 'transform' <#m00> <#m01> <#m02> <#m03> <#m10> <#m11> <#m12> <#m13> <#m20> <#m21> <#m22> <#m23> \n"
	209	" <#m30> <#m31> <#m32> <#m33> \n"
	210	" <Binding_Type> ::= 'binding_type' <Program_Type_Options> \n"
	211	" <Program_Type_Options> ::= 'vertex' \| 'fragment' \n"
	212	" <Content_Type> ::= 'content_type' <Content_Type_Options> \n"
	213	" <Content_Type_Options> ::= 'named' \| 'shadow' \n"
	214	// GPU Programs
	215	" \n"
	216	"<Vertex_Program> ::= 'vertex_program' <Label> [<Seperator>] <Label> '{' {<Vertex_Program_Option>} '}' \n"
	217	" <Vertex_Program_Option> ::= <Vertex_Program_Animation> \| <Vertex_Texture_Fetch> \| <GPU_Program_Options> \n"
	218	" <Vertex_Program_Animation> ::= <Skeletal_Animation> \| <Morph_Animation> \| <Pose_Animation> \n"
	219	" <Skeletal_Animation> ::= 'includes_skeletal_animation' <True_False> \n"
	220	" <Morph_Animation> ::= 'includes_morph_animation' <True_False> \n"
	221	" <Pose_Animation> ::= 'includes_pose_animation' <#val> \n"
	222	" <Vertex_Texture_Fetch> ::= 'uses_vertex_texture_fetch' <True_False> \n"
	223	"<Fragment_Program> ::= 'fragment_program' <Label> [<Seperator>] <Label> '{' {<GPU_Program_Options>}'}' \n"
	224	// do custom parameters last since it will consume everything on the line in the source
	225	" <GPU_Program_Options> ::= <Program_Source> \| <Syntax> \| <Default_Params> \| <Custom_Parameter> \n"
	226	" <Program_Source> ::= 'source' <Label> \n"
	227	" <Syntax> ::= 'syntax' <Label> \n"
	228	" <Default_Params> ::= 'default_params' '{' {<GPUParams_Option>} '}' \n"
	229	" <Custom_Parameter> ::= 'custom_parameter' : <Unquoted_Label> [<Seperator>] <Spaced_Label> \n"
	230
	231	" <GPU_Program_Ref> ::= <GPU_Program_Ref_Type> [<Flex_Label>] '{' {<GPUParams_Option>} '}' \n"
	232	" <GPU_Program_Ref_Type> ::= 'vertex_program_ref' \| 'fragment_program_ref' \| \n"
	233	" 'shadow_caster_vertex_program_ref' \| \n"
	234	" 'shadow_receiver_vertex_program_ref' \| \n"
	235	" 'shadow_receiver_fragment_program_ref' \n"
	236
	237	" <GPUParams_Option> ::= <Param_Named_Auto> \| <Param_Named> \| <Param_Indexed_Auto> \| <Param_Indexed> \n"
	238	" <Param_Named_Auto> ::= 'param_named_auto' <Unquoted_Label> [<Seperator>] <Unquoted_Label> [<#val>] \n"
	239	" <Param_Named> ::= 'param_named' <Unquoted_Label> [<Seperator>] <Param_Value_Option> \n"
	240	" <Param_Indexed_Auto> ::= 'param_indexed_auto' <#index> <Unquoted_Label> [<#val>] \n"
	241	" <Param_Indexed> ::= 'param_indexed' <#index> <Param_Value_Option> \n"
	242	" <Param_Value_Option> ::= <Unquoted_Label> {<#val>} \n"
	243
	244	// common rules
	245	"<On_Off> ::= 'on' \| 'off' \n"
	246	"<True_False> ::= 'true' \| 'false' \n"
	247	"<Colour_Params> ::= <#red> <#green> <#blue> [<#alpha>] \n"
	248	"<Seperator> ::= -' ' \n"
	249
	250	"<Labels_1_N> ::= <Label> [<Seperator>] {<More_Labels>} \n"
	251	"<More_Labels> ::= <Label> [<Seperator>] \n"
	252	"<Label> ::= <Quoted_Label> \| <Unquoted_Label> \n"
	253	"<Flex_Label> ::= <Quoted_Label> \| <Spaced_Label> \n"
	254	"<Quoted_Label> ::= -'\"' <Spaced_Label> -'\"' \n"
	255	"<Spaced_Label> ::= <Spaced_Label_Illegals> {<Spaced_Label_Illegals>} \n"
	256	"<Unquoted_Label> ::= <Unquoted_Label_Illegals> {<Unquoted_Label_Illegals>} \n"
	257	"<Spaced_Label_Illegals> ::= (!,:\n\r\t{}\") \n"
	258	"<Unquoted_Label_Illegals> ::= (! :\n\r\t{}\") \n"
	259
	260	;
	261
	262	return materialScript_BNF;
	263	}
	264	//-----------------------------------------------------------------------
	265	const String& MaterialScriptCompiler::getClientGrammerName(void) const
	266	{
	267	static const String grammerName = "Material Script";
	268	return grammerName;
	269	}
	270	//-----------------------------------------------------------------------
	271	MaterialScriptCompiler::MaterialScriptCompiler(void)
	272	{
	273	// set default group resource name
	274	mScriptContext.groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME;
	275	}
	276	//-----------------------------------------------------------------------
	277	MaterialScriptCompiler::~MaterialScriptCompiler(void)
	278	{
	279
	280	}
	281
	282	//-----------------------------------------------------------------------
	283	void MaterialScriptCompiler::parseScript(DataStreamPtr& stream, const String& groupName, const bool allowOverride)
	284	{
	285	mScriptContext.groupName = groupName;
	286	mScriptContext.allowOverride = allowOverride;
	287	Compiler2Pass::compile(stream->getAsString(), stream->getName());
	288	}
	289
	290	//-----------------------------------------------------------------------
	291	void MaterialScriptCompiler::setupTokenDefinitions(void)
	292	{
	293	addLexemeAction("{", &MaterialScriptCompiler::parseOpenBrace);
	294	addLexemeAction("}", &MaterialScriptCompiler::parseCloseBrace);
	295	addLexemeTokenAction("vertex_program", ID_VERTEX_PROGRAM, &MaterialScriptCompiler::parseGPUProgram);
	296	addLexemeAction("includes_skeletal_animation", &MaterialScriptCompiler::parseProgramSkeletalAnimation);
	297	addLexemeAction("includes_morph_animation", &MaterialScriptCompiler::parseProgramMorphAnimation);
	298	addLexemeAction("includes_pose_animation", &MaterialScriptCompiler::parseProgramPoseAnimation);
	299	addLexemeAction("uses_vertex_texture_fetch", &MaterialScriptCompiler::parseProgramVertexTextureFetch);
	300
	301	addLexemeTokenAction("fragment_program", ID_FRAGMENT_PROGRAM, &MaterialScriptCompiler::parseGPUProgram);
	302
	303	addLexemeAction("source", &MaterialScriptCompiler::parseProgramSource);
	304	addLexemeAction("syntax", &MaterialScriptCompiler::parseProgramSyntax);
	305	addLexemeAction("default_params", &MaterialScriptCompiler::parseDefaultParams);
	306	addLexemeAction("param_indexed", &MaterialScriptCompiler::parseParamIndexed);
	307	addLexemeAction("param_indexed_auto", &MaterialScriptCompiler::parseParamIndexedAuto);
	308	addLexemeAction("param_named", &MaterialScriptCompiler::parseParamNamed);
	309	addLexemeAction("param_named_auto", &MaterialScriptCompiler::parseParamNamedAuto);
	310	addLexemeAction("custom_parameter", &MaterialScriptCompiler::parseProgramCustomParameter);
	311
	312	addLexemeAction("material", &MaterialScriptCompiler::parseMaterial);
	313	addLexemeToken(":", ID_CLONE);
	314	addLexemeAction("lod_distances", &MaterialScriptCompiler::parseLodDistances);
	315	addLexemeAction("receive_shadows", &MaterialScriptCompiler::parseReceiveShadows);
	316	addLexemeAction("transparency_casts_shadows", &MaterialScriptCompiler::parseTransparencyCastsShadows);
	317	addLexemeAction("set_texture_alias", &MaterialScriptCompiler::parseSetTextureAlias);
	318
	319	// Technique section
	320	addLexemeAction("technique", &MaterialScriptCompiler::parseTechnique);
	321	addLexemeAction("scheme", &MaterialScriptCompiler::parseScheme);
	322	addLexemeAction("lod_index", &MaterialScriptCompiler::parseLodIndex);
	323
	324
	325	// Pass section
	326	addLexemeAction("pass", &MaterialScriptCompiler::parsePass);
	327	addLexemeAction("ambient", &MaterialScriptCompiler::parseAmbient);
	328	addLexemeAction("diffuse", &MaterialScriptCompiler::parseDiffuse);
	329	addLexemeAction("specular", &MaterialScriptCompiler::parseSpecular);
	330	addLexemeAction("emissive", &MaterialScriptCompiler::parseEmissive);
	331	addLexemeToken("vertexcolour", ID_VERTEXCOLOUR);
	332
	333	addLexemeAction("scene_blend", &MaterialScriptCompiler::parseSceneBlend);
	334	addLexemeToken("colour_blend", ID_COLOUR_BLEND);
	335	addLexemeToken("dest_colour", ID_DEST_COLOUR);
	336	addLexemeToken("src_colour", ID_SRC_COLOUR);
	337	addLexemeToken("one_minus_dest_colour", ID_ONE_MINUS_DEST_COLOUR);
	338	addLexemeToken("one_minus_src_colour", ID_ONE_MINUS_SRC_COLOUR);
	339	addLexemeToken("dest_alpha", ID_DEST_ALPHA);
	340	addLexemeToken("src_alpha", ID_SRC_ALPHA);
	341	addLexemeToken("one_minus_dest_alpha", ID_ONE_MINUS_DEST_ALPHA);
	342	addLexemeToken("one_minus_src_alpha", ID_ONE_MINUS_SRC_ALPHA);
	343
	344	addLexemeAction("depth_check", &MaterialScriptCompiler::parseDepthCheck);
	345	addLexemeAction("depth_write", &MaterialScriptCompiler::parseDepthWrite);
	346	addLexemeAction("depth_func", &MaterialScriptCompiler::parseDepthFunc);
	347	addLexemeAction("depth_bias", &MaterialScriptCompiler::parseDepthBias);
	348	addLexemeToken("always_fail", ID_ALWAYS_FAIL);
	349	addLexemeToken("always_pass", ID_ALWAYS_PASS);
	350	addLexemeToken("less_equal", ID_LESS_EQUAL);
	351	addLexemeToken("less", ID_LESS);
	352	addLexemeToken("equal", ID_EQUAL);
	353	addLexemeToken("not_equal", ID_NOT_EQUAL);
	354	addLexemeToken("greater_equal", ID_GREATER_EQUAL);
	355	addLexemeToken("greater", ID_GREATER);
	356	addLexemeAction("alpha_rejection", &MaterialScriptCompiler::parseAlphaRejection);
	357	addLexemeAction("cull_hardware", &MaterialScriptCompiler::parseCullHardware);
	358	addLexemeToken("clockwise", ID_CLOCKWISE);
	359	addLexemeToken("anticlockwise", ID_ANTICLOCKWISE);
	360	addLexemeAction("cull_software", &MaterialScriptCompiler::parseCullSoftware);
	361	addLexemeToken("back", ID_CULL_BACK);
	362	addLexemeToken("front", ID_CULL_FRONT);
	363	addLexemeAction("lighting", &MaterialScriptCompiler::parseLighting);
	364	addLexemeAction("shading", &MaterialScriptCompiler::parseShading);
	365	addLexemeTokenAction("flat", ID_FLAT);
	366	addLexemeToken("gouraud", ID_GOURAUD);
	367	addLexemeToken("phong", ID_PHONG);
	368	addLexemeAction("polygon_mode", &MaterialScriptCompiler::parsePolygonMode);
	369	addLexemeTokenAction("solid", ID_SOLID);
	370	addLexemeToken("wireframe", ID_WIREFRAME);
	371	addLexemeToken("points", ID_POINTS);
	372	addLexemeAction("fog_override", &MaterialScriptCompiler::parseFogOverride);
	373	addLexemeToken("exp", ID_EXP);
	374	addLexemeToken("exp2", ID_EXP2);
	375	addLexemeAction("colour_write", &MaterialScriptCompiler::parseColourWrite);
	376	addLexemeAction("max_lights", &MaterialScriptCompiler::parseMaxLights);
	377	addLexemeAction("start_light", &MaterialScriptCompiler::parseStartLight);
	378	addLexemeAction("iteration", &MaterialScriptCompiler::parseIteration);
	379	addLexemeToken("once", ID_ONCE);
	380	addLexemeToken("once_per_light", ID_ONCE_PER_LIGHT);
	381	addLexemeToken("per_light", ID_PER_LIGHT);
	382	addLexemeToken("per_n_lights", ID_PER_N_LIGHTS);
	383	addLexemeToken("directional", ID_DIRECTIONAL);
	384	addLexemeToken("spot", ID_SPOT);
	385	addLexemeAction("point_size", &MaterialScriptCompiler::parsePointSize);
	386	addLexemeAction("point_sprites", &MaterialScriptCompiler::parsePointSprites);
	387	addLexemeAction("point_size_attenuation", &MaterialScriptCompiler::parsePointSizeAttenuation);
	388	addLexemeAction("point_size_min", &MaterialScriptCompiler::parsePointSizeMin);
	389	addLexemeAction("point_size_max", &MaterialScriptCompiler::parsePointSizeMax);
	390
	391	// Texture Unit section
	392	addLexemeAction("texture_unit", &MaterialScriptCompiler::parseTextureUnit);
	393	addLexemeAction("texture_alias", &MaterialScriptCompiler::parseTextureAlias);
	394	addLexemeAction("texture", &MaterialScriptCompiler::parseTexture);
	395	addLexemeToken("1d", ID_1D);
	396	addLexemeToken("2d", ID_2D);
	397	addLexemeToken("3d", ID_3D);
	398	addLexemeToken("cubic", ID_CUBIC);
	399	addLexemeToken("unlimited", ID_UNLIMITED);
	400	addLexemeToken("alpha", ID_ALPHA);
	401	addLexemeAction("anim_texture", &MaterialScriptCompiler::parseAnimTexture);
	402	addLexemeAction("cubic_texture", &MaterialScriptCompiler::parseCubicTexture);
	403	addLexemeToken("separateuv", ID_SEPARATE_UV);
	404	addLexemeToken("combineduvw", ID_COMBINED_UVW);
	405	addLexemeAction("tex_coord_set", &MaterialScriptCompiler::parseTexCoord);
	406	addLexemeAction("tex_address_mode", &MaterialScriptCompiler::parseTexAddressMode);
	407	addLexemeToken("wrap", ID_WRAP);
	408	addLexemeToken("clamp", ID_CLAMP);
	409	addLexemeToken("mirror", ID_MIRROR);
	410	addLexemeToken("border", ID_BORDER);
	411	addLexemeAction("tex_border_colour", &MaterialScriptCompiler::parseTexBorderColour);
	412	addLexemeAction("filtering", &MaterialScriptCompiler::parseFiltering);
	413	addLexemeToken("bilinear", ID_BILINEAR);
	414	addLexemeToken("trilinear", ID_TRILINEAR);
	415	addLexemeToken("anisotropic", ID_ANISOTROPIC);
	416	addLexemeAction("max_anisotropy", &MaterialScriptCompiler::parseMaxAnisotropy);
	417	addLexemeAction("mipmap_bias", &MaterialScriptCompiler::parseMipMapBias);
	418	addLexemeAction("colour_op", &MaterialScriptCompiler::parseColourOp);
	419	addLexemeToken("replace", ID_REPLACE);
	420	addLexemeAction("colour_op_ex", &MaterialScriptCompiler::parseColourOpEx);
	421	addLexemeToken("source1", ID_SOURCE1);
	422	addLexemeToken("source2", ID_SOURCE2);
	423	addLexemeToken("modulate_x2", ID_MODULATE_X2);
	424	addLexemeToken("modulate_x4", ID_MODULATE_X4);
	425	addLexemeToken("add_signed", ID_ADD_SIGNED);
	426	addLexemeToken("add_smooth", ID_ADD_SMOOTH);
	427	addLexemeToken("subtract", ID_SUBTRACT);
	428	addLexemeToken("blend_diffuse_colour", ID_BLEND_DIFFUSE_COLOUR);
	429	addLexemeToken("blend_diffuse_alpha", ID_BLEND_DIFFUSE_ALPHA);
	430	addLexemeToken("blend_texture_alpha", ID_BLEND_TEXTURE_ALPHA);
	431	addLexemeToken("blend_current_alpha", ID_BLEND_CURRENT_ALPHA);
	432	addLexemeToken("blend_manual", ID_BLEND_MANUAL);
	433	addLexemeToken("dotproduct", ID_DOTPRODUCT);
	434	addLexemeToken("src_current", ID_SRC_CURRENT);
	435	addLexemeToken("src_texture", ID_SRC_TEXTURE);
	436	addLexemeToken("src_diffuse", ID_SRC_DIFFUSE);
	437	addLexemeToken("src_specular", ID_SRC_SPECULAR);
	438	addLexemeToken("src_manual", ID_SRC_MANUAL);
	439	addLexemeAction("colour_op_multipass_fallback", &MaterialScriptCompiler::parseColourOpMultipassFallback);
	440	addLexemeAction("alpha_op_ex", &MaterialScriptCompiler::parseAlphaOpEx);
	441	addLexemeAction("env_map", &MaterialScriptCompiler::parseEnvMap);
	442	addLexemeToken("spherical", ID_SPHERICAL);
	443	addLexemeToken("planar", ID_PLANAR);
	444	addLexemeToken("cubic_reflection", ID_CUBIC_REFLECTION);
	445	addLexemeToken("cubic_normal", ID_CUBIC_NORMAL);
	446	addLexemeAction("scroll", &MaterialScriptCompiler::parseScroll);
	447	addLexemeAction("scroll_anim", &MaterialScriptCompiler::parseScrollAnim);
	448	addLexemeTokenAction("rotate", ID_ROTATE, &MaterialScriptCompiler::parseRotate);
	449	addLexemeAction("rotate_anim", &MaterialScriptCompiler::parseRotateAnim);
	450	addLexemeAction("scale", &MaterialScriptCompiler::parseScale);
	451	addLexemeAction("wave_xform", &MaterialScriptCompiler::parseWaveXform);
	452	addLexemeToken("scroll_x", ID_SCROLL_X);
	453	addLexemeToken("scroll_y", ID_SCROLL_Y);
	454	addLexemeToken("scale_x", ID_SCALE_X);
	455	addLexemeToken("scale_y", ID_SCALE_Y);
	456	addLexemeToken("sine", ID_SINE);
	457	addLexemeToken("triangle", ID_TRIANGLE);
	458	addLexemeToken("square", ID_SQUARE);
	459	addLexemeToken("sawtooth", ID_SAWTOOTH);
	460	addLexemeToken("inverse_sawtooth", ID_INVERSE_SAWTOOTH);
	461	addLexemeAction("transform", &MaterialScriptCompiler::parseTransform);
	462	addLexemeAction("binding_type", &MaterialScriptCompiler::parseBindingType);
	463	addLexemeAction("content_type", &MaterialScriptCompiler::parseContentType);
	464	addLexemeToken("named", ID_NAMED);
	465	addLexemeToken("shadow", ID_SHADOW);
	466	// GPU program reference
	467	addLexemeAction("vertex_program_ref", &MaterialScriptCompiler::parseVertexProgramRef);
	468	addLexemeAction("fragment_program_ref", &MaterialScriptCompiler::parseFragmentProgramRef);
	469	addLexemeAction("shadow_caster_vertex_program_ref", &MaterialScriptCompiler::parseShadowCasterVertexProgramRef);
	470	addLexemeAction("shadow_receiver_vertex_program_ref", &MaterialScriptCompiler::parseShadowReceiverVertexProgramRef);
	471	addLexemeAction("shadow_receiver_fragment_program_ref", &MaterialScriptCompiler::parseShadowReceiverFragmentProgramRef);
	472
	473	// common section
	474	addLexemeToken("on", ID_ON);
	475	addLexemeToken("off", ID_OFF);
	476	addLexemeToken("true", ID_TRUE);
	477	addLexemeToken("false", ID_FALSE);
	478	addLexemeToken("none", ID_NONE);
	479	addLexemeToken("point", ID_POINT);
	480	addLexemeToken("linear", ID_LINEAR);
	481	addLexemeToken("add", ID_ADD);
	482	addLexemeToken("modulate", ID_MODULATE);
	483	addLexemeToken("alpha_blend", ID_ALPHA_BLEND);
	484	addLexemeToken("one", ID_ONE);
	485	addLexemeToken("zero", ID_ZERO);
	486	addLexemeToken("vertex", ID_VERTEX);
	487	addLexemeToken("fragment", ID_FRAGMENT);
	488
	489
	490	}
	491
	492	//-----------------------------------------------------------------------
	493	void MaterialScriptCompiler::addLexemeTokenAction(const String& lexeme, const size_t token, const MSC_Action action)
	494	{
	495	size_t newTokenID = addLexemeToken(lexeme, token, action != 0);
	496	if (action)
	497	mTokenActionMap[newTokenID] = action;
	498	}
	499
	500	//-----------------------------------------------------------------------
	501	void MaterialScriptCompiler::executeTokenAction(const size_t tokenID)
	502	{
	503	TokenActionIterator action = mTokenActionMap.find(tokenID);
	504
	505	if (action == mTokenActionMap.end())
	506	{
	507	// BAD command. BAD!
	508	logParseError("Unrecognised Material Script command action");
	509	return;
	510	}
	511	else
	512	{
	513	try
	514	{
	515	(this->*action->second)();
	516	}
	517	catch (Exception& ogreException)
	518	{
	519	if (ogreException.getNumber() == Exception::ERR_DUPLICATE_ITEM)
	520	{
	521	// an exception for duplicate item was thrown.
	522	// this means that either a material name or gpu program name conflict exists.
	523	// Since it wasn't trapped at a lower level then re-throw in order to terminate parsing
	524	logParseError("Duplicate Item Exception trapped. Parsing terminated for this material script.");
	525	throw;
	526	}
	527	else
	528	{
	529	// an unknown token found or BNF Grammer rule was not successful
	530	// in finding a valid terminal token to complete the rule expression.
	531	// don't relog the exception but do log the material script being parsed and the line number
	532	logParseError("Exception trapped, attempting to continue parsing");
	533	}
	534	}
	535	}
	536	}
	537
	538	//-----------------------------------------------------------------------
	539	void MaterialScriptCompiler::logParseError(const String& error)
	540	{
	541	// log material name only if filename not specified
	542	if (mSourceName.empty() && !mScriptContext.material.isNull())
	543	{
	544	LogManager::getSingleton().logMessage(
	545	"Error in material " + mScriptContext.material->getName() +
	546	" : " + error);
	547	}
	548	else
	549	{
	550	if (!mScriptContext.material.isNull())
	551	{
	552	LogManager::getSingleton().logMessage(
	553	"Error in material " + mScriptContext.material->getName() +
	554	" at line " + StringConverter::toString(mCurrentLine) +
	555	" of " + mSourceName + ": " + error);
	556	}
	557	else
	558	{
	559	LogManager::getSingleton().logMessage(
	560	"Error at line " + StringConverter::toString(mCurrentLine) +
	561	" of " + mSourceName + ": " + error);
	562	}
	563	}
	564	}
	565	//-----------------------------------------------------------------------
	566	void MaterialScriptCompiler::parseOpenBrace(void)
	567	{
	568
	569	}
	570	//-----------------------------------------------------------------------
	571	void MaterialScriptCompiler::parseCloseBrace(void)
	572	{
	573	switch(mScriptContext.section)
	574	{
	575	case MSS_NONE:
	576	logParseError("Unexpected terminating brace.");
	577	break;
	578	case MSS_MATERIAL:
	579	// End of material
	580	// if texture aliases were found, pass them to the material
	581	// to update texture names used in Texture unit states
	582	if (!mScriptContext.textureAliases.empty())
	583	{
	584	// request material to update all texture names in TUS's
	585	// that use texture aliases in the list
	586	mScriptContext.material->applyTextureAliases(mScriptContext.textureAliases);
	587	}
	588
	589	mScriptContext.section = MSS_NONE;
	590	mScriptContext.material.setNull();
	591	mScriptContext.textureAliases.clear();
	592	break;
	593	case MSS_TECHNIQUE:
	594	// End of technique
	595	mScriptContext.section = MSS_MATERIAL;
	596	mScriptContext.technique = NULL;
	597	mScriptContext.passLev = -1; //Reset pass level (yes, the pass level)
	598	break;
	599	case MSS_PASS:
	600	// End of pass
	601	mScriptContext.section = MSS_TECHNIQUE;
	602	mScriptContext.pass = NULL;
	603	mScriptContext.stateLev = -1; //Reset state level (yes, the state level)
	604	break;
	605	case MSS_TEXTUREUNIT:
	606	// End of texture unit
	607	mScriptContext.section = MSS_PASS;
	608	mScriptContext.textureUnit = NULL;
	609	break;
	610	case MSS_TEXTURESOURCE:
	611	//End texture source section
	612	//Finish creating texture here
	613
	614	if( ExternalTextureSourceManager::getSingleton().getCurrentPlugIn() != 0)
	615	{
	616	const String sMaterialName = mScriptContext.material->getName();
	617	ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->
	618	createDefinedTexture( sMaterialName, mScriptContext.groupName );
	619	}
	620	//Revert back to texture unit
	621	mScriptContext.section = MSS_TEXTUREUNIT;
	622	break;
	623	case MSS_PROGRAM_REF:
	624	// End of program
	625	mScriptContext.section = MSS_PASS;
	626	mScriptContext.program.setNull();
	627	break;
	628	case MSS_PROGRAM:
	629	// Program definitions are slightly different, they are deferred
	630	// until all the information required is known
	631	// End of program
	632	finishProgramDefinition();
	633	mScriptContext.section = MSS_NONE;
	634	delete mScriptContext.programDef;
	635	mScriptContext.pendingDefaultParams.clear();
	636	mScriptContext.programDef = NULL;
	637	break;
	638	case MSS_DEFAULT_PARAMETERS:
	639	// End of default parameters
	640	mScriptContext.section = MSS_PROGRAM;
	641	break;
	642	};
	643	}
	644	//-----------------------------------------------------------------------
	645	void MaterialScriptCompiler::parseGPUProgram(void)
	646	{
	647	// update section
	648	mScriptContext.section = MSS_PROGRAM;
	649
	650	// Create new program definition-in-progress
	651	mScriptContext.programDef = new MaterialScriptProgramDefinition();
	652	mScriptContext.programDef->progType =
	653	(getCurrentTokenID() == ID_VERTEX_PROGRAM) ? GPT_VERTEX_PROGRAM : GPT_FRAGMENT_PROGRAM;
	654	mScriptContext.programDef->supportsSkeletalAnimation = false;
	655	mScriptContext.programDef->supportsMorphAnimation = false;
	656	mScriptContext.programDef->supportsPoseAnimation = 0;
	657	mScriptContext.programDef->usesVertexTextureFetch = false;
	658
	659	// Get name and language code
	660	// Name, preserve case
	661	mScriptContext.programDef->name = getNextTokenLabel();
	662	// trim trailing white space only
	663	StringUtil::trim(mScriptContext.programDef->name);
	664	// language code
	665	mScriptContext.programDef->language = getNextTokenLabel();
	666	// make sure language is lower case
	667	StringUtil::toLowerCase(mScriptContext.programDef->language);
	668	}
	669	//-----------------------------------------------------------------------
	670	void MaterialScriptCompiler::parseProgramSource(void)
	671	{
	672	assert(mScriptContext.programDef);
	673	mScriptContext.programDef->source = getNextTokenLabel();
	674	}
	675	//-----------------------------------------------------------------------
	676	void MaterialScriptCompiler::parseProgramSyntax(void)
	677	{
	678	assert(mScriptContext.programDef);
	679	mScriptContext.programDef->syntax = getNextTokenLabel();
	680	// make sure language is lower case
	681	StringUtil::toLowerCase(mScriptContext.programDef->syntax);
	682	}
	683	//-----------------------------------------------------------------------
	684	void MaterialScriptCompiler::parseProgramSkeletalAnimation(void)
	685	{
	686	assert(mScriptContext.programDef);
	687	mScriptContext.programDef->supportsSkeletalAnimation = testNextTokenID(ID_TRUE);
	688	}
	689	//-----------------------------------------------------------------------
	690	void MaterialScriptCompiler::parseProgramMorphAnimation(void)
	691	{
	692	assert(mScriptContext.programDef);
	693	mScriptContext.programDef->supportsMorphAnimation = testNextTokenID(ID_TRUE);
	694	}
	695	//-----------------------------------------------------------------------
	696	void MaterialScriptCompiler::parseProgramPoseAnimation(void)
	697	{
	698	assert(mScriptContext.programDef);
	699	mScriptContext.programDef->supportsPoseAnimation = static_cast<ushort>(getNextTokenValue());
	700	}
	701	//-----------------------------------------------------------------------
	702	void MaterialScriptCompiler::parseProgramVertexTextureFetch(void)
	703	{
	704	assert(mScriptContext.programDef);
	705	mScriptContext.programDef->usesVertexTextureFetch = testNextTokenID(ID_TRUE);
	706	}
	707	//-----------------------------------------------------------------------
	708	void MaterialScriptCompiler::parseProgramCustomParameter(void)
	709	{
	710	assert(mScriptContext.programDef);
	711
	712	String command = getNextTokenLabel();
	713	StringUtil::toLowerCase(command);
	714	String params = getNextTokenLabel();
	715	StringUtil::trim(params);
	716	mScriptContext.programDef->customParameters.push_back(
	717	std::pair<String, String>(command, params));
	718	}
	719	//-----------------------------------------------------------------------
	720	void MaterialScriptCompiler::parseDefaultParams(void)
	721	{
	722	mScriptContext.section = MSS_DEFAULT_PARAMETERS;
	723	}
	724	//-----------------------------------------------------------------------
	725	void MaterialScriptCompiler::parseMaterial(void)
	726	{
	727	// check params for reference to parent material to copy from
	728	// syntax: material name : parentMaterialName
	729	MaterialPtr basematerial;
	730
	731	String materialName = getNextTokenLabel();
	732	StringUtil::trim(materialName);
	733	// Create a brand new material
	734	const size_t paramCount = getRemainingTokensForAction();
	735	if (paramCount == 2)
	736	{
	737	// this gets the ':' token which we need to consume to get to the label
	738	getNextToken();
	739	// if a second parameter exists then assume its the name of the base material
	740	// that this new material should clone from
	741	String parentName = getNextTokenLabel();
	742	StringUtil::trim(parentName);
	743	// make sure base material exists
	744	basematerial = MaterialManager::getSingleton().getByName(parentName);
	745	// if it doesn't exist then report error in log and just create a new material
	746	if (basematerial.isNull())
	747	{
	748	logParseError("parent material: " + parentName + " not found for new material:"
	749	+ materialName);
	750	}
	751	}
	752
	753	/* attempt to create the material. If the material name is already in use
	754	then MaterialManager throws an exception.
	755	*/
	756	try
	757	{
	758	mScriptContext.material =
	759	MaterialManager::getSingleton().create(materialName, mScriptContext.groupName);
	760	}
	761	catch (Exception& e)
	762	{
	763	bool exceptionHandled = false;
	764
	765	if (mScriptContext.allowOverride && (e.getNumber() == Exception::ERR_DUPLICATE_ITEM))
	766	{
	767	/* the material already exists log a warning message about it being modified by
	768	another material script
	769	*/
	770	mScriptContext.material = MaterialManager::getSingleton().getByName(materialName);
	771	if ( !mScriptContext.material.isNull())
	772	{
	773	logParseError("material " + materialName +
	774	", defined in " + mScriptContext.material->getOrigin() +
	775	", was overwritten by current material being parsed with same name");
	776	// update group ownership since the original material might have been in a different resource group
	777	mScriptContext.material->changeGroupOwnership(mScriptContext.groupName);
	778	exceptionHandled = true;
	779	}
	780	}
	781	if (!exceptionHandled)
	782	{
	783	logParseError("material " + materialName +
	784	" was previously defined and can not override.\n"
	785	"Material Manager script override was not enabled." );
	786
	787	throw;
	788	}
	789	}
	790
	791	if (!basematerial.isNull())
	792	{
	793	// copy parent material details to new or pre-existing material
	794	basematerial->copyDetailsTo(mScriptContext.material);
	795	}
	796	else
	797	{
	798	// Remove pre-created technique from defaults or original material
	799	mScriptContext.material->removeAllTechniques();
	800	}
	801
	802	mScriptContext.material->_notifyOrigin(mSourceName);
	803
	804	// update section
	805	mScriptContext.section = MSS_MATERIAL;
	806	//Reset all levels since this is the start of the material definition
	807	mScriptContext.passLev = -1;
	808	mScriptContext.stateLev= -1;
	809	mScriptContext.techLev = -1;
	810
	811	}
	812	//-----------------------------------------------------------------------
	813	// material Section Actions
	814	//-----------------------------------------------------------------------
	815	void MaterialScriptCompiler::parseLodDistances(void)
	816	{
	817	// iterate over the parameters and parse distances out of them
	818	Material::LodDistanceList lodList;
	819	while (getRemainingTokensForAction() > 0)
	820	{
	821	lodList.push_back(getNextTokenValue());
	822	}
	823
	824	mScriptContext.material->setLodLevels(lodList);
	825	}
	826	//-----------------------------------------------------------------------
	827	void MaterialScriptCompiler::parseReceiveShadows(void)
	828	{
	829	mScriptContext.material->setReceiveShadows(testNextTokenID(ID_ON));
	830	}
	831	//-----------------------------------------------------------------------
	832	void MaterialScriptCompiler::parseTransparencyCastsShadows(void)
	833	{
	834	mScriptContext.material->setTransparencyCastsShadows(testNextTokenID(ID_ON));
	835	}
	836	//-----------------------------------------------------------------------
	837	void MaterialScriptCompiler::parseSetTextureAlias(void)
	838	{
	839	const String& aliasName = getNextTokenLabel();
	840	const String& textureName = getNextTokenLabel();
	841	mScriptContext.textureAliases[aliasName] = textureName;
	842	}
	843	//-----------------------------------------------------------------------
	844	// Technique section Actions
	845	//-----------------------------------------------------------------------
	846	void MaterialScriptCompiler::parseTechnique(void)
	847	{
	848	String techniqueName;
	849	if (getRemainingTokensForAction() > 0)
	850	techniqueName = getNextTokenLabel();
	851	// if params is not empty then see if the technique name already exists
	852	if (!techniqueName.empty() && (mScriptContext.material->getNumTechniques() > 0))
	853	{
	854	Technique* foundTechnique = mScriptContext.material->getTechnique(techniqueName);
	855	if (foundTechnique)
	856	{
	857	// figure out technique index by iterating through technique container
	858	// would be nice if each technique remembered its index
	859	int count = 0;
	860	Material::TechniqueIterator i = mScriptContext.material->getTechniqueIterator();
	861	while(i.hasMoreElements())
	862	{
	863	if (foundTechnique == i.peekNext())
	864	break;
	865	i.moveNext();
	866	++count;
	867	}
	868
	869	mScriptContext.techLev = count;
	870	}
	871	else
	872	{
	873	// name was not found so a new technique is needed
	874	// position technique level to the end index
	875	// a new technique will be created later on
	876	mScriptContext.techLev = mScriptContext.material->getNumTechniques();
	877	}
	878
	879	}
	880	else
	881	{
	882	// no name was given in the script so a new technique will be created
	883	// Increase technique level depth
	884	++mScriptContext.techLev;
	885	}
	886
	887	// Create a new technique if it doesn't already exist
	888	if (mScriptContext.material->getNumTechniques() > mScriptContext.techLev)
	889	{
	890	mScriptContext.technique = mScriptContext.material->getTechnique(mScriptContext.techLev);
	891	}
	892	else
	893	{
	894	mScriptContext.technique = mScriptContext.material->createTechnique();
	895	if (!techniqueName.empty())
	896	mScriptContext.technique->setName(techniqueName);
	897	}
	898
	899	// update section
	900	mScriptContext.section = MSS_TECHNIQUE;
	901
	902	}
	903	//-----------------------------------------------------------------------
	904	void MaterialScriptCompiler::parseScheme(void)
	905	{
	906	assert(mScriptContext.technique);
	907	mScriptContext.technique->setSchemeName(getNextTokenLabel());
	908	}
	909	//-----------------------------------------------------------------------
	910	void MaterialScriptCompiler::parseLodIndex(void)
	911	{
	912	assert(mScriptContext.technique);
	913	mScriptContext.technique->setLodIndex(static_cast<uint>(getNextTokenValue()));
	914	}
	915	//-----------------------------------------------------------------------
	916	// Pass Section Actions
	917	//-----------------------------------------------------------------------
	918	void MaterialScriptCompiler::parsePass(void)
	919	{
	920	String passName;
	921	if (getRemainingTokensForAction() > 0)
	922	passName = getNextTokenLabel();
	923	// if params is not empty then see if the pass name already exists
	924	if (!passName.empty() && (mScriptContext.technique->getNumPasses() > 0))
	925	{
	926	Pass* foundPass = mScriptContext.technique->getPass(passName);
	927	if (foundPass)
	928	{
	929	mScriptContext.passLev = foundPass->getIndex();
	930	}
	931	else
	932	{
	933	// name was not found so a new pass is needed
	934	// position pass level to the end index
	935	// a new pass will be created later on
	936	mScriptContext.passLev = mScriptContext.technique->getNumPasses();
	937	}
	938
	939	}
	940	else
	941	{
	942	//Increase pass level depth
	943	++mScriptContext.passLev;
	944	}
	945
	946	if (mScriptContext.technique->getNumPasses() > mScriptContext.passLev)
	947	{
	948	mScriptContext.pass = mScriptContext.technique->getPass(mScriptContext.passLev);
	949	}
	950	else
	951	{
	952	// Create a new pass
	953	mScriptContext.pass = mScriptContext.technique->createPass();
	954	if (!passName.empty())
	955	mScriptContext.pass->setName(passName);
	956	}
	957
	958	// update section
	959	mScriptContext.section = MSS_PASS;
	960	}
	961	//-----------------------------------------------------------------------
	962	ColourValue MaterialScriptCompiler::_parseColourValue(void)
	963	{
	964	Real r = getNextTokenValue();
	965	Real g = getNextTokenValue();
	966	Real b = getNextTokenValue();
	967	Real a = getRemainingTokensForAction() == 1 ? getNextTokenValue() : 1.0f;
	968	return ColourValue(r, g, b, a);
	969	}
	970	//-----------------------------------------------------------------------
	971	void MaterialScriptCompiler::parseAmbient(void)
	972	{
	973	// Must be 1, 3 or 4 parameters
	974	assert(mScriptContext.pass);
	975	const size_t paramCount = getRemainingTokensForAction();
	976	if (paramCount == 1) {
	977	if(testNextTokenID(ID_VERTEXCOLOUR))
	978	{
	979	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() \| TVC_AMBIENT);
	980	}
	981	else
	982	{
	983	logParseError("Bad ambient attribute, single parameter flag must be 'vertexcolour'");
	984	}
	985	}
	986	else if (paramCount == 3 \|\| paramCount == 4)
	987	{
	988	mScriptContext.pass->setAmbient( _parseColourValue() );
	989	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() & ~TVC_AMBIENT);
	990	}
	991	else
	992	{
	993	logParseError("Bad ambient attribute, wrong number of parameters (expected 1, 3 or 4)");
	994	}
	995	}
	996	//-----------------------------------------------------------------------
	997	void MaterialScriptCompiler::parseDiffuse(void)
	998	{
	999	// Must be 1, 3 or 4 parameters
	1000	assert(mScriptContext.pass);
	1001	const size_t paramCount = getRemainingTokensForAction();
	1002	if (paramCount == 1) {
	1003	if(testNextTokenID(ID_VERTEXCOLOUR))
	1004	{
	1005	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() \| TVC_DIFFUSE);
	1006	}
	1007	else
	1008	{
	1009	logParseError("Bad diffuse attribute, single parameter flag must be 'vertexcolour'");
	1010	}
	1011	}
	1012	else if (paramCount == 3 \|\| paramCount == 4)
	1013	{
	1014	mScriptContext.pass->setDiffuse( _parseColourValue() );
	1015	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() & ~TVC_DIFFUSE);
	1016	}
	1017	else
	1018	{
	1019	logParseError("Bad diffuse attribute, wrong number of parameters (expected 1, 3 or 4)");
	1020	}
	1021	}
	1022	//-----------------------------------------------------------------------
	1023	void MaterialScriptCompiler::parseSpecular(void)
	1024	{
	1025	// Must be 2, 4 or 5 parameters
	1026	assert(mScriptContext.pass);
	1027	const size_t paramCount = getRemainingTokensForAction();
	1028	if(paramCount == 2)
	1029	{
	1030	if(getNextTokenID() == ID_VERTEXCOLOUR)
	1031	{
	1032	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() \| TVC_SPECULAR);
	1033	mScriptContext.pass->setShininess(getNextTokenValue());
	1034	}
	1035	else
	1036	{
	1037	logParseError("Bad specular attribute, double parameter statement must be 'vertexcolour <shininess>'");
	1038	}
	1039	}
	1040	else if(paramCount == 4 \|\| paramCount == 5)
	1041	{
	1042	Real r = getNextTokenValue();
	1043	Real g = getNextTokenValue();
	1044	Real b = getNextTokenValue();
	1045	Real a = paramCount == 5 ? getNextTokenValue() : 1.0f;
	1046	mScriptContext.pass->setSpecular(r, g, b, a);
	1047	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() & ~TVC_SPECULAR);
	1048	mScriptContext.pass->setShininess( getNextTokenValue() );
	1049	}
	1050	else
	1051	{
	1052	logParseError("Bad specular attribute, wrong number of parameters (expected 2, 4 or 5)");
	1053	}
	1054	}
	1055	//-----------------------------------------------------------------------
	1056	void MaterialScriptCompiler::parseEmissive(void)
	1057	{
	1058	// Must be 1, 3 or 4 parameters
	1059	assert(mScriptContext.pass);
	1060	const size_t paramCount = getRemainingTokensForAction();
	1061	if (paramCount == 1) {
	1062	if(testNextTokenID(ID_VERTEXCOLOUR))
	1063	{
	1064	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() \| TVC_EMISSIVE);
	1065	}
	1066	else
	1067	{
	1068	logParseError("Bad emissive attribute, single parameter flag must be 'vertexcolour'");
	1069	}
	1070	}
	1071	else if (paramCount == 3 \|\| paramCount == 4)
	1072	{
	1073	mScriptContext.pass->setSelfIllumination( _parseColourValue() );
	1074	mScriptContext.pass->setVertexColourTracking(mScriptContext.pass->getVertexColourTracking() & ~TVC_EMISSIVE);
	1075	}
	1076	else
	1077	{
	1078	logParseError("Bad emissive attribute, wrong number of parameters (expected 1, 3 or 4)");
	1079	}
	1080	}
	1081	//-----------------------------------------------------------------------
	1082	SceneBlendFactor MaterialScriptCompiler::convertBlendFactor(void)
	1083	{
	1084	switch(getNextTokenID())
	1085	{
	1086	case ID_ONE:
	1087	return SBF_ONE;
	1088	case ID_ZERO:
	1089	return SBF_ZERO;
	1090	case ID_DEST_COLOUR:
	1091	return SBF_DEST_COLOUR;
	1092	case ID_SRC_COLOUR:
	1093	return SBF_SOURCE_COLOUR;
	1094	case ID_ONE_MINUS_DEST_COLOUR:
	1095	return SBF_ONE_MINUS_DEST_COLOUR;
	1096	case ID_ONE_MINUS_SRC_COLOUR:
	1097	return SBF_ONE_MINUS_SOURCE_COLOUR;
	1098	case ID_DEST_ALPHA:
	1099	return SBF_DEST_ALPHA;
	1100	case ID_SRC_ALPHA:
	1101	return SBF_SOURCE_ALPHA;
	1102	case ID_ONE_MINUS_DEST_ALPHA:
	1103	return SBF_ONE_MINUS_DEST_ALPHA;
	1104	case ID_ONE_MINUS_SRC_ALPHA:
	1105	return SBF_ONE_MINUS_SOURCE_ALPHA;
	1106	default:
	1107	return SBF_ONE;
	1108	break;
	1109	}
	1110	}
	1111	//-----------------------------------------------------------------------
	1112	void MaterialScriptCompiler::parseSceneBlend(void)
	1113	{
	1114	assert(mScriptContext.pass);
	1115	const size_t paramCount = getRemainingTokensForAction();
	1116	// Should be 1 or 2 params
	1117	if (paramCount == 1)
	1118	{
	1119	//simple blend types
	1120	SceneBlendType sbtype = SBT_REPLACE;
	1121	switch(getNextTokenID())
	1122	{
	1123	case ID_ADD:
	1124	sbtype = SBT_ADD;
	1125	break;
	1126	case ID_MODULATE:
	1127	sbtype = SBT_MODULATE;
	1128	break;
	1129	case ID_COLOUR_BLEND:
	1130	sbtype = SBT_TRANSPARENT_COLOUR;
	1131	break;
	1132	case ID_ALPHA_BLEND:
	1133	sbtype = SBT_TRANSPARENT_ALPHA;
	1134	break;
	1135	default:
	1136	break;
	1137	}
	1138	mScriptContext.pass->setSceneBlending(sbtype);
	1139
	1140	}
	1141	else if (paramCount == 2)
	1142	{
	1143	const SceneBlendFactor src = convertBlendFactor();
	1144	const SceneBlendFactor dest = convertBlendFactor();
	1145	mScriptContext.pass->setSceneBlending(src,dest);
	1146	}
	1147	else
	1148	{
	1149	logParseError(
	1150	"Bad scene_blend attribute, wrong number of parameters (expected 1 or 2)");
	1151	}
	1152	}
	1153	//-----------------------------------------------------------------------
	1154	void MaterialScriptCompiler::parseDepthCheck(void)
	1155	{
	1156	assert(mScriptContext.pass);
	1157	mScriptContext.pass->setDepthCheckEnabled(testNextTokenID(ID_ON));
	1158	}
	1159	//-----------------------------------------------------------------------
	1160	void MaterialScriptCompiler::parseDepthWrite(void)
	1161	{
	1162	assert(mScriptContext.pass);
	1163	mScriptContext.pass->setDepthWriteEnabled(testNextTokenID(ID_ON));
	1164	}
	1165	//-----------------------------------------------------------------------
	1166	CompareFunction MaterialScriptCompiler::convertCompareFunction(void)
	1167	{
	1168	switch (getNextTokenID())
	1169	{
	1170	case ID_ALWAYS_FAIL:
	1171	return CMPF_ALWAYS_FAIL;
	1172	case ID_ALWAYS_PASS:
	1173	return CMPF_ALWAYS_PASS;
	1174	case ID_LESS:
	1175	return CMPF_LESS;
	1176	case ID_LESS_EQUAL:
	1177	return CMPF_LESS_EQUAL;
	1178	case ID_EQUAL:
	1179	return CMPF_EQUAL;
	1180	case ID_NOT_EQUAL:
	1181	return CMPF_NOT_EQUAL;
	1182	case ID_GREATER_EQUAL:
	1183	return CMPF_GREATER_EQUAL;
	1184	case ID_GREATER:
	1185	return CMPF_GREATER;
	1186	default:
	1187	return CMPF_LESS_EQUAL;
	1188	break;
	1189	}
	1190	}
	1191
	1192	//-----------------------------------------------------------------------
	1193	void MaterialScriptCompiler::parseDepthFunc(void)
	1194	{
	1195	assert(mScriptContext.pass);
	1196	mScriptContext.pass->setDepthFunction(convertCompareFunction());
	1197	}
	1198	//-----------------------------------------------------------------------
	1199	void MaterialScriptCompiler::parseDepthBias(void)
	1200	{
	1201	assert(mScriptContext.pass);
	1202	float constantBias = static_cast<float>(getNextTokenValue());
	1203	float slopeScaleBias = 0.0f;
	1204	if (getRemainingTokensForAction() == 1)
	1205	{
	1206	slopeScaleBias = static_cast<float>(getNextTokenValue());
	1207	}
	1208
	1209	mScriptContext.pass->setDepthBias(constantBias, slopeScaleBias);
	1210	}
	1211	//-----------------------------------------------------------------------
	1212	void MaterialScriptCompiler::parseAlphaRejection(void)
	1213	{
	1214	assert(mScriptContext.pass);
	1215	const CompareFunction cmp = convertCompareFunction();
	1216	mScriptContext.pass->setAlphaRejectSettings(cmp, static_cast<unsigned char>(getNextTokenValue()));
	1217	}
	1218	//-----------------------------------------------------------------------
	1219	void MaterialScriptCompiler::parseCullHardware(void)
	1220	{
	1221	assert(mScriptContext.pass);
	1222	switch (getNextTokenID())
	1223	{
	1224	case ID_NONE:
	1225	mScriptContext.pass->setCullingMode(CULL_NONE);
	1226	break;
	1227	case ID_ANTICLOCKWISE:
	1228	mScriptContext.pass->setCullingMode(CULL_ANTICLOCKWISE);
	1229	break;
	1230	case ID_CLOCKWISE:
	1231	mScriptContext.pass->setCullingMode(CULL_CLOCKWISE);
	1232	break;
	1233	default:
	1234	break;
	1235	}
	1236	}
	1237	//-----------------------------------------------------------------------
	1238	void MaterialScriptCompiler::parseCullSoftware(void)
	1239	{
	1240	assert(mScriptContext.pass);
	1241	switch (getNextTokenID())
	1242	{
	1243	case ID_NONE:
	1244	mScriptContext.pass->setManualCullingMode(MANUAL_CULL_NONE);
	1245	break;
	1246	case ID_CULL_BACK:
	1247	mScriptContext.pass->setManualCullingMode(MANUAL_CULL_BACK);
	1248	break;
	1249	case ID_CULL_FRONT:
	1250	mScriptContext.pass->setManualCullingMode(MANUAL_CULL_FRONT);
	1251	break;
	1252	default:
	1253	break;
	1254	}
	1255	}
	1256	//-----------------------------------------------------------------------
	1257	void MaterialScriptCompiler::parseLighting(void)
	1258	{
	1259	assert(mScriptContext.pass);
	1260	mScriptContext.pass->setLightingEnabled(testNextTokenID(ID_ON));
	1261	}
	1262	//-----------------------------------------------------------------------
	1263	void MaterialScriptCompiler::parseShading(void)
	1264	{
	1265	assert(mScriptContext.pass);
	1266	switch (getNextTokenID())
	1267	{
	1268	case ID_FLAT:
	1269	mScriptContext.pass->setShadingMode(SO_FLAT);
	1270	break;
	1271	case ID_GOURAUD:
	1272	mScriptContext.pass->setShadingMode(SO_GOURAUD);
	1273	break;
	1274	case ID_PHONG:
	1275	mScriptContext.pass->setShadingMode(SO_PHONG);
	1276	break;
	1277	default:
	1278	break;
	1279	}
	1280	}
	1281	//-----------------------------------------------------------------------
	1282	void MaterialScriptCompiler::parsePolygonMode(void)
	1283	{
	1284	assert(mScriptContext.pass);
	1285	switch (getNextTokenID())
	1286	{
	1287	case ID_SOLID:
	1288	mScriptContext.pass->setPolygonMode(PM_SOLID);
	1289	break;
	1290	case ID_WIREFRAME:
	1291	mScriptContext.pass->setPolygonMode(PM_WIREFRAME);
	1292	break;
	1293	case ID_POINTS:
	1294	mScriptContext.pass->setPolygonMode(PM_POINTS);
	1295	break;
	1296	default:
	1297	break;
	1298	}
	1299	}
	1300	//-----------------------------------------------------------------------
	1301	void MaterialScriptCompiler::parseFogOverride(void)
	1302	{
	1303	assert(mScriptContext.pass);
	1304	if (getNextTokenID() == ID_TRUE)
	1305	{
	1306	// if true, we need to see if they supplied all arguments, or just the 1... if just the one,
	1307	// Assume they want to disable the default fog from effecting this material.
	1308	const size_t paramCount = getRemainingTokensForAction();
	1309	if( paramCount == 7 )
	1310	{
	1311	FogMode fogtype;
	1312	switch (getNextTokenID())
	1313	{
	1314	case ID_LINEAR:
	1315	fogtype = FOG_LINEAR;
	1316	case ID_EXP:
	1317	fogtype = FOG_EXP;
	1318	case ID_EXP2:
	1319	fogtype = FOG_EXP2;
	1320	case ID_NONE:
	1321	default:
	1322	fogtype = FOG_NONE;
	1323	break;
	1324	}
	1325
	1326	const Real red = getNextTokenValue();
	1327	const Real green = getNextTokenValue();
	1328	const Real blue = getNextTokenValue();
	1329	const Real density = getNextTokenValue();
	1330	const Real start = getNextTokenValue();
	1331	const Real end = getNextTokenValue();
	1332
	1333	mScriptContext.pass->setFog(
	1334	true,
	1335	fogtype,
	1336	ColourValue(red, green, blue),
	1337	density, start, end
	1338	);
	1339	}
	1340	else
	1341	{
	1342	mScriptContext.pass->setFog(true);
	1343	}
	1344	}
	1345	else
	1346	mScriptContext.pass->setFog(false);
	1347
	1348	}
	1349	//-----------------------------------------------------------------------
	1350	void MaterialScriptCompiler::parseColourWrite(void)
	1351	{
	1352	assert(mScriptContext.pass);
	1353	mScriptContext.pass->setColourWriteEnabled(testNextTokenID(ID_ON));
	1354	}
	1355	//-----------------------------------------------------------------------
	1356	void MaterialScriptCompiler::parseMaxLights(void)
	1357	{
	1358	assert(mScriptContext.pass);
	1359	mScriptContext.pass->setMaxSimultaneousLights(static_cast<int>(getNextTokenValue()));
	1360	}
	1361	void MaterialScriptCompiler::parseStartLight(void)
	1362	{
	1363	assert(mScriptContext.pass);
	1364	mScriptContext.pass->setStartLight(static_cast<int>(getNextTokenValue()));
	1365	}
	1366	//-----------------------------------------------------------------------
	1367	void MaterialScriptCompiler::parseIterationLightTypes(void)
	1368	{
	1369	assert(mScriptContext.pass);
	1370	// Parse light type
	1371	switch(getNextTokenID())
	1372	{
	1373	case ID_DIRECTIONAL:
	1374	mScriptContext.pass->setIteratePerLight(true, true, Light::LT_DIRECTIONAL);
	1375	break;
	1376	case ID_POINT:
	1377	mScriptContext.pass->setIteratePerLight(true, true, Light::LT_POINT);
	1378	break;
	1379	case ID_SPOT:
	1380	mScriptContext.pass->setIteratePerLight(true, true, Light::LT_SPOTLIGHT);
	1381	break;
	1382	}
	1383	}
	1384	//-----------------------------------------------------------------------
	1385	void MaterialScriptCompiler::parseIteration(void)
	1386	{
	1387	assert(mScriptContext.pass);
	1388	// we could have more than one parameter
	1389	/** combinations could be:
	1390	iteration once
	1391	iteration once_per_light [light type]
	1392	iteration <number>
	1393	iteration <number> [per_light] [light type]
	1394	iteration <number> [per_n_lights] <number> [light type]
	1395	*/
	1396	if (testNextTokenID(ID_ONCE))
	1397	mScriptContext.pass->setIteratePerLight(false, false);
	1398	else if (testNextTokenID(ID_ONCE_PER_LIGHT))
	1399	{
	1400	getNextToken();
	1401	if (getRemainingTokensForAction() == 1)
	1402	{
	1403	parseIterationLightTypes();
	1404	}
	1405	else
	1406	{
	1407	mScriptContext.pass->setIteratePerLight(true, false);
	1408	}
	1409
	1410	}
	1411	else // could be using form: <number> [per_light] [light type]
	1412	{
	1413	uint passIterationCount = static_cast<uint>(getNextTokenValue());
	1414	if (passIterationCount > 0)
	1415	{
	1416	mScriptContext.pass->setPassIterationCount(passIterationCount);
	1417	if (getRemainingTokensForAction() > 1)
	1418	{
	1419	const size_t tokenID = getNextTokenID();
	1420	if (tokenID == ID_PER_LIGHT)
	1421	{
	1422	if (getRemainingTokensForAction() == 1)
	1423	{
	1424	parseIterationLightTypes();
	1425	}
	1426	else
	1427	{
	1428	mScriptContext.pass->setIteratePerLight(true, false);
	1429	}
	1430	}
	1431	else if (tokenID == ID_PER_N_LIGHTS)
	1432	{
	1433	// Number of lights per iteration
	1434	mScriptContext.pass->setLightCountPerIteration(static_cast<short unsigned int>(getNextTokenValue()));
	1435	if (getRemainingTokensForAction() == 1)
	1436	{
	1437	parseIterationLightTypes();
	1438	}
	1439	else
	1440	{
	1441	mScriptContext.pass->setIteratePerLight(true, false);
	1442	}
	1443	}
	1444	else
	1445	logParseError(
	1446	"Bad iteration attribute, valid parameters are <number> [per_light\|per_n_lights <num_lights>] [light type].");
	1447	}
	1448	}
	1449	}
	1450	}
	1451	//-----------------------------------------------------------------------
	1452	void MaterialScriptCompiler::parsePointSize(void)
	1453	{
	1454	mScriptContext.pass->setPointSize(getNextTokenValue());
	1455	}
	1456	//-----------------------------------------------------------------------
	1457	void MaterialScriptCompiler::parsePointSprites(void)
	1458	{
	1459	assert(mScriptContext.pass);
	1460	mScriptContext.pass->setPointSpritesEnabled(testNextTokenID(ID_ON));
	1461	}
	1462	//-----------------------------------------------------------------------
	1463	void MaterialScriptCompiler::parsePointSizeMin(void)
	1464	{
	1465	assert(mScriptContext.pass);
	1466	mScriptContext.pass->setPointMinSize(getNextTokenValue());
	1467	}
	1468	//-----------------------------------------------------------------------
	1469	void MaterialScriptCompiler::parsePointSizeMax(void)
	1470	{
	1471	assert(mScriptContext.pass);
	1472	mScriptContext.pass->setPointMaxSize(getNextTokenValue());
	1473	}
	1474	//-----------------------------------------------------------------------
	1475	void MaterialScriptCompiler::parsePointSizeAttenuation(void)
	1476	{
	1477	assert(mScriptContext.pass);
	1478	const size_t paramCount = getRemainingTokensForAction();
	1479	if (paramCount != 1 && paramCount != 4)
	1480	{
	1481	logParseError("Bad point_size_attenuation attribute, wrong number of parameters (expected 1 or 4)");
	1482	return;
	1483	}
	1484	switch (getNextTokenID())
	1485	{
	1486	case ID_ON:
	1487	if (paramCount == 4)
	1488	{
	1489	Real constant = getNextTokenValue();
	1490	Real linear = getNextTokenValue();
	1491	Real quadric = getNextTokenValue();
	1492	mScriptContext.pass->setPointAttenuation(true, constant, linear, quadric);
	1493	}
	1494	else
	1495	{
	1496	mScriptContext.pass->setPointAttenuation(true);
	1497	}
	1498
	1499	break;
	1500	case ID_OFF:
	1501	mScriptContext.pass->setPointAttenuation(false);
	1502	break;
	1503	default:
	1504	logParseError("Bad point_size_attenuation attribute, valid values are 'on' or 'off'.");
	1505	}
	1506	}
	1507	//-----------------------------------------------------------------------
	1508	void MaterialScriptCompiler::parseTextureCustomParameter(void)
	1509	{
	1510	// This params object does not have the command stripped
	1511	// Split only up to first delimiter, program deals with the rest
	1512
	1513	if (getRemainingTokensForAction() != 2)
	1514	{
	1515	logParseError("Invalid texture parameter entry; "
	1516	"there must be a parameter name and at least one value.");
	1517	}
	1518
	1519	else if( ExternalTextureSourceManager::getSingleton().getCurrentPlugIn() != 0 )
	1520	{
	1521	////First is command, next could be a string with one or more values
	1522	const String& param1 = getNextTokenLabel();
	1523	const String& param2 = getNextTokenLabel();
	1524	ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->setParameter( param1, param2 );
	1525	}
	1526	}
	1527	//-----------------------------------------------------------------------
	1528	void MaterialScriptCompiler::parseTextureUnit(void)
	1529	{
	1530	String tusName;
	1531	if (getRemainingTokensForAction() > 0)
	1532	tusName = getNextTokenLabel();
	1533	// if params is a name then see if that texture unit exists
	1534	// if not then log the warning and just move on to the next TU from current
	1535	if (!tusName.empty() && (mScriptContext.pass->getNumTextureUnitStates() > 0))
	1536	{
	1537	// specifying a TUS name in the script for a TU means that a specific TU is being requested
	1538	// try to get the specific TU
	1539	// if the index requested is not valid, just creat a new TU
	1540	// find the TUS with name
	1541	TextureUnitState * foundTUS = mScriptContext.pass->getTextureUnitState(tusName);
	1542	if (foundTUS)
	1543	{
	1544	mScriptContext.stateLev = mScriptContext.pass->getTextureUnitStateIndex(foundTUS);
	1545	}
	1546	else
	1547	{
	1548	// name was not found so a new TUS is needed
	1549	// position TUS level to the end index
	1550	// a new TUS will be created later on
	1551	mScriptContext.stateLev = static_cast<uint>(mScriptContext.pass->getNumTextureUnitStates());
	1552	}
	1553	}
	1554	else
	1555	{
	1556	//Increase Texture Unit State level depth
	1557	++mScriptContext.stateLev;
	1558	}
	1559
	1560	if (mScriptContext.pass->getNumTextureUnitStates() > static_cast<size_t>(mScriptContext.stateLev))
	1561	{
	1562	mScriptContext.textureUnit = mScriptContext.pass->getTextureUnitState(mScriptContext.stateLev);
	1563	}
	1564	else
	1565	{
	1566	// Create a new texture unit
	1567	mScriptContext.textureUnit = mScriptContext.pass->createTextureUnitState();
	1568	if (!tusName.empty())
	1569	mScriptContext.textureUnit->setName(tusName);
	1570	}
	1571	// update section
	1572	mScriptContext.section = MSS_TEXTUREUNIT;
	1573	}
	1574	//-----------------------------------------------------------------------
	1575	void MaterialScriptCompiler::parseTextureAlias(void)
	1576	{
	1577	assert(mScriptContext.textureUnit);
	1578	mScriptContext.textureUnit->setTextureNameAlias(getNextTokenLabel());
	1579	}
	1580	//-----------------------------------------------------------------------
	1581	// Texture layer attributes
	1582	void MaterialScriptCompiler::parseTexture(void)
	1583	{
	1584	assert(mScriptContext.textureUnit);
	1585	TextureType tt = TEX_TYPE_2D;
	1586	int mipmaps = MIP_DEFAULT; // When passed to TextureManager::load, this means default to default number of mipmaps
	1587	bool isAlpha = false;
	1588	PixelFormat desiredFormat = PF_UNKNOWN;
	1589	const String& textureName = getNextTokenLabel();
	1590
	1591	while (getRemainingTokensForAction() > 0)
	1592	{
	1593	switch(getNextTokenID())
	1594	{
	1595	case ID_1D:
	1596	tt = TEX_TYPE_1D;
	1597	break;
	1598	case ID_2D:
	1599	tt = TEX_TYPE_2D;
	1600	break;
	1601	case ID_3D:
	1602	tt = TEX_TYPE_3D;
	1603	break;
	1604	case ID_CUBIC:
	1605	tt = TEX_TYPE_CUBE_MAP;
	1606	break;
	1607	case ID_UNLIMITED:
	1608	mipmaps = MIP_UNLIMITED;
	1609	break;
	1610	case ID_ALPHA:
	1611	isAlpha = true;
	1612	break;
	1613	case _value_:
	1614	replaceToken();
	1615	mipmaps = static_cast<int>(getNextTokenValue());
	1616	break;
	1617	default:
	1618	desiredFormat = PixelUtil::getFormatFromName(getCurrentTokenLexeme(), true);
	1619	break;
	1620	}
	1621	}
	1622	mScriptContext.textureUnit->setTextureName(textureName, tt);
	1623	mScriptContext.textureUnit->setNumMipmaps(mipmaps);
	1624	mScriptContext.textureUnit->setIsAlpha(isAlpha);
	1625	mScriptContext.textureUnit->setDesiredFormat(desiredFormat);
	1626	}
	1627	//-----------------------------------------------------------------------
	1628	void MaterialScriptCompiler::parseAnimTexture(void)
	1629	{
	1630	assert(mScriptContext.textureUnit);
	1631	StringVector vecparams;
	1632	// first token will be a label
	1633	vecparams.push_back(getNextTokenLabel());
	1634	// Determine which form it is
	1635	// if next token is a value then no more labels to be processed
	1636	if (testNextTokenID(_value_))
	1637	{
	1638	// First form using base name & number of frames
	1639	unsigned int frameCount = static_cast<unsigned int>(getNextTokenValue());
	1640	mScriptContext.textureUnit->setAnimatedTextureName(
	1641	vecparams[0],
	1642	frameCount,
	1643	getNextTokenValue());
	1644	}
	1645	else
	1646	{
	1647	unsigned int numParams = 1;
	1648	while (getRemainingTokensForAction() > 1)
	1649	{
	1650	vecparams.push_back(getNextTokenLabel());
	1651	++numParams;
	1652	}
	1653	// the last label should be a number so convert string label to number
	1654	// Second form using individual names
	1655	mScriptContext.textureUnit->setAnimatedTextureName(
	1656	(String*)&vecparams[0],
	1657	numParams,
	1658	StringConverter::parseReal(getNextTokenLabel()));
	1659	}
	1660	}
	1661	//-----------------------------------------------------------------------
	1662	void MaterialScriptCompiler::parseCubicTexture(void)
	1663	{
	1664	assert(mScriptContext.textureUnit);
	1665	StringVector vecparams;
	1666
	1667	// first token will be a label
	1668	vecparams.push_back(getNextTokenLabel());
	1669	// Determine which form it is
	1670	// if next token is a label then 5 more labels to be processed
	1671	if (testNextTokenID(_character_))
	1672	{
	1673	// get next five texture names
	1674	for (int i = 0; i < 5; ++i)
	1675	vecparams.push_back(getNextTokenLabel());
	1676	}
	1677
	1678	bool useUVW = testNextTokenID(ID_COMBINED_UVW);
	1679
	1680	if (vecparams.size() == 1)
	1681	{
	1682	mScriptContext.textureUnit->setCubicTextureName(vecparams[0], useUVW);
	1683	}
	1684	else
	1685	{
	1686	// Second form using individual names
	1687	// Can use vecparams[0] as array start point
	1688	mScriptContext.textureUnit->setCubicTextureName((String*)&vecparams[0], useUVW);
	1689	}
	1690	}
	1691	//-----------------------------------------------------------------------
	1692	void MaterialScriptCompiler::parseTexCoord(void)
	1693	{
	1694	assert(mScriptContext.textureUnit);
	1695	mScriptContext.textureUnit->setTextureCoordSet(
	1696	static_cast<unsigned int>(getNextTokenValue()));
	1697	}
	1698	//-----------------------------------------------------------------------
	1699	TextureUnitState::TextureAddressingMode MaterialScriptCompiler::convTexAddressMode(void)
	1700	{
	1701	switch (getNextTokenID())
	1702	{
	1703	case ID_WRAP:
	1704	return TextureUnitState::TAM_WRAP;
	1705	case ID_CLAMP:
	1706	return TextureUnitState::TAM_CLAMP;
	1707	case ID_MIRROR:
	1708	return TextureUnitState::TAM_MIRROR;
	1709	case ID_BORDER:
	1710	return TextureUnitState::TAM_BORDER;
	1711	default:
	1712	return TextureUnitState::TAM_WRAP;
	1713	}
	1714	}
	1715	//-----------------------------------------------------------------------
	1716	void MaterialScriptCompiler::parseTexAddressMode(void)
	1717	{
	1718	assert(mScriptContext.textureUnit);
	1719	const size_t paramCount = getRemainingTokensForAction();
	1720
	1721	if (paramCount == 1)
	1722	{
	1723	// Single-parameter option
	1724	mScriptContext.textureUnit->setTextureAddressingMode(
	1725	convTexAddressMode());
	1726	}
	1727	else
	1728	{
	1729	// 2-3 parameter option
	1730	TextureUnitState::UVWAddressingMode uvw;
	1731	uvw.u = convTexAddressMode();
	1732	uvw.v = convTexAddressMode();
	1733
	1734	if (paramCount == 3)
	1735	{
	1736	// w
	1737	uvw.w = convTexAddressMode();
	1738	}
	1739	else
	1740	{
	1741	uvw.w = TextureUnitState::TAM_WRAP;
	1742	}
	1743	mScriptContext.textureUnit->setTextureAddressingMode(uvw);
	1744	}
	1745	}
	1746	//-----------------------------------------------------------------------
	1747	void MaterialScriptCompiler::parseTexBorderColour(void)
	1748	{
	1749	assert(mScriptContext.textureUnit);
	1750	mScriptContext.textureUnit->setTextureBorderColour( _parseColourValue() );
	1751	}
	1752	//-----------------------------------------------------------------------
	1753	FilterOptions MaterialScriptCompiler::convertFiltering()
	1754	{
	1755	switch (getNextTokenID())
	1756	{
	1757	case ID_NONE:
	1758	return FO_NONE;
	1759	case ID_POINT:
	1760	return FO_POINT;
	1761	case ID_LINEAR:
	1762	return FO_LINEAR;
	1763	case ID_ANISOTROPIC:
	1764	return FO_ANISOTROPIC;
	1765	default:
	1766	return FO_POINT;
	1767	}
	1768	}
	1769	//-----------------------------------------------------------------------
	1770	void MaterialScriptCompiler::parseFiltering(void)
	1771	{
	1772	assert(mScriptContext.textureUnit);
	1773	// Must be 1 or 3 parameters
	1774	const size_t paramCount = getRemainingTokensForAction();
	1775	if (paramCount == 1)
	1776	{
	1777	// Simple format
	1778	switch (getNextTokenID())
	1779	{
	1780	case ID_BILINEAR:
	1781	mScriptContext.textureUnit->setTextureFiltering(TFO_BILINEAR);
	1782	break;
	1783	case ID_TRILINEAR:
	1784	mScriptContext.textureUnit->setTextureFiltering(TFO_TRILINEAR);
	1785	break;
	1786	case ID_ANISOTROPIC:
	1787	mScriptContext.textureUnit->setTextureFiltering(TFO_ANISOTROPIC);
	1788	break;
	1789	case ID_NONE:
	1790	mScriptContext.textureUnit->setTextureFiltering(TFO_NONE);
	1791	break;
	1792	}
	1793	}
	1794	else
	1795	{
	1796	// Complex format
	1797	const FilterOptions minFO = convertFiltering();
	1798	const FilterOptions magFO = convertFiltering();
	1799	const FilterOptions mipFO = convertFiltering();
	1800	mScriptContext.textureUnit->setTextureFiltering(minFO, magFO, mipFO);
	1801	}
	1802	}
	1803	//-----------------------------------------------------------------------
	1804	void MaterialScriptCompiler::parseMaxAnisotropy(void)
	1805	{
	1806	assert(mScriptContext.textureUnit);
	1807	mScriptContext.textureUnit->setTextureAnisotropy(
	1808	static_cast<unsigned int>(getNextTokenValue()));
	1809	}
	1810	//-----------------------------------------------------------------------
	1811	void MaterialScriptCompiler::parseMipMapBias(void)
	1812	{
	1813	assert(mScriptContext.textureUnit);
	1814	mScriptContext.textureUnit->setTextureMipmapBias(getNextTokenValue());
	1815	}
	1816	//-----------------------------------------------------------------------
	1817	void MaterialScriptCompiler::parseColourOp(void)
	1818	{
	1819	assert(mScriptContext.textureUnit);
	1820	switch (getNextTokenID())
	1821	{
	1822	case ID_REPLACE:
	1823	mScriptContext.textureUnit->setColourOperation(LBO_REPLACE);
	1824	break;
	1825	case ID_ADD:
	1826	mScriptContext.textureUnit->setColourOperation(LBO_ADD);
	1827	break;
	1828	case ID_MODULATE:
	1829	mScriptContext.textureUnit->setColourOperation(LBO_MODULATE);
	1830	break;
	1831	case ID_ALPHA_BLEND:
	1832	mScriptContext.textureUnit->setColourOperation(LBO_ALPHA_BLEND);
	1833	break;
	1834	}
	1835	}
	1836	//-----------------------------------------------------------------------
	1837	LayerBlendOperationEx MaterialScriptCompiler::convertBlendOpEx(void)
	1838	{
	1839	switch(getNextTokenID())
	1840	{
	1841	case ID_SOURCE1:
	1842	return LBX_SOURCE1;
	1843	case ID_SOURCE2:
	1844	return LBX_SOURCE2;
	1845	case ID_MODULATE:
	1846	return LBX_MODULATE;
	1847	case ID_MODULATE_X2:
	1848	return LBX_MODULATE_X2;
	1849	case ID_MODULATE_X4:
	1850	return LBX_MODULATE_X4;
	1851	case ID_ADD:
	1852	return LBX_ADD;
	1853	case ID_ADD_SIGNED:
	1854	return LBX_ADD_SIGNED;
	1855	case ID_ADD_SMOOTH:
	1856	return LBX_ADD_SMOOTH;
	1857	case ID_SUBTRACT:
	1858	return LBX_SUBTRACT;
	1859	case ID_BLEND_DIFFUSE_COLOUR:
	1860	return LBX_BLEND_DIFFUSE_COLOUR;
	1861	case ID_BLEND_DIFFUSE_ALPHA:
	1862	return LBX_BLEND_DIFFUSE_ALPHA;
	1863	case ID_BLEND_TEXTURE_ALPHA:
	1864	return LBX_BLEND_TEXTURE_ALPHA;
	1865	case ID_BLEND_CURRENT_ALPHA:
	1866	return LBX_BLEND_CURRENT_ALPHA;
	1867	case ID_BLEND_MANUAL:
	1868	return LBX_BLEND_MANUAL;
	1869	case ID_DOTPRODUCT:
	1870	return LBX_DOTPRODUCT;
	1871	default:
	1872	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid blend function", "convertBlendOpEx");
	1873	}
	1874	}
	1875	//-----------------------------------------------------------------------
	1876	LayerBlendSource MaterialScriptCompiler::convertBlendSource(void)
	1877	{
	1878	switch(getNextTokenID())
	1879	{
	1880	case ID_SRC_CURRENT:
	1881	return LBS_CURRENT;
	1882	case ID_SRC_TEXTURE:
	1883	return LBS_TEXTURE;
	1884	case ID_SRC_DIFFUSE:
	1885	return LBS_DIFFUSE;
	1886	case ID_SRC_SPECULAR:
	1887	return LBS_SPECULAR;
	1888	case ID_SRC_MANUAL:
	1889	return LBS_MANUAL;
	1890	default:
	1891	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid blend source", "convertBlendSource");
	1892	}
	1893	}
	1894	//-----------------------------------------------------------------------
	1895	void MaterialScriptCompiler::parseColourOpEx(void)
	1896	{
	1897
	1898	assert(mScriptContext.textureUnit);
	1899
	1900	LayerBlendOperationEx op;
	1901	LayerBlendSource src1, src2;
	1902	Real manual = 0.0;
	1903	ColourValue colSrc1 = ColourValue::White;
	1904	ColourValue colSrc2 = ColourValue::White;
	1905
	1906	try {
	1907	op = convertBlendOpEx();
	1908	src1 = convertBlendSource();
	1909	src2 = convertBlendSource();
	1910
	1911	if (op == LBX_BLEND_MANUAL)
	1912	manual = getNextTokenValue();
	1913
	1914	if (src1 == LBS_MANUAL)
	1915	colSrc1 = _parseColourValue();
	1916
	1917	if (src2 == LBS_MANUAL)
	1918	colSrc2 = _parseColourValue();
	1919	}
	1920	catch (Exception& e)
	1921	{
	1922	logParseError("Bad colour_op_ex attribute, " + e.getDescription());
	1923	return;
	1924	}
	1925
	1926	mScriptContext.textureUnit->setColourOperationEx(op, src1, src2, colSrc1, colSrc2, manual);
	1927	}
	1928	//-----------------------------------------------------------------------
	1929	void MaterialScriptCompiler::parseColourOpMultipassFallback(void)
	1930	{
	1931	assert(mScriptContext.textureUnit);
	1932
	1933	SceneBlendFactor src = convertBlendFactor();
	1934	SceneBlendFactor dest = convertBlendFactor();
	1935	mScriptContext.textureUnit->setColourOpMultipassFallback(src,dest);
	1936	}
	1937	//-----------------------------------------------------------------------
	1938	void MaterialScriptCompiler::parseAlphaOpEx(void)
	1939	{
	1940	assert(mScriptContext.textureUnit);
	1941
	1942	LayerBlendOperationEx op;
	1943	LayerBlendSource src1, src2;
	1944	Real manual = 0.0;
	1945	Real arg1 = 1.0, arg2 = 1.0;
	1946
	1947	try {
	1948	op = convertBlendOpEx();
	1949	src1 = convertBlendSource();
	1950	src2 = convertBlendSource();
	1951
	1952	if (op == LBX_BLEND_MANUAL)
	1953	manual = getNextTokenValue();
	1954
	1955	if (src1 == LBS_MANUAL)
	1956	arg1 = getNextTokenValue();
	1957
	1958	if (src2 == LBS_MANUAL)
	1959	arg2 = getNextTokenValue();
	1960	}
	1961	catch (Exception& e)
	1962	{
	1963	logParseError("Bad alpha_op_ex attribute, " + e.getDescription());
	1964	return;
	1965	}
	1966
	1967	mScriptContext.textureUnit->setAlphaOperation(op, src1, src2, arg1, arg2, manual);
	1968	}
	1969	//-----------------------------------------------------------------------
	1970	void MaterialScriptCompiler::parseEnvMap(void)
	1971	{
	1972	assert(mScriptContext.textureUnit);
	1973
	1974	switch (getNextTokenID())
	1975	{
	1976	case ID_OFF:
	1977	mScriptContext.textureUnit->setEnvironmentMap(false);
	1978	break;
	1979	case ID_SPHERICAL:
	1980	mScriptContext.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_CURVED);
	1981	break;
	1982	case ID_PLANAR:
	1983	mScriptContext.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_PLANAR);
	1984	break;
	1985	case ID_CUBIC_REFLECTION:
	1986	mScriptContext.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_REFLECTION);
	1987	break;
	1988	case ID_CUBIC_NORMAL:
	1989	mScriptContext.textureUnit->setEnvironmentMap(true, TextureUnitState::ENV_NORMAL);
	1990	break;
	1991	}
	1992	}
	1993	//-----------------------------------------------------------------------
	1994	void MaterialScriptCompiler::parseScroll(void)
	1995	{
	1996	assert(mScriptContext.textureUnit);
	1997
	1998	const Real x = getNextTokenValue();
	1999	const Real y = getNextTokenValue();
	2000
	2001	mScriptContext.textureUnit->setTextureScroll(x, y);
	2002	}
	2003	//-----------------------------------------------------------------------
	2004	void MaterialScriptCompiler::parseScrollAnim(void)
	2005	{
	2006	assert(mScriptContext.textureUnit);
	2007
	2008	const Real xspeed = getNextTokenValue();
	2009	const Real yspeed = getNextTokenValue();
	2010
	2011	mScriptContext.textureUnit->setScrollAnimation(xspeed, yspeed);
	2012	}
	2013	//-----------------------------------------------------------------------
	2014	void MaterialScriptCompiler::parseRotate(void)
	2015	{
	2016	assert(mScriptContext.textureUnit);
	2017	mScriptContext.textureUnit->setTextureRotate(Angle(getNextTokenValue()));
	2018	}
	2019	//-----------------------------------------------------------------------
	2020	void MaterialScriptCompiler::parseRotateAnim(void)
	2021	{
	2022	assert(mScriptContext.textureUnit);
	2023	mScriptContext.textureUnit->setRotateAnimation(getNextTokenValue());
	2024	}
	2025	//-----------------------------------------------------------------------
	2026	void MaterialScriptCompiler::parseScale(void)
	2027	{
	2028	assert(mScriptContext.textureUnit);
	2029	const Real xscale = getNextTokenValue();
	2030	const Real yscale = getNextTokenValue();
	2031	mScriptContext.textureUnit->setTextureScale(xscale, yscale);
	2032	}
	2033	//-----------------------------------------------------------------------
	2034	void MaterialScriptCompiler::parseWaveXform(void)
	2035	{
	2036
	2037	assert(mScriptContext.textureUnit);
	2038
	2039	TextureUnitState::TextureTransformType ttype;
	2040	WaveformType waveType;
	2041	// Check transform type
	2042	switch (getNextTokenID())
	2043	{
	2044	default:
	2045	case ID_SCROLL_X:
	2046	ttype = TextureUnitState::TT_TRANSLATE_U;
	2047	break;
	2048	case ID_SCROLL_Y:
	2049	ttype = TextureUnitState::TT_TRANSLATE_V;
	2050	break;
	2051	case ID_ROTATE:
	2052	ttype = TextureUnitState::TT_ROTATE;
	2053	break;
	2054	case ID_SCALE_X:
	2055	ttype = TextureUnitState::TT_SCALE_U;
	2056	break;
	2057	case ID_SCALE_Y:
	2058	ttype = TextureUnitState::TT_SCALE_V;
	2059	break;
	2060	}
	2061	// Check wave type
	2062	switch (getNextTokenID())
	2063	{
	2064	default:
	2065	case ID_SINE:
	2066	waveType = WFT_SINE;
	2067	break;
	2068	case ID_TRIANGLE:
	2069	waveType = WFT_TRIANGLE;
	2070	break;
	2071	case ID_SQUARE:
	2072	waveType = WFT_SQUARE;
	2073	break;
	2074	case ID_SAWTOOTH:
	2075	waveType = WFT_SAWTOOTH;
	2076	break;
	2077	case ID_INVERSE_SAWTOOTH:
	2078	waveType = WFT_INVERSE_SAWTOOTH;
	2079	break;
	2080	}
	2081
	2082	const Real base = getNextTokenValue();
	2083	const Real frequency = getNextTokenValue();
	2084	const Real phase = getNextTokenValue();
	2085	const Real amplitude = getNextTokenValue();
	2086
	2087	mScriptContext.textureUnit->setTransformAnimation(
	2088	ttype,
	2089	waveType,
	2090	base,
	2091	frequency,
	2092	phase,
	2093	amplitude );
	2094	}
	2095	//-----------------------------------------------------------------------
	2096	void MaterialScriptCompiler::parseTransform(void)
	2097	{
	2098	assert(mScriptContext.textureUnit);
	2099
	2100	Real matrixArray[16];
	2101
	2102	for (size_t i = 0; i < 16; ++i)
	2103	{
	2104	matrixArray[i] = getNextTokenValue();
	2105	}
	2106
	2107	Matrix4 xform(
	2108	matrixArray[0],
	2109	matrixArray[1],
	2110	matrixArray[2],
	2111	matrixArray[3],
	2112	matrixArray[4],
	2113	matrixArray[5],
	2114	matrixArray[6],
	2115	matrixArray[7],
	2116	matrixArray[8],
	2117	matrixArray[9],
	2118	matrixArray[10],
	2119	matrixArray[11],
	2120	matrixArray[12],
	2121	matrixArray[13],
	2122	matrixArray[14],
	2123	matrixArray[15]);
	2124
	2125	mScriptContext.textureUnit->setTextureTransform(xform);
	2126	}
	2127	//-----------------------------------------------------------------------
	2128	void MaterialScriptCompiler::parseBindingType(void)
	2129	{
	2130	assert(mScriptContext.textureUnit);
	2131	switch (getNextTokenID())
	2132	{
	2133	case ID_VERTEX:
	2134	mScriptContext.textureUnit->setBindingType(TextureUnitState::BT_VERTEX);
	2135	break;
	2136	case ID_FRAGMENT:
	2137	mScriptContext.textureUnit->setBindingType(TextureUnitState::BT_FRAGMENT);
	2138	break;
	2139	}
	2140	}
	2141	//-----------------------------------------------------------------------
	2142	void MaterialScriptCompiler::parseContentType(void)
	2143	{
	2144	assert(mScriptContext.textureUnit);
	2145	switch (getNextTokenID())
	2146	{
	2147	case ID_NAMED:
	2148	mScriptContext.textureUnit->setContentType(TextureUnitState::CONTENT_NAMED);
	2149	break;
	2150	case ID_SHADOW:
	2151	mScriptContext.textureUnit->setContentType(TextureUnitState::CONTENT_SHADOW);
	2152	break;
	2153	}
	2154	}
	2155	//-----------------------------------------------------------------------
	2156	void MaterialScriptCompiler::parseVertexProgramRef(void)
	2157	{
	2158	assert(mScriptContext.pass);
	2159	// update section
	2160	mScriptContext.section = MSS_PROGRAM_REF;
	2161	String name;
	2162
	2163	// get the name of the program definition if it was set
	2164	if (getRemainingTokensForAction() == 1)
	2165	{
	2166	name = getNextTokenLabel();
	2167	StringUtil::trim(name);
	2168	}
	2169
	2170	// check if pass has a vertex program already
	2171	if (mScriptContext.pass->hasVertexProgram())
	2172	{
	2173	// if existing pass vertex program has same name as params
	2174	// or params is empty then use current vertex program
	2175	if (name.empty() \|\| (mScriptContext.pass->getVertexProgramName() == name))
	2176	{
	2177	mScriptContext.program = mScriptContext.pass->getVertexProgram();
	2178	}
	2179	}
	2180
	2181	// if context.program was not set then try to get the vertex program using the name
	2182	// passed in params
	2183	if (mScriptContext.program.isNull())
	2184	{
	2185	mScriptContext.program = GpuProgramManager::getSingleton().getByName(name);
	2186	if (mScriptContext.program.isNull())
	2187	{
	2188	// Unknown program
	2189	logParseError("Invalid vertex_program_ref entry - vertex program "
	2190	+ name + " has not been defined.");
	2191	return;
	2192	}
	2193
	2194	// Set the vertex program for this pass
	2195	mScriptContext.pass->setVertexProgram(name);
	2196	}
	2197
	2198	mScriptContext.isProgramShadowCaster = false;
	2199	mScriptContext.isVertexProgramShadowReceiver = false;
	2200	mScriptContext.isFragmentProgramShadowReceiver = false;
	2201
	2202	// Create params? Skip this if program is not supported
	2203	if (mScriptContext.program->isSupported())
	2204	{
	2205	mScriptContext.programParams = mScriptContext.pass->getVertexProgramParameters();
	2206	mScriptContext.numAnimationParametrics = 0;
	2207	}
	2208	}
	2209	//-----------------------------------------------------------------------
	2210	void MaterialScriptCompiler::parseShadowCasterVertexProgramRef(void)
	2211	{
	2212	assert(mScriptContext.pass);
	2213	// update section
	2214	mScriptContext.section = MSS_PROGRAM_REF;
	2215	String name;
	2216
	2217	// get the name of the program definition if it was set
	2218	if (getRemainingTokensForAction() == 1)
	2219	{
	2220	name = getNextTokenLabel();
	2221	StringUtil::trim(name);
	2222	}
	2223
	2224	// check if pass has a shadow caster vertex program already
	2225	if (mScriptContext.pass->hasShadowCasterVertexProgram())
	2226	{
	2227	// if existing pass vertex program has same name as params
	2228	// or params is empty then use current vertex program
	2229	if (name.empty() \|\| (mScriptContext.pass->getShadowCasterVertexProgramName() == name))
	2230	{
	2231	mScriptContext.program = mScriptContext.pass->getShadowCasterVertexProgram();
	2232	}
	2233	}
	2234
	2235	// if context.program was not set then try to get the vertex program using the name
	2236	// passed in params
	2237	if (mScriptContext.program.isNull())
	2238	{
	2239	mScriptContext.program = GpuProgramManager::getSingleton().getByName(name);
	2240	if (mScriptContext.program.isNull())
	2241	{
	2242	// Unknown program
	2243	logParseError("Invalid shadow_caster_vertex_program_ref entry - vertex program "
	2244	+ name + " has not been defined.");
	2245	return;
	2246	}
	2247
	2248	// Set the vertex program for this pass
	2249	mScriptContext.pass->setShadowCasterVertexProgram(name);
	2250	}
	2251
	2252	mScriptContext.isProgramShadowCaster = true;
	2253	mScriptContext.isVertexProgramShadowReceiver = false;
	2254	mScriptContext.isFragmentProgramShadowReceiver = false;
	2255
	2256	// Create params? Skip this if program is not supported
	2257	if (mScriptContext.program->isSupported())
	2258	{
	2259	mScriptContext.programParams = mScriptContext.pass->getShadowCasterVertexProgramParameters();
	2260	mScriptContext.numAnimationParametrics = 0;
	2261	}
	2262	}
	2263	//-----------------------------------------------------------------------
	2264	void MaterialScriptCompiler::parseShadowReceiverVertexProgramRef(void)
	2265	{
	2266	assert(mScriptContext.pass);
	2267	// update section
	2268	mScriptContext.section = MSS_PROGRAM_REF;
	2269
	2270	String name;
	2271
	2272	// get the name of the program definition if it was set
	2273	if (getRemainingTokensForAction() == 1)
	2274	{
	2275	name = getNextTokenLabel();
	2276	StringUtil::trim(name);
	2277	}
	2278
	2279	// check if pass has a shadow caster vertex program already
	2280	if (mScriptContext.pass->hasShadowReceiverVertexProgram())
	2281	{
	2282	// if existing pass vertex program has same name as params
	2283	// or params is empty then use current vertex program
	2284	if (name.empty() \|\| (mScriptContext.pass->getShadowReceiverVertexProgramName() == name))
	2285	{
	2286	mScriptContext.program = mScriptContext.pass->getShadowReceiverVertexProgram();
	2287	}
	2288	}
	2289
	2290	// if context.program was not set then try to get the vertex program using the name
	2291	// passed in params
	2292	if (mScriptContext.program.isNull())
	2293	{
	2294	mScriptContext.program = GpuProgramManager::getSingleton().getByName(name);
	2295	if (mScriptContext.program.isNull())
	2296	{
	2297	// Unknown program
	2298	logParseError("Invalid shadow_receiver_vertex_program_ref entry - vertex program "
	2299	+ name + " has not been defined.");
	2300	return;
	2301	}
	2302
	2303	// Set the vertex program for this pass
	2304	mScriptContext.pass->setShadowReceiverVertexProgram(name);
	2305	}
	2306
	2307	mScriptContext.isProgramShadowCaster = false;
	2308	mScriptContext.isVertexProgramShadowReceiver = true;
	2309	mScriptContext.isFragmentProgramShadowReceiver = false;
	2310
	2311	// Create params? Skip this if program is not supported
	2312	if (mScriptContext.program->isSupported())
	2313	{
	2314	mScriptContext.programParams = mScriptContext.pass->getShadowReceiverVertexProgramParameters();
	2315	mScriptContext.numAnimationParametrics = 0;
	2316	}
	2317	}
	2318	//-----------------------------------------------------------------------
	2319	void MaterialScriptCompiler::parseShadowReceiverFragmentProgramRef(void)
	2320	{
	2321	assert(mScriptContext.pass);
	2322	// update section
	2323	mScriptContext.section = MSS_PROGRAM_REF;
	2324
	2325	String name;
	2326
	2327	// get the name of the program definition if it was set
	2328	if (getRemainingTokensForAction() == 1)
	2329	{
	2330	name = getNextTokenLabel();
	2331	StringUtil::trim(name);
	2332	}
	2333	// check if pass has a fragment program already
	2334	if (mScriptContext.pass->hasShadowReceiverFragmentProgram())
	2335	{
	2336	// if existing pass fragment program has same name as params
	2337	// or params is empty then use current fragment program
	2338	if (name.empty() \|\| (mScriptContext.pass->getShadowReceiverFragmentProgramName() == name))
	2339	{
	2340	mScriptContext.program = mScriptContext.pass->getShadowReceiverFragmentProgram();
	2341	}
	2342	}
	2343
	2344	// if context.program was not set then try to get the fragment program using the name
	2345	// passed in
	2346	if (mScriptContext.program.isNull())
	2347	{
	2348	mScriptContext.program = GpuProgramManager::getSingleton().getByName(name);
	2349	if (mScriptContext.program.isNull())
	2350	{
	2351	// Unknown program
	2352	logParseError("Invalid shadow_receiver_fragment_program_ref entry - fragment program "
	2353	+ name + " has not been defined.");
	2354	return;
	2355	}
	2356
	2357	// Set the vertex program for this pass
	2358	mScriptContext.pass->setShadowReceiverFragmentProgram(name);
	2359	}
	2360
	2361	mScriptContext.isProgramShadowCaster = false;
	2362	mScriptContext.isVertexProgramShadowReceiver = false;
	2363	mScriptContext.isFragmentProgramShadowReceiver = true;
	2364
	2365	// Create params? Skip this if program is not supported
	2366	if (mScriptContext.program->isSupported())
	2367	{
	2368	mScriptContext.programParams = mScriptContext.pass->getShadowReceiverFragmentProgramParameters();
	2369	mScriptContext.numAnimationParametrics = 0;
	2370	}
	2371	}
	2372	//-----------------------------------------------------------------------
	2373	void MaterialScriptCompiler::parseFragmentProgramRef(void)
	2374	{
	2375	assert(mScriptContext.pass);
	2376	// update section
	2377	mScriptContext.section = MSS_PROGRAM_REF;
	2378
	2379	String name;
	2380
	2381	// get the name of the program definition if it was set
	2382	if (getRemainingTokensForAction() == 1)
	2383	{
	2384	name = getNextTokenLabel();
	2385	StringUtil::trim(name);
	2386	}
	2387	// check if pass has a fragment program already
	2388	if (mScriptContext.pass->hasFragmentProgram())
	2389	{
	2390	// if existing pass fragment program has same name as params
	2391	// or params is empty then use current fragment program
	2392	if (name.empty() \|\| (mScriptContext.pass->getFragmentProgramName() == name))
	2393	{
	2394	mScriptContext.program = mScriptContext.pass->getFragmentProgram();
	2395	}
	2396	}
	2397
	2398	// if context.program was not set then try to get the fragment program using the name
	2399	// passed in params
	2400	if (mScriptContext.program.isNull())
	2401	{
	2402	mScriptContext.program = GpuProgramManager::getSingleton().getByName(name);
	2403	if (mScriptContext.program.isNull())
	2404	{
	2405	// Unknown program
	2406	logParseError("Invalid fragment_program_ref entry - fragment program "
	2407	+ name + " has not been defined.");
	2408	return;
	2409	}
	2410
	2411	// Set the vertex program for this pass
	2412	mScriptContext.pass->setFragmentProgram(name);
	2413	}
	2414
	2415	// Create params? Skip this if program is not supported
	2416	if (mScriptContext.program->isSupported())
	2417	{
	2418	mScriptContext.programParams = mScriptContext.pass->getFragmentProgramParameters();
	2419	mScriptContext.numAnimationParametrics = 0;
	2420	}
	2421	}
	2422	//-----------------------------------------------------------------------
	2423	void MaterialScriptCompiler::processManualProgramParam(bool isNamed,
	2424	const String commandname, size_t index, const String& paramName)
	2425	{
	2426	// NB we assume that the first element of vecparams is taken up with either
	2427	// the index or the parameter name, which we ignore
	2428
	2429	// Determine type
	2430	size_t start, dims, roundedDims, i;
	2431	bool isReal;
	2432	bool isMatrix4x4 = false;
	2433	String param(getNextTokenLabel());
	2434
	2435	StringUtil::toLowerCase(param);
	2436
	2437	if (param == "matrix4x4")
	2438	{
	2439	dims = 16;
	2440	isReal = true;
	2441	isMatrix4x4 = true;
	2442	}
	2443	else if ((start = param.find("float")) != String::npos)
	2444	{
	2445	// find the dimensionality
	2446	start = param.find_first_not_of("float");
	2447	// Assume 1 if not specified
	2448	if (start == String::npos)
	2449	{
	2450	dims = 1;
	2451	}
	2452	else
	2453	{
	2454	dims = StringConverter::parseInt(param.substr(start));
	2455	}
	2456	isReal = true;
	2457	}
	2458	else if ((start = param.find("int")) != String::npos)
	2459	{
	2460	// find the dimensionality
	2461	start = param.find_first_not_of("int");
	2462	// Assume 1 if not specified
	2463	if (start == String::npos)
	2464	{
	2465	dims = 1;
	2466	}
	2467	else
	2468	{
	2469	dims = StringConverter::parseInt(param.substr(start));
	2470	}
	2471	isReal = false;
	2472	}
	2473	else
	2474	{
	2475	logParseError("Invalid " + commandname + " attribute - unrecognised "
	2476	"parameter type " + param);
	2477	return;
	2478	}
	2479
	2480	if (getRemainingTokensForAction() != dims)
	2481	{
	2482	logParseError("Invalid " + commandname + " attribute - you need " +
	2483	StringConverter::toString(2 + dims) + " parameters for a parameter of "
	2484	"type " + param);
	2485	}
	2486
	2487	// clear any auto parameter bound to this constant, it would override this setting
	2488	// can cause problems overriding materials or changing default params
	2489	if (isNamed)
	2490	mScriptContext.programParams->clearNamedAutoConstant(paramName);
	2491	else
	2492	mScriptContext.programParams->clearAutoConstant(index);
	2493
	2494	// Round dims to multiple of 4
	2495	if (dims %4 != 0)
	2496	{
	2497	roundedDims = dims + 4 - (dims % 4);
	2498	}
	2499	else
	2500	{
	2501	roundedDims = dims;
	2502	}
	2503
	2504	// Now parse all the values
	2505	if (isReal)
	2506	{
	2507	Real* realBuffer = new Real[roundedDims];
	2508	// Do specified values
	2509	for (i = 0; i < dims; ++i)
	2510	{
	2511	realBuffer[i] = getNextTokenValue();
	2512	}
	2513	// Fill up to multiple of 4 with zero
	2514	for (; i < roundedDims; ++i)
	2515	{
	2516	realBuffer[i] = 0.0f;
	2517
	2518	}
	2519
	2520	if (isMatrix4x4)
	2521	{
	2522	// its a Matrix4x4 so pass as a Matrix4
	2523	// use specialized setConstant that takes a matrix so matrix is transposed if required
	2524	Matrix4 m4x4(
	2525	realBuffer[0], realBuffer[1], realBuffer[2], realBuffer[3],
	2526	realBuffer[4], realBuffer[5], realBuffer[6], realBuffer[7],
	2527	realBuffer[8], realBuffer[9], realBuffer[10], realBuffer[11],
	2528	realBuffer[12], realBuffer[13], realBuffer[14], realBuffer[15]
	2529	);
	2530	if (isNamed)
	2531	mScriptContext.programParams->setNamedConstant(paramName, m4x4);
	2532	else
	2533	mScriptContext.programParams->setConstant(index, m4x4);
	2534	}
	2535	else
	2536	{
	2537	// Set
	2538	if (isNamed)
	2539	{
	2540	// For named, only set up to the precise number of elements
	2541	// (no rounding to 4 elements)
	2542	// GLSL can support sub-float4 elements and we support that
	2543	// in the buffer now. Note how we set the 'multiple' param to 1
	2544	mScriptContext.programParams->setNamedConstant(paramName,
	2545	realBuffer, dims, 1);
	2546	}
	2547	else
	2548	{
	2549	mScriptContext.programParams->setConstant(index,
	2550	realBuffer, static_cast<size_t>(roundedDims * 0.25));
	2551	}
	2552
	2553	}
	2554
	2555
	2556	delete [] realBuffer;
	2557	}
	2558	else
	2559	{
	2560	int* intBuffer = new int[roundedDims];
	2561	// Do specified values
	2562	for (i = 0; i < dims; ++i)
	2563	{
	2564	intBuffer[i] = static_cast<int>(getNextTokenValue());
	2565	}
	2566	// Fill to multiple of 4 with 0
	2567	for (; i < roundedDims; ++i)
	2568	{
	2569	intBuffer[i] = 0;
	2570	}
	2571	// Set
	2572	if (isNamed)
	2573	{
	2574	// For named, only set up to the precise number of elements
	2575	// (no rounding to 4 elements)
	2576	// GLSL can support sub-float4 elements and we support that
	2577	// in the buffer now. Note how we set the 'multiple' param to 1
	2578	mScriptContext.programParams->setNamedConstant(paramName, intBuffer,
	2579	dims, 1);
	2580	}
	2581	else
	2582	{
	2583	mScriptContext.programParams->setConstant(index, intBuffer,
	2584	static_cast<size_t>(roundedDims * 0.25));
	2585	}
	2586	delete [] intBuffer;
	2587	}
	2588	}
	2589	//-----------------------------------------------------------------------
	2590	void MaterialScriptCompiler::processAutoProgramParam(bool isNamed, const String commandname,
	2591	size_t index, const String& paramName)
	2592	{
	2593
	2594	String autoConstantName(getNextTokenLabel());
	2595	// make sure param is in lower case
	2596	StringUtil::toLowerCase(autoConstantName);
	2597
	2598	// lookup the param to see if its a valid auto constant
	2599	const GpuProgramParameters::AutoConstantDefinition* autoConstantDef =
	2600	mScriptContext.programParams->getAutoConstantDefinition(autoConstantName);
	2601
	2602	// exit with error msg if the auto constant definition wasn't found
	2603	if (!autoConstantDef)
	2604	{
	2605	logParseError("Invalid " + commandname + " attribute - "
	2606	+ autoConstantName);
	2607	return;
	2608	}
	2609
	2610	// add AutoConstant based on the type of data it uses
	2611	switch (autoConstantDef->dataType)
	2612	{
	2613	case GpuProgramParameters::ACDT_NONE:
	2614	if (isNamed)
	2615	mScriptContext.programParams->setNamedAutoConstant(paramName, autoConstantDef->acType, 0);
	2616	else
	2617	mScriptContext.programParams->setAutoConstant(index, autoConstantDef->acType, 0);
	2618	break;
	2619
	2620	case GpuProgramParameters::ACDT_INT:
	2621	{
	2622	// Special case animation_parametric, we need to keep track of number of times used
	2623	if (autoConstantDef->acType == GpuProgramParameters::ACT_ANIMATION_PARAMETRIC)
	2624	{
	2625	if (isNamed)
	2626	mScriptContext.programParams->setNamedAutoConstant(
	2627	paramName, autoConstantDef->acType, mScriptContext.numAnimationParametrics++);
	2628	else
	2629	mScriptContext.programParams->setAutoConstant(
	2630	index, autoConstantDef->acType, mScriptContext.numAnimationParametrics++);
	2631	}
	2632	// Special case texture projector - assume 0 if data not specified
	2633	else if (autoConstantDef->acType == GpuProgramParameters::ACT_TEXTURE_VIEWPROJ_MATRIX
	2634	&& getRemainingTokensForAction() == 0)
	2635	{
	2636	if (isNamed)
	2637	mScriptContext.programParams->setNamedAutoConstant(
	2638	paramName, autoConstantDef->acType, 0);
	2639	else
	2640	mScriptContext.programParams->setAutoConstant(
	2641	index, autoConstantDef->acType, 0);
	2642
	2643	}
	2644	else
	2645	{
	2646
	2647	if (getRemainingTokensForAction() != 1)
	2648	{
	2649	logParseError("Invalid " + commandname + " attribute - "
	2650	"expected 3 parameters.");
	2651	return;
	2652	}
	2653
	2654	size_t extraParam = static_cast<size_t>(getNextTokenValue());
	2655	if (isNamed)
	2656	mScriptContext.programParams->setNamedAutoConstant(
	2657	paramName, autoConstantDef->acType, extraParam);
	2658	else
	2659	mScriptContext.programParams->setAutoConstant(
	2660	index, autoConstantDef->acType, extraParam);
	2661	}
	2662	}
	2663	break;
	2664
	2665	case GpuProgramParameters::ACDT_REAL:
	2666	{
	2667	// special handling for time
	2668	if (autoConstantDef->acType == GpuProgramParameters::ACT_TIME \|\|
	2669	autoConstantDef->acType == GpuProgramParameters::ACT_FRAME_TIME)
	2670	{
	2671	Real factor = 1.0f;
	2672	if (getRemainingTokensForAction() == 1)
	2673	{
	2674	factor = getNextTokenValue();
	2675	}
	2676
	2677	if (isNamed)
	2678	mScriptContext.programParams->setNamedAutoConstantReal(
	2679	paramName, autoConstantDef->acType, factor);
	2680	else
	2681	mScriptContext.programParams->setAutoConstantReal(
	2682	index, autoConstantDef->acType, factor);
	2683	}
	2684	else // normal processing for auto constants that take an extra real value
	2685	{
	2686	if (getRemainingTokensForAction() != 1)
	2687	{
	2688	logParseError("Invalid " + commandname + " attribute - "
	2689	"expected 3 parameters.");
	2690	return;
	2691	}
	2692
	2693	const Real rData = getNextTokenValue();
	2694	if (isNamed)
	2695	mScriptContext.programParams->setNamedAutoConstantReal(
	2696	paramName, autoConstantDef->acType, rData);
	2697	else
	2698	mScriptContext.programParams->setAutoConstantReal(
	2699	index, autoConstantDef->acType, rData);
	2700	}
	2701	}
	2702	break;
	2703
	2704	} // end switch
	2705
	2706
	2707	}
	2708
	2709	//-----------------------------------------------------------------------
	2710	void MaterialScriptCompiler::parseParamIndexed(void)
	2711	{
	2712	if (mScriptContext.section == MSS_DEFAULT_PARAMETERS)
	2713	{
	2714	// save the pass2 token que position for later processing
	2715	mScriptContext.pendingDefaultParams.push_back(getPass2TokenQuePosition());
	2716	return;
	2717	}
	2718
	2719	// NB skip this if the program is not supported or could not be found
	2720	if (mScriptContext.program.isNull() \|\| !mScriptContext.program->isSupported())
	2721	{
	2722	return;
	2723	}
	2724
	2725	// Get start index
	2726	const size_t index = static_cast<size_t>(getNextTokenValue());
	2727
	2728	processManualProgramParam(false, "param_indexed", index);
	2729
	2730	}
	2731	//-----------------------------------------------------------------------
	2732	void MaterialScriptCompiler::parseParamIndexedAuto(void)
	2733	{
	2734	if (mScriptContext.section == MSS_DEFAULT_PARAMETERS)
	2735	{
	2736	// save the pass2 token que position for later processing
	2737	mScriptContext.pendingDefaultParams.push_back(getPass2TokenQuePosition());
	2738	return;
	2739	}
	2740	// NB skip this if the program is not supported or could not be found
	2741	if (mScriptContext.program.isNull() \|\| !mScriptContext.program->isSupported())
	2742	{
	2743	return;
	2744	}
	2745	// Get start index
	2746	const size_t index = static_cast<size_t>(getNextTokenValue());
	2747
	2748	processAutoProgramParam(false, "param_indexed_auto", index);
	2749
	2750	}
	2751	//-----------------------------------------------------------------------
	2752	void MaterialScriptCompiler::parseParamNamed(void)
	2753	{
	2754	if (mScriptContext.section == MSS_DEFAULT_PARAMETERS)
	2755	{
	2756	// save the pass2 token que position for later processing
	2757	mScriptContext.pendingDefaultParams.push_back(getPass2TokenQuePosition());
	2758	return;
	2759	}
	2760	// NB skip this if the program is not supported or could not be found
	2761	if (mScriptContext.program.isNull() \|\| !mScriptContext.program->isSupported())
	2762	{
	2763	return;
	2764	}
	2765
	2766	// Get start index from name
	2767	const String& paramName = getNextTokenLabel();
	2768	try {
	2769	const GpuConstantDefinition& def =
	2770	mScriptContext.programParams->getConstantDefinition(paramName);
	2771	}
	2772	catch (Exception& e)
	2773	{
	2774	logParseError("Invalid param_named attribute - " + e.getDescription());
	2775	return;
	2776	}
	2777
	2778	processManualProgramParam(true, "param_named", 0, paramName);
	2779
	2780	}
	2781	//-----------------------------------------------------------------------
	2782	void MaterialScriptCompiler::parseParamNamedAuto(void)
	2783	{
	2784	if (mScriptContext.section == MSS_DEFAULT_PARAMETERS)
	2785	{
	2786	// save the pass2 token que position for later processing
	2787	mScriptContext.pendingDefaultParams.push_back(getPass2TokenQuePosition());
	2788	return;
	2789	}
	2790	// NB skip this if the program is not supported or could not be found
	2791	if (mScriptContext.program.isNull() \|\| !mScriptContext.program->isSupported())
	2792	{
	2793	return;
	2794	}
	2795
	2796	// Get start index from name
	2797	const String& paramName = getNextTokenLabel();
	2798	try {
	2799	const GpuConstantDefinition& def =
	2800	mScriptContext.programParams->getConstantDefinition(paramName);
	2801	}
	2802	catch (Exception& e)
	2803	{
	2804	logParseError("Invalid param_named_auto attribute - " + e.getDescription());
	2805	return;
	2806	}
	2807
	2808	processAutoProgramParam(true, "param_named_auto", 0, paramName);
	2809	}
	2810	//-----------------------------------------------------------------------
	2811	void MaterialScriptCompiler::finishProgramDefinition(void)
	2812	{
	2813	// Now it is time to create the program and propagate the parameters
	2814	MaterialScriptProgramDefinition* def = mScriptContext.programDef;
	2815	GpuProgramPtr gp;
	2816
	2817	if (def->language == "asm")
	2818	{
	2819	// Native assembler
	2820	// Validate
	2821	if (def->source.empty())
	2822	{
	2823	logParseError("Invalid program definition for " + def->name +
	2824	", you must specify a source file.");
	2825	}
	2826	if (def->syntax.empty())
	2827	{
	2828	logParseError("Invalid program definition for " + def->name +
	2829	", you must specify a syntax code.");
	2830	}
	2831
	2832	/* attempt to create the gpu program. This could fail if the gpu program name is
	2833	already being used so must catch the exception and see if its possible to override
	2834	the existing gpu program.
	2835	*/
	2836	try
	2837	{
	2838	gp = GpuProgramManager::getSingleton().
	2839	createProgram(def->name, mScriptContext.groupName, def->source,
	2840	def->progType, def->syntax);
	2841	}
	2842	catch (Exception& e)
	2843	{
	2844	bool exceptionHandled = false;
	2845
	2846	// attempt recovery if exception was caused by duplicate program name found
	2847	if (mScriptContext.allowOverride && (e.getNumber() == Exception::ERR_DUPLICATE_ITEM))
	2848	{
	2849	// the gpu program already exists so unload it and then change source and syntax
	2850	// the syntax code is not checked here
	2851	gp = GpuProgramManager::getSingleton().getByName(def->name);
	2852	if (!gp.isNull())
	2853	{
	2854	if (gp->getType() == def->progType)
	2855	{
	2856	logParseError("gpu asm program: " + def->name +
	2857	", defined in " + gp->getOrigin() +
	2858	", was overwritten by current gpu program definition being parsed with same name");
	2859	gp->unload();
	2860	/* updat group ownership since the original gpu program
	2861	might have been in a different resource group
	2862	*/
	2863	gp->changeGroupOwnership(mScriptContext.groupName);
	2864	gp->setSyntaxCode(def->syntax);
	2865	gp->setSource(def->source);
	2866	// Need to do something about the existing default parameters
	2867	gp->load();
	2868	exceptionHandled = true;
	2869	}
	2870	else
	2871	{
	2872	// Don't create or override the gpu program due to incompitble program type so ignore the new definition
	2873	logParseError("gpu asm program: " + def->name + " program type conflict with current gpu program definition being parsed with same name");
	2874	}
	2875	}
	2876	}
	2877
	2878	if (!exceptionHandled)
	2879	{
	2880	// exception message already logged so no sense logging them in here and making two entries in the log
	2881	logParseError("gpu asm program: " + def->name +
	2882	" was previously defined and can not be overridden.\n"
	2883	"Material Manager script override was not enabled." );
	2884	mScriptContext.program.setNull();
	2885	mScriptContext.programParams.setNull();
	2886	}
	2887	}
	2888	}
	2889	else
	2890	{
	2891	// High-level program
	2892	// Validate
	2893	if (def->source.empty() && def->language != "unified")
	2894	{
	2895	logParseError("Invalid program definition for " + def->name +
	2896	", you must specify a source file.");
	2897	}
	2898	/* attempt to create the high level gpu program. This could fail if the gpu program name is
	2899	already being used so must catch the exception and see if its possible to override
	2900	the existing gpu program.
	2901	*/
	2902	HighLevelGpuProgramPtr hgp;
	2903	try
	2904	{
	2905	hgp = HighLevelGpuProgramManager::getSingleton().
	2906	createProgram(def->name, mScriptContext.groupName,
	2907	def->language, def->progType);
	2908	}
	2909	catch (Exception& e)
	2910	{
	2911	bool exceptionHandled = false;
	2912	// attempt recovery if exception was caused by duplicate gpu program name found
	2913	if (mScriptContext.allowOverride && (e.getNumber() == Exception::ERR_DUPLICATE_ITEM))
	2914	{
	2915	hgp = HighLevelGpuProgramManager::getSingleton().getByName(def->name);
	2916	if (!hgp.isNull())
	2917	{
	2918	// the language and program type must still be the same otherwise reuse is not possible
	2919	if ((hgp->getLanguage() != def->language) \|\| (hgp->getType() != def->progType))
	2920	{
	2921	logParseError("gpu high level program: " + def->name +
	2922	" already exists and can not be redefined with the language or program type defined in the material script");
	2923	}
	2924	else
	2925	{
	2926	logParseError("gpu high level program: " + def->name +
	2927	", defined in " + hgp->getOrigin() +
	2928	", was overwritten by current gpu program definition being parsed with same name");
	2929	// unload the previous source that was compiled
	2930	hgp->unload();
	2931	/* update group ownership since the original gpu program
	2932	might have been in a different resource group
	2933	*/
	2934	hgp->changeGroupOwnership(mScriptContext.groupName);
	2935	exceptionHandled = true;
	2936	}
	2937	}
	2938	}
	2939
	2940	if (!exceptionHandled)
	2941	{
	2942	// exception message already logged so no sense logging them in here and making two entries in the log
	2943	logParseError("gpu high level program: " + def->name +
	2944	" was previously defined and can not be overridden.\n"
	2945	"Material Manager script override was not enabled." );
	2946	mScriptContext.program.setNull();
	2947	mScriptContext.programParams.setNull();
	2948	}
	2949	}
	2950	// if the high level gpu program dosn't exist then don't continue
	2951	if (hgp.isNull())
	2952	return;
	2953
	2954	// Assign to generalised version
	2955	gp = hgp;
	2956
	2957	// Set source file
	2958	hgp->setSourceFile(def->source);
	2959
	2960	// Set custom parameters
	2961	std::vector<std::pair<String, String> >::const_iterator i, iend;
	2962	iend = def->customParameters.end();
	2963	for (i = def->customParameters.begin(); i != iend; ++i)
	2964	{
	2965	if (!hgp->setParameter(i->first, i->second))
	2966	{
	2967	logParseError("Error in program " + def->name +
	2968	" parameter " + i->first + " is not valid.");
	2969	}
	2970	}
	2971	}
	2972
	2973	// don't continue processing gpu program if it doesn't exist
	2974	if (gp.isNull())
	2975	return;
	2976
	2977	// Set skeletal animation option
	2978	gp->setSkeletalAnimationIncluded(def->supportsSkeletalAnimation);
	2979	// Set morph animation option
	2980	gp->setMorphAnimationIncluded(def->supportsMorphAnimation);
	2981	// Set pose animation option
	2982	gp->setPoseAnimationIncluded(def->supportsPoseAnimation);
	2983	// Set vertex texture usage
	2984	gp->setVertexTextureFetchRequired(def->usesVertexTextureFetch);
	2985
	2986	// set origin
	2987	gp->_notifyOrigin(mSourceName);
	2988
	2989	// Set up to receive default parameters
	2990	if (gp->isSupported()
	2991	&& !mScriptContext.pendingDefaultParams.empty())
	2992	{
	2993	mScriptContext.programParams = gp->getDefaultParameters();
	2994	mScriptContext.numAnimationParametrics = 0;
	2995	mScriptContext.program = gp;
	2996	size_t i, iend;
	2997	iend = mScriptContext.pendingDefaultParams.size();
	2998	for (i = 0; i < iend; ++i)
	2999	{
	3000	// invoke the action for the pending default param in the token que
	3001	setPass2TokenQuePosition(mScriptContext.pendingDefaultParams[i], true);
	3002	}
	3003	// Reset
	3004	mScriptContext.program.setNull();
	3005	mScriptContext.programParams.setNull();
	3006	}
	3007
	3008	}
	3009
	3010
	3011	}

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

Download in other formats: