Removed Parameters and Blocks blocks from BSL

Source/BansheeSL/BsLexerFX.l

@@ -45,71 +45,15 @@ DEFINE_EXPR		[^\r\n]*
 true			{ yylval->intValue = 1; return TOKEN_BOOLEAN; }
 false			{ yylval->intValue = 0; return TOKEN_BOOLEAN; }
 
-	/* Value types */
-
-int				{ yylval->intValue = PT_Int; return TOKEN_INTTYPE; } 
-int2			{ yylval->intValue = PT_Int2; return TOKEN_INT2TYPE; } 
-int3			{ yylval->intValue = PT_Int3; return TOKEN_INT3TYPE; } 
-int4			{ yylval->intValue = PT_Int4; return TOKEN_INT4TYPE; }
-
-float			{ yylval->intValue = PT_Float; return TOKEN_FLOATTYPE; } 
-float2			{ yylval->intValue = PT_Float2; return TOKEN_FLOAT2TYPE; } 
-float3			{ yylval->intValue = PT_Float3; return TOKEN_FLOAT3TYPE; } 
-float4			{ yylval->intValue = PT_Float4; return TOKEN_FLOAT4TYPE; }
-color			{ yylval->intValue = PT_Color; return TOKEN_COLORTYPE; }
-
-mat2x2			{ yylval->intValue = PT_Mat2x2; return TOKEN_MAT2x2TYPE; } 
-mat2x3			{ yylval->intValue = PT_Mat2x3; return TOKEN_MAT2x3TYPE; } 
-mat2x4			{ yylval->intValue = PT_Mat2x4; return TOKEN_MAT2x4TYPE; }
-
-mat3x2			{ yylval->intValue = PT_Mat3x2; return TOKEN_MAT3x2TYPE; } 
-mat3x3			{ yylval->intValue = PT_Mat3x3; return TOKEN_MAT3x3TYPE; } 
-mat3x4			{ yylval->intValue = PT_Mat3x4; return TOKEN_MAT3x4TYPE; }
-
-mat4x2			{ yylval->intValue = PT_Mat4x2; return TOKEN_MAT4x2TYPE; } 
-mat4x3			{ yylval->intValue = PT_Mat4x3; return TOKEN_MAT4x3TYPE; } 
-mat4x4			{ yylval->intValue = PT_Mat4x4; return TOKEN_MAT4x4TYPE; }
-
-Sampler1D		{ yylval->intValue = PT_Sampler1D; return TOKEN_SAMPLER1D; } 
-Sampler2D		{ yylval->intValue = PT_Sampler2D; return TOKEN_SAMPLER2D; } 
-Sampler3D		{ yylval->intValue = PT_Sampler3D; return TOKEN_SAMPLER3D; } 
-SamplerCUBE		{ yylval->intValue = PT_SamplerCUBE; return TOKEN_SAMPLERCUBE; } 
-Sampler2DMS		{ yylval->intValue = PT_Sampler2DMS; return TOKEN_SAMPLER2DMS; }
-
-Texture1D		{ yylval->intValue = PT_Texture1D; return TOKEN_TEXTURE1D; } 
-Texture2D		{ yylval->intValue = PT_Texture2D; return TOKEN_TEXTURE2D; } 
-Texture3D		{ yylval->intValue = PT_Texture3D; return TOKEN_TEXTURE3D; } 
-TextureCUBE		{ yylval->intValue = PT_TextureCUBE; return TOKEN_TEXTURECUBE; } 
-Texture2DMS		{ yylval->intValue = PT_Texture2DMS; return TOKEN_TEXTURE2DMS; }
-
-RWTexture1D		{ yylval->intValue = PT_RWTexture1D; return TOKEN_RWTEXTURE1D; } 
-RWTexture2D		{ yylval->intValue = PT_RWTexture2D; return TOKEN_RWTEXTURE2D; } 
-RWTexture3D		{ yylval->intValue = PT_RWTexture3D; return TOKEN_RWTEXTURE3D; } 
-RWTexture2DMS	{ yylval->intValue = PT_RWTexture2DMS; return TOKEN_RWTEXTURE2DMS; }
-
-ByteBuffer		{ yylval->intValue = PT_ByteBuffer; return TOKEN_BYTEBUFFER; } 
-StructBuffer	{ yylval->intValue = PT_StructBuffer; return TOKEN_STRUCTBUFFER; } 
-
-RWTypedBuffer	{ yylval->intValue = PT_TypedBufferRW; return TOKEN_RWTYPEDBUFFER; } 
-RWByteBuffer	{ yylval->intValue = PT_ByteBufferRW; return TOKEN_RWBYTEBUFFER; }
-RWStructBuffer	{ yylval->intValue = PT_StructBufferRW; return TOKEN_RWSTRUCTBUFFER; } 
-AppendBuffer	{ yylval->intValue = PT_AppendBuffer; return TOKEN_RWAPPENDBUFFER; } 
-ConsumeBuffer	{ yylval->intValue = PT_ConsumeBuffer; return TOKEN_RWCONSUMEBUFFER; }
-
-Block			{ return TOKEN_PARAMSBLOCK; }
-
 	/* Shader keywords */
 Separable		{ return TOKEN_SEPARABLE; }
 Sort			{ return TOKEN_SORT; }
 Priority		{ return TOKEN_PRIORITY; }
 Transparent		{ return TOKEN_TRANSPARENT; }
 Technique		{ return TOKEN_TECHNIQUE; }
-Parameters		{ return TOKEN_PARAMETERS; }
-Blocks			{ return TOKEN_BLOCKS; }
 
 	/* Technique keywords */
 Renderer		{ return TOKEN_RENDERER; }
-Language		{ return TOKEN_LANGUAGE; }
 Tags			{ return TOKEN_TAGS; }
 Pass			{ return TOKEN_PASS; }
 
@@ -151,25 +95,7 @@ Source				{ return TOKEN_SOURCE; }
 Dest				{ return TOKEN_DEST; }
 Op					{ return TOKEN_OP; }
 
-	/* Sampler state keywords */
-AddressMode			{ return TOKEN_ADDRMODE; }
-MinFilter			{ return TOKEN_MINFILTER; }
-MagFilter			{ return TOKEN_MAGFILTER; }
-MipFilter			{ return TOKEN_MIPFILTER; }
-MaxAniso			{ return TOKEN_MAXANISO; }
-MipmapBias			{ return TOKEN_MIPBIAS; }
-MipMin				{ return TOKEN_MIPMIN; }
-MipMax				{ return TOKEN_MIPMAX; }
-BorderColor			{ return TOKEN_BORDERCOLOR; }
-U					{ return TOKEN_U; }
-V					{ return TOKEN_V; }
-W					{ return TOKEN_W; }
-
 	/* Qualifiers */
-auto				{ return TOKEN_AUTO; }
-alias				{ return TOKEN_ALIAS; }
-shared				{ return TOKEN_SHARED; }
-usage				{ return TOKEN_USAGE; }
 base				{ return TOKEN_BASE; }
 inherits			{ return TOKEN_INHERITS; }
 
@@ -231,22 +157,6 @@ RBA				{ yylval->intValue = 0xD; return TOKEN_COLORMASK; }
 GBA				{ yylval->intValue = 0xE; return TOKEN_COLORMASK; }
 RGBA			{ yylval->intValue = 0xF; return TOKEN_COLORMASK; }
 
-WRAP			{ yylval->intValue = AMV_Wrap; return TOKEN_ADDRMODEVALUE; }
-MIRROR			{ yylval->intValue = AMV_Mirror; return TOKEN_ADDRMODEVALUE; }
-CLAMP			{ yylval->intValue = AMV_Clamp; return TOKEN_ADDRMODEVALUE; }
-BORDER			{ yylval->intValue = AMV_Border; return TOKEN_ADDRMODEVALUE; }
-
-NOFILTER		{ yylval->intValue = FV_None; return TOKEN_FILTERVALUE; }
-POINT			{ yylval->intValue = FV_Point; return TOKEN_FILTERVALUE; }
-LINEAR			{ yylval->intValue = FV_Linear; return TOKEN_FILTERVALUE; }
-ANISO			{ yylval->intValue = FV_Anisotropic; return TOKEN_FILTERVALUE; }
-POINTC			{ yylval->intValue = FV_PointCmp; return TOKEN_FILTERVALUE; }
-LINEARC			{ yylval->intValue = FV_LinearCmp; return TOKEN_FILTERVALUE; }
-ANISOC			{ yylval->intValue = FV_AnisotropicCmp; return TOKEN_FILTERVALUE; }
-
-STATIC			{ yylval->intValue = BUV_Static; return TOKEN_BUFFERUSAGE; }
-DYNAMIC			{ yylval->intValue = BUV_Dynamic; return TOKEN_BUFFERUSAGE; }
-
 FRONTTOBACK		{ yylval->intValue = QST_FrontToBack; return TOKEN_QUEUETYPE; }
 BACKTOFRONT		{ yylval->intValue = QST_BackToFront; return TOKEN_QUEUETYPE; }
 NOSORT			{ yylval->intValue = QST_None; return TOKEN_QUEUETYPE; }

Source/BansheeSL/BsParserFX.y

@@ -42,22 +42,7 @@ typedef struct YYLTYPE {
 			(Current).filename = NULL;																\
 		}																							\
 	while (0)
-
-#define ADD_PARAMETER(OUTPUT, TYPE, NAME)															\
-			OUTPUT = nodeCreate(parse_state->memContext, NT_Parameter);								\
-			nodePush(parse_state, OUTPUT);															\
-																									\
-			NodeOption paramType;																	\
-			paramType.type = OT_ParamType;															\
-			paramType.value.intValue = TYPE;														\
-																									\
-			NodeOption paramName;																	\
-			paramName.type = OT_Identifier;															\
-			paramName.value.strValue = NAME;														\
-																									\
-			nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &paramType);		\
-			nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &paramName);		\
-
+	
 }
 
 %output  "BsParserFX.c"
@@ -92,70 +77,18 @@ typedef struct YYLTYPE {
 %token <intValue>	TOKEN_COMPFUNCVALUE
 %token <intValue>	TOKEN_OPVALUE
 %token <intValue>	TOKEN_COLORMASK
-%token <intValue>	TOKEN_ADDRMODEVALUE
-%token <intValue>	TOKEN_FILTERVALUE
 %token <intValue>	TOKEN_BLENDOPVALUE
-%token <intValue>	TOKEN_BUFFERUSAGE
 %token <intValue>	TOKEN_QUEUETYPE
 
-%token <intValue> TOKEN_FLOATTYPE 
-%token <intValue> TOKEN_FLOAT2TYPE 
-%token <intValue> TOKEN_FLOAT3TYPE 
-%token <intValue> TOKEN_FLOAT4TYPE
-%token <intValue> TOKEN_INTTYPE 
-%token <intValue> TOKEN_INT2TYPE 
-%token <intValue> TOKEN_INT3TYPE 
-%token <intValue> TOKEN_INT4TYPE
-%token <intValue> TOKEN_COLORTYPE
-
-%token <intValue> TOKEN_MAT2x2TYPE 
-%token <intValue> TOKEN_MAT2x3TYPE 
-%token <intValue> TOKEN_MAT2x4TYPE
-
-%token <intValue> TOKEN_MAT3x2TYPE 
-%token <intValue> TOKEN_MAT3x3TYPE 
-%token <intValue> TOKEN_MAT3x4TYPE
-
-%token <intValue> TOKEN_MAT4x2TYPE 
-%token <intValue> TOKEN_MAT4x3TYPE 
-%token <intValue> TOKEN_MAT4x4TYPE
-
-%token <intValue> TOKEN_SAMPLER1D 
-%token <intValue> TOKEN_SAMPLER2D 
-%token <intValue> TOKEN_SAMPLER3D 
-%token <intValue> TOKEN_SAMPLERCUBE 
-%token <intValue> TOKEN_SAMPLER2DMS
-
-%token <intValue> TOKEN_TEXTURE1D 
-%token <intValue> TOKEN_TEXTURE2D 
-%token <intValue> TOKEN_TEXTURE3D 
-%token <intValue> TOKEN_TEXTURECUBE 
-%token <intValue> TOKEN_TEXTURE2DMS
-
-%token <intValue> TOKEN_RWTEXTURE1D 
-%token <intValue> TOKEN_RWTEXTURE2D 
-%token <intValue> TOKEN_RWTEXTURE3D 
-%token <intValue> TOKEN_RWTEXTURE2DMS
-
-%token <intValue> TOKEN_BYTEBUFFER 
-%token <intValue> TOKEN_STRUCTBUFFER 
-%token <intValue> TOKEN_RWTYPEDBUFFER 
-%token <intValue> TOKEN_RWBYTEBUFFER
-%token <intValue> TOKEN_RWSTRUCTBUFFER 
-%token <intValue> TOKEN_RWAPPENDBUFFER 
-%token <intValue> TOKEN_RWCONSUMEBUFFER
-
-%token TOKEN_PARAMSBLOCK
-
 	/* Qualifiers */
-%token TOKEN_AUTO TOKEN_ALIAS TOKEN_SHARED TOKEN_USAGE TOKEN_BASE TOKEN_INHERITS
+%token TOKEN_BASE TOKEN_INHERITS
 
 	/* Shader keywords */
 %token TOKEN_SEPARABLE TOKEN_SORT TOKEN_PRIORITY TOKEN_TRANSPARENT
-%token TOKEN_PARAMETERS TOKEN_BLOCKS TOKEN_TECHNIQUE
+%token TOKEN_TECHNIQUE
 
 	/* Technique keywords */
-%token	TOKEN_RENDERER TOKEN_LANGUAGE TOKEN_PASS TOKEN_TAGS
+%token	TOKEN_RENDERER TOKEN_PASS TOKEN_TAGS
 
 	/* Pass keywords */
 %token	TOKEN_VERTEX TOKEN_FRAGMENT TOKEN_GEOMETRY TOKEN_HULL TOKEN_DOMAIN TOKEN_COMPUTE TOKEN_COMMON
@@ -172,11 +105,6 @@ typedef struct YYLTYPE {
 %token	TOKEN_BLEND TOKEN_COLOR TOKEN_ALPHA TOKEN_WRITEMASK
 %token	TOKEN_SOURCE TOKEN_DEST TOKEN_OP
 
-	/* Sampler state keywords */
-%token	TOKEN_ADDRMODE TOKEN_MINFILTER TOKEN_MAGFILTER TOKEN_MIPFILTER
-%token	TOKEN_MAXANISO TOKEN_MIPBIAS TOKEN_MIPMIN TOKEN_MIPMAX
-%token	TOKEN_BORDERCOLOR TOKEN_U TOKEN_V TOKEN_W
-
 %type <nodePtr>		shader;
 %type <nodeOption>	shader_statement;
 %type <nodeOption>	shader_option;
@@ -209,75 +137,8 @@ typedef struct YYLTYPE {
 %type <nodePtr>		blend_alpha_header;
 %type <nodeOption>	blenddef_option;
 
-%type <nodeOption>	sampler_state_option;
-
-%type <nodePtr>		addr_mode;
-%type <nodePtr>		addr_mode_header;
-%type <nodeOption>	addr_mode_option;
-
-%type <nodePtr> parameters
-%type <nodePtr> parameters_header
-%type <nodeOption> parameter
-
-%type <nodePtr> block_header
-%type <nodeOption> block
-%type <nodePtr> blocks_header
-%type <nodePtr> blocks
-
-%type <nodeOption> qualifier
 %type <nodeOption> technique_qualifier
 
-%type <matrixValue> float2;
-%type <matrixValue> float3;
-%type <matrixValue> float4;
-%type <intVectorValue> int2;
-%type <intVectorValue> int3;
-%type <intVectorValue> int4;
-%type <matrixValue> mat6;
-%type <matrixValue> mat8;
-%type <matrixValue> mat9;
-%type <matrixValue> mat12;
-%type <matrixValue> mat16;
-
-%type <nodePtr> param_header_float
-%type <nodePtr> param_header_float2
-%type <nodePtr> param_header_float3
-%type <nodePtr> param_header_float4
-%type <nodePtr> param_header_int
-%type <nodePtr> param_header_int2
-%type <nodePtr> param_header_int3
-%type <nodePtr> param_header_int4
-%type <nodePtr> param_header_color
-%type <nodePtr> param_header_mat2x2
-%type <nodePtr> param_header_mat2x3
-%type <nodePtr> param_header_mat2x4
-%type <nodePtr> param_header_mat3x2
-%type <nodePtr> param_header_mat3x3
-%type <nodePtr> param_header_mat3x4
-%type <nodePtr> param_header_mat4x2
-%type <nodePtr> param_header_mat4x3
-%type <nodePtr> param_header_mat4x4
-%type <nodePtr> param_header_sampler
-%type <nodePtr> param_header_texture
-%type <nodePtr> param_header_buffer
-%type <nodePtr> param_header_qualified_sampler
-
-%type <nodeOption> param_body_float
-%type <nodeOption> param_body_float2
-%type <nodeOption> param_body_float3
-%type <nodeOption> param_body_float4
-%type <nodeOption> param_body_int
-%type <nodeOption> param_body_int2
-%type <nodeOption> param_body_int3
-%type <nodeOption> param_body_int4
-%type <nodeOption> param_body_mat6
-%type <nodeOption> param_body_mat8
-%type <nodeOption> param_body_mat9
-%type <nodeOption> param_body_mat12
-%type <nodeOption> param_body_mat16
-%type <nodeOption> param_body_sampler
-%type <nodeOption> param_body_tex
-
 %%
 
 	/* Shader */
@@ -290,8 +151,6 @@ shader
 shader_statement
 	: shader_option
 	| technique			{ $$.type = OT_Technique; $$.value.nodePtr = $1; }
-	| parameters		{ $$.type = OT_Parameters; $$.value.nodePtr = $1; }
-	| blocks			{ $$.type = OT_Blocks; $$.value.nodePtr = $1; }
 	;
 
 shader_option
@@ -329,7 +188,6 @@ technique_statement
 
 technique_option
 	: TOKEN_RENDERER '=' TOKEN_STRING ';'	{ $$.type = OT_Renderer; $$.value.strValue = $3; }
-	| TOKEN_LANGUAGE '=' TOKEN_STRING ';'	{ $$.type = OT_Language; $$.value.strValue = $3; }
 	| tags									{ $$.type = OT_Tags; $$.value.nodePtr = $1; }
 	;
 	
@@ -593,431 +451,6 @@ blenddef_option
 	| TOKEN_OP '=' TOKEN_BLENDOPVALUE ';'					{ $$.type = OT_Op; $$.value.intValue = $3; }
 	;
 
-	/* Sampler state */
-
-sampler_state_body
-	: /* empty */
-	| sampler_state_option sampler_state_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
-	;
-
-sampler_state_option
-	: addr_mode												{ $$.type = OT_AddrMode; $$.value.nodePtr = $1; }
-	| TOKEN_MINFILTER '=' TOKEN_FILTERVALUE ';'				{ $$.type = OT_MinFilter; $$.value.intValue = $3; }
-	| TOKEN_MAGFILTER '=' TOKEN_FILTERVALUE ';'				{ $$.type = OT_MagFilter; $$.value.intValue = $3; }
-	| TOKEN_MIPFILTER '=' TOKEN_FILTERVALUE ';'				{ $$.type = OT_MipFilter; $$.value.intValue = $3; }
-	| TOKEN_MAXANISO '=' TOKEN_INTEGER ';'					{ $$.type = OT_MaxAniso; $$.value.intValue = $3; }
-	| TOKEN_MIPBIAS '=' TOKEN_FLOAT ';'						{ $$.type = OT_MipBias; $$.value.floatValue = $3; }
-	| TOKEN_MIPMIN '=' TOKEN_FLOAT ';'						{ $$.type = OT_MipMin; $$.value.floatValue = $3; }
-	| TOKEN_MIPMAX '=' TOKEN_FLOAT ';'						{ $$.type = OT_MipMax; $$.value.floatValue = $3; }
-	| TOKEN_BORDERCOLOR '=' float4 ';'						{ $$.type = OT_BorderColor; memcpy($$.value.matrixValue, $3, sizeof($3)); }
-	| TOKEN_COMPAREFUNC '=' TOKEN_COMPFUNCVALUE ';'			{ $$.type = OT_CompareFunc; $$.value.intValue = $3; }
-	;
-
-	/* Addresing mode */
-addr_mode
-	: addr_mode_header '{' addr_mode_body '}' ';'		{ nodePop(parse_state); $$ = $1; }
-	| addr_mode_header '{' addr_mode_body_init '}' ';'	{ nodePop(parse_state); $$ = $1; }
-	;
-
-addr_mode_header
-	: TOKEN_ADDRMODE '='
-		{ 
-			$$ = nodeCreate(parse_state->memContext, NT_AddrMode); 
-			nodePush(parse_state, $$);
-		}
-	;
-
-addr_mode_body_init
-	: TOKEN_ADDRMODEVALUE ',' TOKEN_ADDRMODEVALUE ',' TOKEN_ADDRMODEVALUE
-		{
-			NodeOption u; u.type = OT_U; u.value.intValue = $1;
-			NodeOption v; v.type = OT_V; v.value.intValue = $3;
-			NodeOption w; w.type = OT_W; w.value.intValue = $5;
-
-			nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &u);
-			nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &v);
-			nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &w);
-		}
-	;
-
-addr_mode_body
-	: /* empty */
-	| addr_mode_option addr_mode_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
-	;
-
-addr_mode_option
-	: TOKEN_U '=' TOKEN_ADDRMODEVALUE ';'					{ $$.type = OT_U; $$.value.intValue = $3; }
-	| TOKEN_V '=' TOKEN_ADDRMODEVALUE ';'					{ $$.type = OT_V; $$.value.intValue = $3; }
-	| TOKEN_W '=' TOKEN_ADDRMODEVALUE ';'					{ $$.type = OT_W; $$.value.intValue = $3; }
-	;
-
-	/* Value types */
-float2
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT '}'	{ $$[0] = $2; $$[1] = $4; }
-	;
-
-float3
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT '}'	{ $$[0] = $2; $$[1] = $4; $$[2] = $6; }
-	;
-
-float4
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT '}'	{ $$[0] = $2; $$[1] = $4; $$[2] = $6; $$[3] = $8;}
-	;
-
-int2
-	: '{' TOKEN_INTEGER ',' TOKEN_INTEGER '}'	{ $$[0] = $2; $$[1] = $4; }
-	;
-
-int3
-	: '{' TOKEN_INTEGER ',' TOKEN_INTEGER ',' TOKEN_INTEGER '}'	{ $$[0] = $2; $$[1] = $4; $$[2] = $6; }
-	;
-
-int4
-	: '{' TOKEN_INTEGER ',' TOKEN_INTEGER ',' TOKEN_INTEGER ',' TOKEN_INTEGER '}'	{ $$[0] = $2; $$[1] = $4; $$[2] = $6; $$[3] = $8;}
-	;
-
-mat6
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT '}'	
-		{ 
-			$$[0] = $2; $$[1] = $4; $$[2] = $6; 
-			$$[3] = $8; $$[4] = $10; $$[5] = $12;
-		}
-	;
-
-mat8
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT '}'	
-		{ 
-			$$[0] = $2; $$[1] = $4; $$[2] = $6; 
-			$$[3] = $8; $$[4] = $10; $$[5] = $12;
-			$$[6] = $14; $$[7] = $16;
-		}
-	;
-
-mat9
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT '}'	
-		{ 
-			$$[0] = $2; $$[1] = $4; $$[2] = $6; 
-			$$[3] = $8; $$[4] = $10; $$[5] = $12;
-			$$[6] = $14; $$[7] = $16; $$[8] = $18;
-		}
-	;
-
-mat12
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT '}'	
-		{ 
-			$$[0] = $2; $$[1] = $4; $$[2] = $6; $$[3] = $8; 
-			$$[4] = $10; $$[5] = $12; $$[6] = $14; $$[7] = $16; 
-			$$[8] = $18; $$[9] = $20; $$[10] = $22; $$[11] = $24;
-		}
-	;
-
-mat16
-	: '{' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' 
-		  TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT ',' TOKEN_FLOAT '}'	
-		{ 
-			$$[0] = $2; $$[1] = $4; $$[2] = $6; $$[3] = $8; 
-			$$[4] = $10; $$[5] = $12; $$[6] = $14; $$[7] = $16; 
-			$$[8] = $18; $$[9] = $20; $$[10] = $22; $$[11] = $24;
-			$$[12] = $26; $$[13] = $28; $$[14] = $30; $$[15] = $32;
-		}
-	;
-
-	/* Parameters */
-parameters
-	: parameters_header '{' parameters_body '}' ';' { nodePop(parse_state); $$ = $1; }
-	;
-
-parameters_header
-	: TOKEN_PARAMETERS '='
-		{ 
-			$$ = nodeCreate(parse_state->memContext, NT_Parameters); 
-			nodePush(parse_state, $$);
-		}
-	;
-
-parameters_body
-	: /* empty */
-	| parameter parameters_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
-	;
-
-parameter
-	: param_header_float	qualifier_list param_body_float		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_float2	qualifier_list param_body_float2	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_float3	qualifier_list param_body_float3	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_float4	qualifier_list param_body_float4	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_int		qualifier_list param_body_int		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_int2		qualifier_list param_body_int2		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_int3		qualifier_list param_body_int3		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_int4		qualifier_list param_body_int4		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_color	qualifier_list param_body_float4	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat2x2	qualifier_list param_body_float4	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat2x3	qualifier_list param_body_mat6		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat2x4	qualifier_list param_body_mat8		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat3x2	qualifier_list param_body_mat6		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat3x3	qualifier_list param_body_mat9		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat3x4	qualifier_list param_body_mat12		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat4x2	qualifier_list param_body_mat8		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat4x3	qualifier_list param_body_mat12		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_mat4x4	qualifier_list param_body_mat16		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_texture	qualifier_list param_body_tex		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_buffer	qualifier_list						';' { nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
-	| param_header_qualified_sampler		param_body_sampler	';' 
-		{ 
-			nodePop(parse_state);
-
-			NodeOption samplerState;
-			samplerState.type = OT_SamplerState;
-			samplerState.value.nodePtr = $1;
-
-			nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &samplerState); 
-
-			$$.type = OT_Parameter; $$.value.nodePtr = parse_state->topNode; 
-			nodePop(parse_state); 
-		}
-	;
-
-param_header_float 
-	: TOKEN_FLOATTYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_float2
-	: TOKEN_FLOAT2TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_float3
-	: TOKEN_FLOAT3TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_float4 
-	: TOKEN_FLOAT4TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_int 
-	: TOKEN_INTTYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_int2
-	: TOKEN_INT2TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_int3
-	: TOKEN_INT3TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_int4
-	: TOKEN_INT4TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_color
-	: TOKEN_COLORTYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat2x2
-	: TOKEN_MAT2x2TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat2x3
-	: TOKEN_MAT2x3TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat2x4
-	: TOKEN_MAT2x4TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat3x2
-	: TOKEN_MAT3x2TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat3x3
-	: TOKEN_MAT3x3TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat3x4
-	: TOKEN_MAT3x4TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat4x2
-	: TOKEN_MAT4x2TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat4x3
-	: TOKEN_MAT4x3TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_mat4x4
-	: TOKEN_MAT4x4TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_sampler
-	: TOKEN_SAMPLER1D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_SAMPLER2D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_SAMPLER3D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_SAMPLERCUBE		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_SAMPLER2DMS		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_texture
-	: TOKEN_TEXTURE1D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_TEXTURE2D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_TEXTURE3D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_TEXTURECUBE		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_TEXTURE2DMS		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWTEXTURE1D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWTEXTURE2D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWTEXTURE3D		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWTEXTURE2DMS	TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_buffer
-	: TOKEN_BYTEBUFFER		TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_STRUCTBUFFER	TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWTYPEDBUFFER	TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWBYTEBUFFER	TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWSTRUCTBUFFER	TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWAPPENDBUFFER	TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	| TOKEN_RWCONSUMEBUFFER TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
-	;
-
-param_header_qualified_sampler
-	: param_header_sampler qualifier_list	
-		{ 
-			$$ = nodeCreate(parse_state->memContext, NT_SamplerState); 
-			nodePush(parse_state, $$);
-		}
-	;
-
-param_body_float 
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' TOKEN_FLOAT	{ $$.type = OT_ParamValue; $$.value.floatValue = $2; }
-	;
-
-param_body_float2
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' float2		{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_float3
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' float3		{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_float4
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' float4		{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_int
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' TOKEN_INTEGER	{ $$.type = OT_ParamValue; $$.value.intValue = $2; }
-	;
-
-param_body_int2
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' int2			{ $$.type = OT_ParamValue; memcpy($$.value.intVectorValue, $2, sizeof($2)); }
-	;
-
-param_body_int3
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' int3			{ $$.type = OT_ParamValue; memcpy($$.value.intVectorValue, $2, sizeof($2)); }
-	;
-
-param_body_int4
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' int4			{ $$.type = OT_ParamValue; memcpy($$.value.intVectorValue, $2, sizeof($2)); }
-	;
-
-param_body_mat6
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' mat6			{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_mat8
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' mat8			{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_mat9
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' mat9			{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_mat12
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' mat12			{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_mat16
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' mat16			{ $$.type = OT_ParamValue; memcpy($$.value.matrixValue, $2, sizeof($2)); }
-	;
-
-param_body_sampler
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' '{' sampler_state_body '}' { }
-	;
-
-param_body_tex
-	: /* empty */		{ $$.type = OT_None; }
-	| '=' TOKEN_STRING	{ $$.type = OT_ParamStrValue; $$.value.strValue = $2; }
-	;
-
-	/* Blocks */
-blocks
-	: blocks_header '{' blocks_body '}' ';' { nodePop(parse_state); $$ = $1; }
-	;
-
-blocks_header
-	: TOKEN_BLOCKS '='
-		{ 
-			$$ = nodeCreate(parse_state->memContext, NT_Blocks); 
-			nodePush(parse_state, $$);
-		}
-	;
-
-blocks_body
-	: /* empty */
-	| block blocks_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
-	;
-
-block
-	: block_header qualifier_list ';' { nodePop(parse_state); $$.type = OT_Block; $$.value.nodePtr = $1; }
-	;
-
-block_header
-	: TOKEN_PARAMSBLOCK TOKEN_IDENTIFIER
-		{
-			$$ = nodeCreate(parse_state->memContext, NT_Block);
-			nodePush(parse_state, $$);
-
-			NodeOption blockName;
-			blockName.type = OT_Identifier;
-			blockName.value.strValue = $2;
-
-			nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &blockName);
-		}
-	;
-
-	/* Qualifiers */
-qualifier_list
-	: /* empty */
-	| qualifier qualifier_list		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
-	;
-
-qualifier
-	: ':' TOKEN_ALIAS '(' TOKEN_STRING ')'		{ $$.type = OT_Alias; $$.value.strValue = $4; }
-	| ':' TOKEN_AUTO '(' TOKEN_STRING ')'		{ $$.type = OT_Auto; $$.value.strValue = $4; }
-	| ':' TOKEN_SHARED '(' TOKEN_BOOLEAN ')'	{ $$.type = OT_Shared; $$.value.intValue = $4; }
-	| ':' TOKEN_USAGE '(' TOKEN_BUFFERUSAGE ')'	{ $$.type = OT_Usage; $$.value.intValue = $4; }
-	;
 %%
 
 void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const char *msg) 

Source/BansheeSL/Include/BsASTFX.h

@@ -10,16 +10,11 @@ enum tagNodeType
 {
 	NT_Shader,
 	NT_Technique,
-	NT_Parameters,
-	NT_Blocks,
 	NT_Pass,
 	NT_StencilOp,
 	NT_Target,
 	NT_BlendDef,
-	NT_SamplerState,
 	NT_AddrMode,
-	NT_Parameter,
-	NT_Block,
 	NT_Tags,
 	NT_CodeVertex,
 	NT_CodeFragment,
@@ -39,7 +34,6 @@ enum tagOptionType
 	OT_Transparent,
 	OT_Technique,
 	OT_Renderer,
-	OT_Language,
 	OT_Pass,
 	OT_FillMode,
 	OT_CullMode,
@@ -71,31 +65,7 @@ enum tagOptionType
 	OT_Source,
 	OT_Dest,
 	OT_Op,
-	OT_AddrMode,
-	OT_MinFilter,
-	OT_MagFilter,
-	OT_MipFilter,
-	OT_MaxAniso,
-	OT_MipBias,
-	OT_MipMin,
-	OT_MipMax,
-	OT_BorderColor,
-	OT_U,
-	OT_V,
-	OT_W,
-	OT_Alias,
-	OT_Auto,
-	OT_Shared,
-	OT_Usage,
-	OT_ParamType,
 	OT_Identifier,
-	OT_ParamValue,
-	OT_ParamStrValue,
-	OT_Parameters,
-	OT_Blocks,
-	OT_Parameter,
-	OT_Block,
-	OT_SamplerState,
 	OT_Code,
 	OT_StencilRef,
 	OT_Tags,
@@ -115,21 +85,6 @@ enum tagOptionDataType
 	ODT_Matrix
 };
 
-enum tagParamType
-{
-	PT_Float, PT_Float2, PT_Float3, PT_Float4, 
-	PT_Int, PT_Int2, PT_Int3, PT_Int4, PT_Color,
-	PT_Mat2x2, PT_Mat2x3, PT_Mat2x4,
-	PT_Mat3x2, PT_Mat3x3, PT_Mat3x4,
-	PT_Mat4x2, PT_Mat4x3, PT_Mat4x4,
-	PT_Sampler1D, PT_Sampler2D, PT_Sampler3D, PT_SamplerCUBE, PT_Sampler2DMS,
-	PT_Texture1D, PT_Texture2D, PT_Texture3D, PT_TextureCUBE, PT_Texture2DMS,
-	PT_RWTexture1D, PT_RWTexture2D, PT_RWTexture3D, PT_RWTexture2DMS,
-	PT_ByteBuffer, PT_StructBuffer, PT_ByteBufferRW, PT_StructBufferRW,
-	PT_TypedBufferRW, PT_AppendBuffer, PT_ConsumeBuffer,
-	PT_Count // Keep at end
-};
-
 enum tagFillModeValue 
 { 
 	FMV_Wire, FMV_Solid 
@@ -160,22 +115,6 @@ enum tagBlendOpValue
 	BOV_Min, BOV_Max 
 };
 
-enum tagAddrModeValue
-{
-	AMV_Wrap, AMV_Mirror, AMV_Clamp, AMV_Border
-};
-
-enum tagFilterValue 
-{ 
-	FV_None, FV_Point, FV_Linear, FV_Anisotropic, 
-	FV_PointCmp, FV_LinearCmp, FV_AnisotropicCmp 
-};
-
-enum tagBufferUsageValue 
-{ 
-	BUV_Static, BUV_Dynamic 
-};
-
 enum tagQueueSortTypeValue
 {
 	QST_FrontToBack, QST_BackToFront, QST_None
@@ -184,7 +123,6 @@ enum tagQueueSortTypeValue
 typedef enum tagNodeType NodeType;
 typedef enum tagOptionType OptionType;
 typedef enum tagOptionDataType OptionDataType;
-typedef enum tagParamType ParamType;
 typedef struct tagParseState ParseState;
 typedef struct tagOptionInfo OptionInfo;
 typedef union tagOptionData OptionData;
@@ -202,9 +140,6 @@ typedef enum tagCullModeValue CullModeValue;
 typedef enum tagCompFuncValue CompFuncValue;
 typedef enum tagOpValue OpValue;
 typedef enum tagBlendOpValue BlendOpValue;
-typedef enum tagAddrModeValue AddrModeValue;
-typedef enum tagFilterValue FilterValue;
-typedef enum tagBufferUsageValue BufferUsageValue;
 typedef enum tagQueueSortTypeValue QueueSortTypeValue;
 
 struct tagNodeLink

Source/BansheeSL/Include/BsSLFXCompiler.h

@@ -93,40 +93,18 @@ namespace bs
 		/**	Converts FX renderer name into an in-engine renderer identifier. */
 		static StringID parseRenderer(const String& name);
 
-		/** Converts FX language string into an in-engine shader language string (for example hlsl, glsl). */
-		static void parseLanguage(const String& name, String& language);
-
-		/**	Maps FX buffer usage enum into in-engine param block usage. */
-		static GpuParamBlockUsage parseBlockUsage(BufferUsageValue usage);
-
-		/**	Maps FX filter mode enum into in-engine filter mode. */
-		static UINT32 parseFilterMode(FilterValue filter);
-
 		/**	Maps FX queue sort type enum into in-engine queue sort type mode. */
 		static QueueSortType parseSortType(QueueSortTypeValue sortType);
 
 		/**	Maps FX comparison function enum into in-engine compare function. */
 		static CompareFunction parseCompFunc(CompFuncValue compFunc);
 
-		/**	Maps FX addressing mode enum into in-engine addressing mode. */
-		static TextureAddressingMode parseAddrMode(AddrModeValue addrMode);
-
 		/**	Maps FX operation to in-engine blend factor. */
 		static BlendFactor parseBlendFactor(OpValue factor);
 
 		/**	Maps FX blend operation to in-engine blend operation. */
 		static BlendOperation parseBlendOp(BlendOpValue op);
 
-		/**
-		 * Maps FX parameter type to in-engine shader parameter.
-		 *
-		 * @param[in]	type		Input FX parameter type.
-		 * @param[in]	isObjType	Output parameter signaling whether the in-engine parameter is a data or an object type.
-		 * @param[in]	typeId		Type ID corresponding to a value of in-game GpuParamDataType or GpuParamObjectType
-		 *							enum (depending on isObjType()).
-		 */
-		static void parseParamType(ParamType type, bool& isObjType, UINT32& typeId);
-
 		/**	Maps FX operation to in-engine stencil operation. */
 		static StencilOperation parseStencilOp(OpValue op);
 		
@@ -148,12 +126,6 @@ namespace bs
 		 */
 		static void parseStencilBack(DEPTH_STENCIL_STATE_DESC& desc, ASTFXNode* stencilOpNode);
 
-		/**
-		 * Populates the addressing mode portion of the sampler state descriptor for U/V/W axes from the provided addressing
-		 * mode AST node.
-		 */
-		static void parseAddrMode(SAMPLER_STATE_DESC& desc, ASTFXNode* addrModeNode);
-
 		/** Populates the color (RGB) portion of the blend state descriptor from the provided blend definition AST node. */
 		static void parseColorBlendDef(RENDER_TARGET_BLEND_STATE_DESC& desc, ASTFXNode* blendDefNode);
 
@@ -184,9 +156,6 @@ namespace bs
 		 */
 		static bool parseDepthStencilState(DEPTH_STENCIL_STATE_DESC& desc, ASTFXNode* passNode);
 
-		/** Parses the sampler state AST node and outputs a sampler state object, or a nullptr in case AST node is empty. */
-		static SPtr<SamplerState> parseSamplerState(ASTFXNode* samplerStateNode);
-
 		/**
 		 * Parses a code AST node and outputs the result in one of the streams within the provided pass data.
 		 *
@@ -216,18 +185,6 @@ namespace bs
 		 */
 		static void parseTechnique(ASTFXNode* techniqueNode, const Vector<String>& codeBlocks, TechniqueData& techniqueData);
 
-		/**
-		 * Parses the parameters AST node and populates the shader descriptor with information about GPU program parameters
-		 * and their default values.
-		 */
-		static void parseParameters(SHADER_DESC& desc, ASTFXNode* parametersNode);
-
-		/**
-		 * Parses the blocks AST node and populates the shader descriptor with information about GPU program parameter 
-		 * blocks.
-		 */
-		static void parseBlocks(SHADER_DESC& desc, ASTFXNode* blocksNode);
-
 		/**
 		 * Parses the AST node hierarchy and generates a shader object.
 		 *

Source/BansheeSL/Source/BsASTFX.c

@@ -13,7 +13,6 @@ OptionInfo OPTION_LOOKUP[] =
 	{ OT_Transparent, ODT_Bool },
 	{ OT_Technique, ODT_Complex }, 
 	{ OT_Renderer, ODT_String }, 
-	{ OT_Language, ODT_String }, 
 	{ OT_Pass, ODT_Complex }, 
 	{ OT_FillMode, ODT_Int }, 
 	{ OT_CullMode, ODT_Int },
@@ -45,31 +44,7 @@ OptionInfo OPTION_LOOKUP[] =
 	{ OT_Source, ODT_Int },
 	{ OT_Dest, ODT_Int },
 	{ OT_Op, ODT_Int },
-	{ OT_AddrMode, ODT_Complex },
-	{ OT_MinFilter, ODT_Int },
-	{ OT_MagFilter, ODT_Int },
-	{ OT_MipFilter, ODT_Int },
-	{ OT_MaxAniso, ODT_Int },
-	{ OT_MipBias, ODT_Float },
-	{ OT_MipMin, ODT_Float },
-	{ OT_MipMax, ODT_Float },
-	{ OT_BorderColor, ODT_Matrix },
-	{ OT_U, ODT_Int },
-	{ OT_V, ODT_Int },
-	{ OT_W, ODT_Int },
-	{ OT_Alias, ODT_String },
-	{ OT_Auto, ODT_String },
-	{ OT_Shared, ODT_Bool },
-	{ OT_Usage, ODT_Int },
-	{ OT_ParamType, ODT_Int },
 	{ OT_Identifier, ODT_String },
-	{ OT_ParamValue, ODT_Matrix },
-	{ OT_ParamStrValue, ODT_String },
-	{ OT_Parameters, ODT_Complex },
-	{ OT_Blocks, ODT_Complex },
-	{ OT_Parameter, ODT_Complex },
-	{ OT_Block, ODT_Complex },
-	{ OT_SamplerState, ODT_Complex },
 	{ OT_Code, ODT_Complex },
 	{ OT_StencilRef, ODT_Int },
 	{ OT_Tags, ODT_Complex },

Source/BansheeSL/Source/BsSLFXCompiler.cpp

@@ -428,9 +428,6 @@ namespace bs
 			case OT_Renderer:
 				metaData.renderer = parseRenderer(removeQuotes(option->value.strValue));
 				break;
-			case OT_Language:
-				parseLanguage(removeQuotes(option->value.strValue), metaData.language);
-				break;
 			case OT_Tags:
 			{
 				ASTFXNode* tagsNode = option->value.nodePtr;
@@ -467,49 +464,6 @@ namespace bs
 		return RendererAny;
 	}
 
-	void BSLFXCompiler::parseLanguage(const String& name, String& language)
-	{
-		if (name == "HLSL" || name == "HLSL11")
-			language = "hlsl";
-		else if (name == "HLSL9")
-			language = "hlsl9";
-		else if (name == "GLSL")
-			language = "glsl";
-		else // "Any"
-			language = "";
-	}
-
-	GpuParamBlockUsage BSLFXCompiler::parseBlockUsage(BufferUsageValue usage)
-	{
-		if (usage == BUV_Dynamic)
-			return GPBU_DYNAMIC;
-
-		return GPBU_STATIC;
-	}
-
-	UINT32 BSLFXCompiler::parseFilterMode(FilterValue filter)
-	{
-		switch (filter)
-		{
-		case FV_Point:
-			return FO_POINT;
-		case FV_Linear:
-			return FO_LINEAR;
-		case FV_Anisotropic:
-			return FO_ANISOTROPIC;
-		case FV_PointCmp:
-			return FO_POINT | FO_USE_COMPARISON;
-		case FV_LinearCmp:
-			return FO_LINEAR | FO_USE_COMPARISON;
-		case FV_AnisotropicCmp:
-			return FO_ANISOTROPIC | FO_USE_COMPARISON;
-		default:
-			break;
-		}
-
-		return FO_NONE;
-	}
-
 	QueueSortType BSLFXCompiler::parseSortType(QueueSortTypeValue sortType)
 	{
 		switch (sortType)
@@ -550,23 +504,6 @@ namespace bs
 		return CMPF_ALWAYS_PASS;
 	}
 
-	TextureAddressingMode BSLFXCompiler::parseAddrMode(AddrModeValue addrMode)
-	{
-		switch (addrMode)
-		{
-		case AMV_Wrap:
-			return TAM_WRAP;
-		case AMV_Mirror:
-			return TAM_MIRROR;
-		case AMV_Clamp:
-			return TAM_CLAMP;
-		case AMV_Border:
-			return TAM_BORDER;
-		}
-
-		return TAM_WRAP;
-	}
-
 	BlendFactor BSLFXCompiler::parseBlendFactor(OpValue factor)
 	{
 		switch (factor)
@@ -617,74 +554,6 @@ namespace bs
 		return BO_ADD;
 	}
 
-	void BSLFXCompiler::parseParamType(ParamType type, bool& isObjType, UINT32& typeId)
-	{
-		struct ParamData
-		{
-			UINT32 type;
-			bool isObjType;
-		};
-
-		static bool initialized = false;
-		static ParamData lookup[PT_Count];
-
-		if (!initialized)
-		{
-			lookup[PT_Float] = { GPDT_FLOAT1, false };
-			lookup[PT_Float2] = { GPDT_FLOAT2, false };
-			lookup[PT_Float3] = { GPDT_FLOAT3, false };
-			lookup[PT_Float4] = { GPDT_FLOAT4, false };
-
-			lookup[PT_Int] = { GPDT_INT1, false };
-			lookup[PT_Int2] = { GPDT_INT2, false };
-			lookup[PT_Int3] = { GPDT_INT3, false };
-			lookup[PT_Int4] = { GPDT_INT4, false };
-			lookup[PT_Color] = { GPDT_COLOR, false };
-
-			lookup[PT_Mat2x2] = { GPDT_MATRIX_2X2, false };
-			lookup[PT_Mat2x3] = { GPDT_MATRIX_2X3, false };
-			lookup[PT_Mat2x4] = { GPDT_MATRIX_2X4, false };
-
-			lookup[PT_Mat3x2] = { GPDT_MATRIX_3X2, false };
-			lookup[PT_Mat3x3] = { GPDT_MATRIX_3X3, false };
-			lookup[PT_Mat3x4] = { GPDT_MATRIX_3X4, false };
-
-			lookup[PT_Mat4x2] = { GPDT_MATRIX_4X2, false };
-			lookup[PT_Mat4x3] = { GPDT_MATRIX_4X3, false };
-			lookup[PT_Mat4x4] = { GPDT_MATRIX_4X4, false };
-
-			lookup[PT_Sampler1D] = { GPOT_SAMPLER1D, true };
-			lookup[PT_Sampler2D] = { GPOT_SAMPLER2D, true };
-			lookup[PT_Sampler3D] = { GPOT_SAMPLER3D, true };
-			lookup[PT_SamplerCUBE] = { GPOT_SAMPLERCUBE, true };
-			lookup[PT_Sampler2DMS] = { GPOT_SAMPLER2DMS, true };
-
-			lookup[PT_Texture1D] = { GPOT_TEXTURE1D, true };
-			lookup[PT_Texture2D] = { GPOT_TEXTURE2D, true };
-			lookup[PT_Texture3D] = { GPOT_TEXTURE3D, true };
-			lookup[PT_TextureCUBE] = { GPOT_TEXTURECUBE, true };
-			lookup[PT_Texture2DMS] = { GPOT_TEXTURE2DMS, true };
-
-			lookup[PT_RWTexture1D] = { GPOT_RWTEXTURE1D, true };
-			lookup[PT_RWTexture2D] = { GPOT_RWTEXTURE2D, true };
-			lookup[PT_RWTexture3D] = { GPOT_RWTEXTURE3D, true };
-			lookup[PT_RWTexture2DMS] = { GPOT_RWTEXTURE2DMS, true };
-
-			lookup[PT_ByteBuffer] = { GPOT_BYTE_BUFFER, true };
-			lookup[PT_StructBuffer] = { GPOT_STRUCTURED_BUFFER, true };
-			lookup[PT_TypedBufferRW] = { GPOT_RWTYPED_BUFFER, true };
-			lookup[PT_ByteBufferRW] = { GPOT_RWBYTE_BUFFER, true };
-			lookup[PT_StructBufferRW] = { GPOT_RWSTRUCTURED_BUFFER, true };
-			lookup[PT_AppendBuffer] = { GPOT_RWAPPEND_BUFFER, true };
-			lookup[PT_ConsumeBuffer] = { GPOT_RWCONSUME_BUFFER, true };
-
-			initialized = true;
-		}
-
-		isObjType = lookup[type].isObjType;
-		typeId = lookup[type].type;
-	}
-
 	StencilOperation BSLFXCompiler::parseStencilOp(OpValue op)
 	{
 		switch (op)
@@ -793,32 +662,6 @@ namespace bs
 		}
 	}
 
-	void BSLFXCompiler::parseAddrMode(SAMPLER_STATE_DESC& desc, ASTFXNode* addrModeNode)
-	{
-		if (addrModeNode == nullptr || addrModeNode->type != NT_AddrMode)
-			return;
-
-		for (int i = 0; i < addrModeNode->options->count; i++)
-		{
-			NodeOption* option = &addrModeNode->options->entries[i];
-
-			switch (option->type)
-			{
-			case OT_U:
-				desc.addressMode.u = parseAddrMode((AddrModeValue)option->value.intValue);
-				break;
-			case OT_V:
-				desc.addressMode.v = parseAddrMode((AddrModeValue)option->value.intValue);
-				break;
-			case OT_W:
-				desc.addressMode.w = parseAddrMode((AddrModeValue)option->value.intValue);
-				break;
-			default:
-				break;
-			}
-		}
-	}
-
 	void BSLFXCompiler::parseColorBlendDef(RENDER_TARGET_BLEND_STATE_DESC& desc, ASTFXNode* blendDefNode)
 	{
 		if (blendDefNode == nullptr || blendDefNode->type != NT_BlendDef)
@@ -1058,73 +901,7 @@ namespace bs
 
 		return !isDefault;
 	}
-
-	SPtr<SamplerState> BSLFXCompiler::parseSamplerState(ASTFXNode* samplerStateNode)
-	{
-		if (samplerStateNode == nullptr || samplerStateNode->type != NT_SamplerState)
-			return nullptr;
-
-		SAMPLER_STATE_DESC desc;
-		bool isDefault = true;
-
-		for (int i = 0; i < samplerStateNode->options->count; i++)
-		{
-			NodeOption* option = &samplerStateNode->options->entries[i];
-
-			switch (option->type)
-			{
-			case OT_AddrMode:
-				parseAddrMode(desc, option->value.nodePtr);
-				isDefault = false;
-				break;
-			case OT_MinFilter:
-				desc.minFilter = (FilterOptions)parseFilterMode((FilterValue)option->value.intValue);
-				isDefault = false;
-				break;
-			case OT_MagFilter:
-				desc.magFilter = (FilterOptions)parseFilterMode((FilterValue)option->value.intValue);
-				isDefault = false;
-				break;
-			case OT_MipFilter:
-				desc.mipFilter = (FilterOptions)parseFilterMode((FilterValue)option->value.intValue);
-				isDefault = false;
-				break;
-			case OT_MaxAniso:
-				desc.maxAniso = option->value.intValue;
-				isDefault = false;
-				break;
-			case OT_MipBias:
-				desc.mipmapBias = option->value.floatValue;
-				isDefault = false;
-				break;
-			case OT_MipMin:
-				desc.mipMin = option->value.floatValue;
-				isDefault = false;
-				break;
-			case OT_MipMax:
-				desc.mipMax = option->value.floatValue;
-				isDefault = false;
-				break;
-			case OT_BorderColor:
-				desc.borderColor = Color(option->value.matrixValue[0], option->value.matrixValue[1],
-					option->value.matrixValue[2], option->value.matrixValue[3]);
-				isDefault = false;
-				break;
-			case OT_CompareFunc:
-				desc.comparisonFunc = parseCompFunc((CompFuncValue)option->value.intValue);
-				isDefault = false;
-				break;
-			default:
-				break;
-			}
-		}
-
-		if (isDefault)
-			return nullptr;
-
-		return SamplerState::create(desc);
-	}
-
+	
 	void BSLFXCompiler::parseCodeBlock(ASTFXNode* codeNode, const Vector<String>& codeBlocks, PassData& passData)
 	{
 		if (codeNode == nullptr || (codeNode->type != NT_CodeCommon && codeNode->type != NT_CodeVertex && 
@@ -1300,158 +1077,6 @@ namespace bs
 		}
 	}
 
-	void BSLFXCompiler::parseParameters(SHADER_DESC& desc, ASTFXNode* parametersNode)
-	{
-		if (parametersNode == nullptr || parametersNode->type != NT_Parameters)
-			return;
-
-		for (int i = 0; i < parametersNode->options->count; i++)
-		{
-			NodeOption* option = &parametersNode->options->entries[i];
-
-			if (option->type != OT_Parameter)
-				continue;
-
-			ASTFXNode* parameter = option->value.nodePtr;
-
-			String name;
-			String alias;
-
-			UINT32 typeId = 0;
-			bool isObjType = false;
-			StringID semantic;
-			SPtr<SamplerState> samplerState = nullptr;
-			float defaultValue[16];
-			HTexture defaultTexture;
-			bool hasDefaultValue = false;
-			for (int j = 0; j < parameter->options->count; j++)
-			{
-				NodeOption* paramOption = &parameter->options->entries[j];
-
-				switch (paramOption->type)
-				{
-				case OT_Identifier:
-					name = paramOption->value.strValue;
-					break;
-				case OT_Alias:
-					alias = removeQuotes(paramOption->value.strValue);
-					break;
-				case OT_ParamType:
-					parseParamType((ParamType)paramOption->value.intValue, isObjType, typeId);
-					break;
-				case OT_ParamValue:
-					memcpy(defaultValue, paramOption->value.matrixValue, sizeof(defaultValue));
-					hasDefaultValue = true;
-					break;
-				case OT_ParamStrValue:
-				{
-					String defaultTextureName = removeQuotes(paramOption->value.strValue);
-					defaultTexture = getBuiltinTexture(defaultTextureName);
-					hasDefaultValue = true;
-				}
-					break;
-				case OT_Auto:
-					semantic = removeQuotes(paramOption->value.strValue);
-					break;
-				case OT_SamplerState:
-					samplerState = parseSamplerState(paramOption->value.nodePtr);
-					break;
-				default:
-					break;
-				}
-			}
-
-			if (name.empty())
-				continue;
-
-			auto addParameter = [&](const String& paramName, const String& gpuVarName)
-			{
-				if (isObjType)
-				{
-					GpuParamObjectType objType = (GpuParamObjectType)typeId;
-
-					if (Shader::isSampler(objType))
-					{
-						if(hasDefaultValue)
-							desc.addParameter(paramName, gpuVarName, objType, samplerState, semantic);
-						else
-							desc.addParameter(paramName, gpuVarName, objType, semantic);
-					}
-					else if(Shader::isTexture(objType))
-					{
-						if(hasDefaultValue)
-							desc.addParameter(paramName, gpuVarName, objType, defaultTexture, semantic);
-						else
-							desc.addParameter(paramName, gpuVarName, objType, semantic);
-					}
-					else
-						desc.addParameter(paramName, gpuVarName, objType, semantic);
-				}
-				else
-				{
-					if (hasDefaultValue)
-						desc.addParameter(paramName, gpuVarName, (GpuParamDataType)typeId, semantic, 1, 0, (UINT8*)defaultValue);
-					else
-						desc.addParameter(paramName, gpuVarName, (GpuParamDataType)typeId, semantic);
-				}
-			};
-
-			addParameter(name, name);
-
-			if (!alias.empty())
-				addParameter(name, alias);
-		}
-	}
-
-	void BSLFXCompiler::parseBlocks(SHADER_DESC& desc, ASTFXNode* blocksNode)
-	{
-		if (blocksNode == nullptr || blocksNode->type != NT_Blocks)
-			return;
-
-		for (int i = 0; i < blocksNode->options->count; i++)
-		{
-			NodeOption* option = &blocksNode->options->entries[i];
-
-			if (option->type != OT_Block)
-				continue;
-
-			ASTFXNode* parameter = option->value.nodePtr;
-
-			String name;
-			bool shared = false;
-			GpuParamBlockUsage usage = GPBU_STATIC;
-			StringID semantic;
-
-			for (int j = 0; j < parameter->options->count; j++)
-			{
-				NodeOption* paramOption = &parameter->options->entries[j];
-
-				switch (paramOption->type)
-				{
-				case OT_Identifier:
-					name = paramOption->value.strValue;
-					break;
-				case OT_Shared:
-					shared = paramOption->value.intValue > 0;
-					break;
-				case OT_Usage:
-					usage = parseBlockUsage((BufferUsageValue)paramOption->value.intValue);
-					break;
-				case OT_Auto:
-					semantic = removeQuotes(paramOption->value.strValue);
-					break;
-				default:
-					break;
-				}
-			}
-
-			if (name.empty())
-				continue;
-
-			desc.setParamBlockAttribs(name, shared, usage, semantic);
-		}
-	}
-	
 	BSLFXCompileResult BSLFXCompiler::parseShader(const String& name, ParseState* parseState, Vector<String>& codeBlocks)
 	{
 		BSLFXCompileResult output;
@@ -1497,12 +1122,6 @@ namespace bs
 
 				break;
 			}
-			case OT_Parameters:
-				parseParameters(shaderDesc, option->value.nodePtr);
-				break;
-			case OT_Blocks:
-				parseBlocks(shaderDesc, option->value.nodePtr);
-				break;
 			default:
 				break;
 			}