BansheeSL: A bunch more lexer and parser rules

BansheeSL/BsLexerFX.h

@@ -447,7 +447,7 @@ extern int yylex \
 #undef YY_DECL
 #endif
 
-#line 168 "BsLexerFX.l"
+#line 220 "BsLexerFX.l"
 
 #line 453 "BsLexerFX.h"
 #undef yyIN_HEADER

BansheeSL/BsLexerFX.l

@@ -11,6 +11,7 @@ INTEGER			[0-9][0-9]*
 INTEGER_BIN		0x[0-9][0-9]*
 FLOAT			[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?
 STRING			\"[^"\n]*\"
+IDENTIFIER		[_a-zA-Z][_a-zA-Z0-9]*
 WS				[ \r\n\t]*
 
 %%
@@ -22,6 +23,48 @@ WS				[ \r\n\t]*
 true			{ yylval->intValue = 1; return TOKEN_BOOLEAN; }
 false			{ yylval->intValue = 0; return TOKEN_BOOLEAN; }
 
+	/* Value types */
+
+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; }
+
+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; }
+
+bytebuffer		{ yylval->intValue = PT_ByteBuffer; return TOKEN_BYTEBUFFER; } 
+structbuffer	{ yylval->intValue = PT_StructBuffer; return TOKEN_STRUCTBUFFER; } 
+
+typedbufferRW	{ yylval->intValue = PT_TypedBufferRW; return TOKEN_RWTYPEDBUFFER; } 
+bytebufferRW	{ yylval->intValue = PT_ByteBufferRW; return TOKEN_RWBYTEBUFFER; }
+structbufferRW	{ 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; }
 Queue			{ return TOKEN_QUEUE; }
@@ -93,6 +136,12 @@ 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; }
+
 	/* State values */
 wire			{ yylval->intValue = 0; return TOKEN_FILLMODEVALUE; }
 solid			{ yylval->intValue = 1; return TOKEN_FILLMODEVALUE; }
@@ -164,5 +213,8 @@ pointcmp		{ yylval->intValue = 4; return TOKEN_FILTERVALUE; }
 linearcmp		{ yylval->intValue = 5; return TOKEN_FILTERVALUE; }
 anisotropiccmp	{ yylval->intValue = 6; return TOKEN_FILTERVALUE; }
 
+static			{ yylval->intValue = 0; return TOKEN_BUFFERUSAGE; }
+dynamic			{ yylval->intValue = 1; return TOKEN_BUFFERUSAGE; }
 
+{IDENTIFIER}	{ yylval->strValue = mmalloc_strdup(yyextra->memContext, yytext); return TOKEN_IDENTIFIER; }
 .				{ return yytext[0]; }

BansheeSL/BsParserFX.h

@@ -51,10 +51,25 @@ extern int yydebug;
 	typedef void* yyscan_t;
 #endif
 
+#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);		\
+
 
 
 /* Line 2579 of glr.c  */
-#line 58 "BsParserFX.h"
+#line 73 "BsParserFX.h"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -66,71 +81,108 @@ extern int yydebug;
      TOKEN_FLOAT = 259,
      TOKEN_BOOLEAN = 260,
      TOKEN_STRING = 261,
-     TOKEN_FILLMODEVALUE = 262,
-     TOKEN_CULLMODEVALUE = 263,
-     TOKEN_COMPFUNCVALUE = 264,
-     TOKEN_OPVALUE = 265,
-     TOKEN_COLORMASK = 266,
-     TOKEN_ADDRMODEVALUE = 267,
-     TOKEN_FILTERVALUE = 268,
-     TOKEN_BLENDOPVALUE = 269,
-     TOKEN_SEPARABLE = 270,
-     TOKEN_QUEUE = 271,
-     TOKEN_PRIORITY = 272,
-     TOKEN_PARAMETERS = 273,
-     TOKEN_BLOCKS = 274,
-     TOKEN_TECHNIQUE = 275,
-     TOKEN_RENDERER = 276,
-     TOKEN_LANGUAGE = 277,
-     TOKEN_INCLUDE = 278,
-     TOKEN_PASS = 279,
-     TOKEN_VERTEX = 280,
-     TOKEN_FRAGMENT = 281,
-     TOKEN_GEOMETRY = 282,
-     TOKEN_HULL = 283,
-     TOKEN_DOMAIN = 284,
-     TOKEN_COMPUTE = 285,
-     TOKEN_FILLMODE = 286,
-     TOKEN_CULLMODE = 287,
-     TOKEN_DEPTHBIAS = 288,
-     TOKEN_SDEPTHBIAS = 289,
-     TOKEN_DEPTHCLIP = 290,
-     TOKEN_SCISSOR = 291,
-     TOKEN_MULTISAMPLE = 292,
-     TOKEN_AALINE = 293,
-     TOKEN_DEPTHREAD = 294,
-     TOKEN_DEPTHWRITE = 295,
-     TOKEN_COMPAREFUNC = 296,
-     TOKEN_STENCIL = 297,
-     TOKEN_STENCILREADMASK = 298,
-     TOKEN_STENCILWRITEMASK = 299,
-     TOKEN_STENCILOPFRONT = 300,
-     TOKEN_STENCILOPBACK = 301,
-     TOKEN_FAIL = 302,
-     TOKEN_ZFAIL = 303,
-     TOKEN_ALPHATOCOVERAGE = 304,
-     TOKEN_INDEPENDANTBLEND = 305,
-     TOKEN_TARGET = 306,
-     TOKEN_INDEX = 307,
-     TOKEN_BLEND = 308,
-     TOKEN_COLOR = 309,
-     TOKEN_ALPHA = 310,
-     TOKEN_WRITEMASK = 311,
-     TOKEN_SOURCE = 312,
-     TOKEN_DEST = 313,
-     TOKEN_OP = 314,
-     TOKEN_ADDRMODE = 315,
-     TOKEN_MINFILTER = 316,
-     TOKEN_MAGFILTER = 317,
-     TOKEN_MIPFILTER = 318,
-     TOKEN_MAXANISO = 319,
-     TOKEN_MIPBIAS = 320,
-     TOKEN_MIPMIN = 321,
-     TOKEN_MIPMAX = 322,
-     TOKEN_BORDERCOLOR = 323,
-     TOKEN_U = 324,
-     TOKEN_V = 325,
-     TOKEN_W = 326
+     TOKEN_IDENTIFIER = 262,
+     TOKEN_FILLMODEVALUE = 263,
+     TOKEN_CULLMODEVALUE = 264,
+     TOKEN_COMPFUNCVALUE = 265,
+     TOKEN_OPVALUE = 266,
+     TOKEN_COLORMASK = 267,
+     TOKEN_ADDRMODEVALUE = 268,
+     TOKEN_FILTERVALUE = 269,
+     TOKEN_BLENDOPVALUE = 270,
+     TOKEN_BUFFERUSAGE = 271,
+     TOKEN_FLOATTYPE = 272,
+     TOKEN_FLOAT2TYPE = 273,
+     TOKEN_FLOAT3TYPE = 274,
+     TOKEN_FLOAT4TYPE = 275,
+     TOKEN_MAT2x2TYPE = 276,
+     TOKEN_MAT2x3TYPE = 277,
+     TOKEN_MAT2x4TYPE = 278,
+     TOKEN_MAT3x2TYPE = 279,
+     TOKEN_MAT3x3TYPE = 280,
+     TOKEN_MAT3x4TYPE = 281,
+     TOKEN_MAT4x2TYPE = 282,
+     TOKEN_MAT4x3TYPE = 283,
+     TOKEN_MAT4x4TYPE = 284,
+     TOKEN_SAMPLER1D = 285,
+     TOKEN_SAMPLER2D = 286,
+     TOKEN_SAMPLER3D = 287,
+     TOKEN_SAMPLERCUBE = 288,
+     TOKEN_SAMPLER2DMS = 289,
+     TOKEN_TEXTURE1D = 290,
+     TOKEN_TEXTURE2D = 291,
+     TOKEN_TEXTURE3D = 292,
+     TOKEN_TEXTURECUBE = 293,
+     TOKEN_TEXTURE2DMS = 294,
+     TOKEN_BYTEBUFFER = 295,
+     TOKEN_STRUCTBUFFER = 296,
+     TOKEN_RWTYPEDBUFFER = 297,
+     TOKEN_RWBYTEBUFFER = 298,
+     TOKEN_RWSTRUCTBUFFER = 299,
+     TOKEN_RWAPPENDBUFFER = 300,
+     TOKEN_RWCONSUMEBUFFER = 301,
+     TOKEN_PARAMSBLOCK = 302,
+     TOKEN_AUTO = 303,
+     TOKEN_ALIAS = 304,
+     TOKEN_SHARED = 305,
+     TOKEN_USAGE = 306,
+     TOKEN_SEPARABLE = 307,
+     TOKEN_QUEUE = 308,
+     TOKEN_PRIORITY = 309,
+     TOKEN_PARAMETERS = 310,
+     TOKEN_BLOCKS = 311,
+     TOKEN_TECHNIQUE = 312,
+     TOKEN_RENDERER = 313,
+     TOKEN_LANGUAGE = 314,
+     TOKEN_INCLUDE = 315,
+     TOKEN_PASS = 316,
+     TOKEN_VERTEX = 317,
+     TOKEN_FRAGMENT = 318,
+     TOKEN_GEOMETRY = 319,
+     TOKEN_HULL = 320,
+     TOKEN_DOMAIN = 321,
+     TOKEN_COMPUTE = 322,
+     TOKEN_FILLMODE = 323,
+     TOKEN_CULLMODE = 324,
+     TOKEN_DEPTHBIAS = 325,
+     TOKEN_SDEPTHBIAS = 326,
+     TOKEN_DEPTHCLIP = 327,
+     TOKEN_SCISSOR = 328,
+     TOKEN_MULTISAMPLE = 329,
+     TOKEN_AALINE = 330,
+     TOKEN_DEPTHREAD = 331,
+     TOKEN_DEPTHWRITE = 332,
+     TOKEN_COMPAREFUNC = 333,
+     TOKEN_STENCIL = 334,
+     TOKEN_STENCILREADMASK = 335,
+     TOKEN_STENCILWRITEMASK = 336,
+     TOKEN_STENCILOPFRONT = 337,
+     TOKEN_STENCILOPBACK = 338,
+     TOKEN_FAIL = 339,
+     TOKEN_ZFAIL = 340,
+     TOKEN_ALPHATOCOVERAGE = 341,
+     TOKEN_INDEPENDANTBLEND = 342,
+     TOKEN_TARGET = 343,
+     TOKEN_INDEX = 344,
+     TOKEN_BLEND = 345,
+     TOKEN_COLOR = 346,
+     TOKEN_ALPHA = 347,
+     TOKEN_WRITEMASK = 348,
+     TOKEN_SOURCE = 349,
+     TOKEN_DEST = 350,
+     TOKEN_OP = 351,
+     TOKEN_ADDRMODE = 352,
+     TOKEN_MINFILTER = 353,
+     TOKEN_MAGFILTER = 354,
+     TOKEN_MIPFILTER = 355,
+     TOKEN_MAXANISO = 356,
+     TOKEN_MIPBIAS = 357,
+     TOKEN_MIPMIN = 358,
+     TOKEN_MIPMAX = 359,
+     TOKEN_BORDERCOLOR = 360,
+     TOKEN_U = 361,
+     TOKEN_V = 362,
+     TOKEN_W = 363
    };
 #endif
 
@@ -138,17 +190,18 @@ extern int yydebug;
 typedef union YYSTYPE
 {
 /* Line 2579 of glr.c  */
-#line 34 "BsParserFX.y"
+#line 49 "BsParserFX.y"
 
 	int intValue;
 	float floatValue;
+	float matrixValue[16];
 	const char* strValue;
 	ASTFXNode* nodePtr;
 	NodeOption nodeOption;
 
 
 /* Line 2579 of glr.c  */
-#line 152 "BsParserFX.h"
+#line 205 "BsParserFX.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */

BansheeSL/BsParserFX.y

@@ -19,6 +19,21 @@
 	typedef void* yyscan_t;
 #endif
 
+#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"
@@ -34,6 +49,7 @@
 %union {
 	int intValue;
 	float floatValue;
+	float matrixValue[16];
 	const char* strValue;
 	ASTFXNode* nodePtr;
 	NodeOption nodeOption;
@@ -44,6 +60,7 @@
 %token <floatValue> TOKEN_FLOAT
 %token <intValue>	TOKEN_BOOLEAN
 %token <strValue>	TOKEN_STRING
+%token <strValue>	TOKEN_IDENTIFIER
 
 %token <intValue>	TOKEN_FILLMODEVALUE
 %token <intValue>	TOKEN_CULLMODEVALUE
@@ -53,6 +70,49 @@
 %token <intValue>	TOKEN_ADDRMODEVALUE
 %token <intValue>	TOKEN_FILTERVALUE
 %token <intValue>	TOKEN_BLENDOPVALUE
+%token <intValue>	TOKEN_BUFFERUSAGE
+
+%token <intValue> TOKEN_FLOATTYPE 
+%token <intValue> TOKEN_FLOAT2TYPE 
+%token <intValue> TOKEN_FLOAT3TYPE 
+%token <intValue> TOKEN_FLOAT4TYPE
+
+%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_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
 
 	/* Shader keywords */
 %token TOKEN_SEPARABLE TOKEN_QUEUE TOKEN_PRIORITY
@@ -69,7 +129,7 @@
 
 %token	TOKEN_DEPTHREAD TOKEN_DEPTHWRITE TOKEN_COMPAREFUNC TOKEN_STENCIL
 %token	TOKEN_STENCILREADMASK TOKEN_STENCILWRITEMASK TOKEN_STENCILOPFRONT TOKEN_STENCILOPBACK
-%token	TOKEN_FAIL TOKEN_ZFAIL TOKEN_PASS
+%token	TOKEN_FAIL TOKEN_ZFAIL
 
 %token	TOKEN_ALPHATOCOVERAGE TOKEN_INDEPENDANTBLEND TOKEN_TARGET TOKEN_INDEX
 %token	TOKEN_BLEND TOKEN_COLOR TOKEN_ALPHA TOKEN_WRITEMASK
@@ -89,8 +149,82 @@
 %type <nodeOption>	technique_statement;
 %type <nodeOption>	technique_option;
 
+%type <nodePtr>		pass;
+%type <nodePtr>		pass_header;
+%type <nodeOption>	pass_statement;
+%type <nodeOption>	pass_option;
+
+%type <nodePtr>		stencil_op_front_header;
+%type <nodePtr>		stencil_op_back_header;
+%type <nodeOption>	stencil_op_option;
+
+%type <nodePtr>		target;
+%type <nodePtr>		target_header;
+%type <nodeOption>	target_statement;
+%type <nodeOption>	target_option;
+
+%type <nodePtr>		blend_color_header;
+%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 <matrixValue> float2;
+%type <matrixValue> float3;
+%type <matrixValue> float4;
+%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_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_generic
+%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_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
+
 %%
 
+	/* Shader */
+
 shader
 	: /* empty */				{ }
 	| shader_statement shader	{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
@@ -99,6 +233,8 @@ 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
@@ -107,6 +243,8 @@ shader_option
 	| TOKEN_PRIORITY '=' TOKEN_INTEGER ';'		{ $$.type = OT_Priority; $$.value.intValue = $3; }
 	;
 
+	/* Technique */
+
 technique
 	: technique_header '{' technique_body '}' ';' { nodePop(parse_state); $$ = $1; }
 	;
@@ -126,6 +264,7 @@ technique_body
 
 technique_statement
 	: technique_option
+	| pass				{ $$.type = OT_Pass; $$.value.nodePtr = $1; }
 	;
 
 technique_option
@@ -133,4 +272,479 @@ technique_option
 	| TOKEN_LANGUAGE '=' TOKEN_STRING ';'	{ $$.type = OT_Language; $$.value.strValue = $3; }
 	| TOKEN_INCLUDE '=' TOKEN_STRING ';'	{ $$.type = OT_Include; $$.value.strValue = $3; }
 
+	/* Pass */
+
+pass
+	: pass_header '{' pass_body '}' ';' { nodePop(parse_state); $$ = $1; }
+	;
+
+pass_header
+	: TOKEN_PASS '=' 
+		{ 
+			$$ = nodeCreate(parse_state->memContext, NT_Pass); 
+			nodePush(parse_state, $$);
+		}
+	;
+
+pass_body
+	: /* empty */
+	| pass_statement pass_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
+	;
+
+pass_statement
+	: pass_option
+	;
+
+pass_option
+	: TOKEN_FILLMODE '=' TOKEN_FILLMODEVALUE ';'			{ $$.type = OT_FillMode; $$.value.intValue = $3; }
+	| TOKEN_CULLMODE '=' TOKEN_CULLMODEVALUE ';'			{ $$.type = OT_CullMode; $$.value.intValue = $3; }
+	| TOKEN_DEPTHBIAS '=' TOKEN_FLOAT ';'					{ $$.type = OT_DepthBias; $$.value.floatValue = $3; }
+	| TOKEN_SDEPTHBIAS '=' TOKEN_FLOAT ';'					{ $$.type = OT_SDepthBias; $$.value.floatValue = $3; }
+	| TOKEN_DEPTHCLIP '=' TOKEN_BOOLEAN ';'					{ $$.type = OT_DepthClip; $$.value.intValue = $3; }
+	| TOKEN_SCISSOR '=' TOKEN_BOOLEAN ';'					{ $$.type = OT_Scissor; $$.value.intValue = $3; }
+	| TOKEN_MULTISAMPLE '=' TOKEN_BOOLEAN ';'				{ $$.type = OT_Multisample; $$.value.intValue = $3; }
+	| TOKEN_AALINE '=' TOKEN_BOOLEAN ';'					{ $$.type = OT_AALine; $$.value.intValue = $3; }
+	| TOKEN_DEPTHREAD '=' TOKEN_BOOLEAN ';'					{ $$.type = OT_DepthRead; $$.value.intValue = $3; }
+	| TOKEN_DEPTHWRITE '=' TOKEN_BOOLEAN ';'				{ $$.type = OT_DepthWrite; $$.value.intValue = $3; }
+	| TOKEN_COMPAREFUNC '=' TOKEN_COMPFUNCVALUE ';'			{ $$.type = OT_CompareFunc; $$.value.intValue = $3; }
+	| TOKEN_STENCIL '=' TOKEN_BOOLEAN ';'					{ $$.type = OT_Stencil; $$.value.intValue = $3; }
+	| TOKEN_STENCILREADMASK '=' TOKEN_INTEGER ';'			{ $$.type = OT_StencilReadMask; $$.value.intValue = $3; }
+	| TOKEN_STENCILWRITEMASK '=' TOKEN_INTEGER ';'			{ $$.type = OT_StencilWriteMask; $$.value.intValue = $3; }
+	| stencil_op_front_header '{' stencil_op_body '}' ';'	{ nodePop(parse_state); $$.type = OT_StencilOpFront; $$.value.nodePtr = $1; }
+	| stencil_op_back_header '{' stencil_op_body '}' ';'	{ nodePop(parse_state); $$.type = OT_StencilOpBack; $$.value.nodePtr = $1; }
+	| TOKEN_ALPHATOCOVERAGE '=' TOKEN_BOOLEAN ';'			{ $$.type = OT_AlphaToCoverage; $$.value.intValue = $3; }
+	| TOKEN_INDEPENDANTBLEND '=' TOKEN_BOOLEAN ';'			{ $$.type = OT_IndependantBlend; $$.value.intValue = $3; }
+	| target												{ $$.type = OT_Target; $$.value.nodePtr = $1; }
+	;
+
+	/* Stencil op */
+
+stencil_op_front_header
+	: TOKEN_STENCILOPFRONT '='
+		{ 
+			$$ = nodeCreate(parse_state->memContext, NT_StencilOp); 
+			nodePush(parse_state, $$);
+		}
+	;
+
+stencil_op_back_header
+	: TOKEN_STENCILOPBACK '='
+		{ 
+			$$ = nodeCreate(parse_state->memContext, NT_StencilOp); 
+			nodePush(parse_state, $$);
+		}
+	;
+
+stencil_op_body
+	: /* empty */
+	| stencil_op_option stencil_op_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
+	;
+
+stencil_op_option
+	: TOKEN_FAIL '=' TOKEN_OPVALUE ';'					{ $$.type = OT_Fail; $$.value.intValue = $3; }
+	| TOKEN_ZFAIL '=' TOKEN_OPVALUE ';'					{ $$.type = OT_ZFail; $$.value.intValue = $3; }
+	| TOKEN_PASS '=' TOKEN_OPVALUE ';'					{ $$.type = OT_Pass; $$.value.intValue = $3; }
+	| TOKEN_COMPAREFUNC '=' TOKEN_COMPFUNCVALUE ';'		{ $$.type = OT_CompareFunc; $$.value.intValue = $3; }
+	; 
+
+	/* Target */
+target
+	: target_header '{' target_body '}' ';' { nodePop(parse_state); $$ = $1; }
+	;
+
+target_header
+	: TOKEN_TARGET '='
+		{ 
+			$$ = nodeCreate(parse_state->memContext, NT_Target); 
+			nodePush(parse_state, $$);
+		}
+	;
+
+target_body
+	: /* empty */
+	| target_statement target_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
+	;
+
+target_statement
+	: target_option
+	;
+
+target_option
+	: TOKEN_INDEX '=' TOKEN_INTEGER ';'					{ $$.type = OT_Index; $$.value.intValue = $3; }
+	| TOKEN_BLEND '=' TOKEN_BOOLEAN ';'					{ $$.type = OT_Blend; $$.value.intValue = $3; }
+	| blend_color_header '{' blenddef_body '}' ';'		{ nodePop(parse_state); $$.type = OT_Color; $$.value.nodePtr = $1; }
+	| blend_alpha_header '{' blenddef_body '}' ';'		{ nodePop(parse_state); $$.type = OT_Alpha; $$.value.nodePtr = $1; }
+	| TOKEN_WRITEMASK '=' TOKEN_COLORMASK ';'			{ $$.type = OT_Index; $$.value.intValue = $3; }
+	;
+
+	/* Blend definition */
+blend_color_header
+	: TOKEN_COLOR '='
+		{ 
+			$$ = nodeCreate(parse_state->memContext, NT_BlendDef); 
+			nodePush(parse_state, $$);
+		}
+	;
+
+blend_alpha_header
+	: TOKEN_ALPHA '='
+		{ 
+			$$ = nodeCreate(parse_state->memContext, NT_BlendDef); 
+			nodePush(parse_state, $$);
+		}
+	;
+
+blenddef_body
+	: /* empty */
+	| blenddef_option blenddef_body		{ nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$1); }
+	;
+
+blenddef_option
+	: TOKEN_SOURCE '=' TOKEN_OPVALUE ';'					{ $$.type = OT_Source; $$.value.intValue = $3; }
+	| TOKEN_DEST '=' TOKEN_OPVALUE ';'						{ $$.type = OT_Dest; $$.value.intValue = $3; }
+	| 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
+	: TOKEN_ADDRMODE '='
+		{ 
+			$$ = nodeCreate(parse_state->memContext, NT_AddrMode); 
+			nodePush(parse_state, $$);
+		}
+	;
+
+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;}
+	;
+
+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_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_generic	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_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_generic
+	: 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_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_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 '}' { }
+	;
+
+	/* 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_IDENTIFIER ')'	{ $$.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; }
+	;
 %%

BansheeSL/Include/BsASTFX.h

@@ -7,6 +7,7 @@
 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;
@@ -21,12 +22,19 @@ enum tagNodeType
 	NT_Technique,
 	NT_Parameters,
 	NT_Blocks,
-	NT_Pass
+	NT_Pass,
+	NT_StencilOp,
+	NT_Target,
+	NT_BlendDef,
+	NT_SamplerState,
+	NT_AddrMode,
+	NT_Parameter,
+	NT_Block
 };
 
 enum tagOptionType
 {
-	OT_Node,
+	OT_None = 0,
 	OT_Separable,
 	OT_Priority,
 	OT_Queue,
@@ -34,8 +42,60 @@ enum tagOptionType
 	OT_Renderer,
 	OT_Language,
 	OT_Include,
-	OT_Pass
-	// TODO - Add others
+	OT_Pass,
+	OT_FillMode,
+	OT_CullMode,
+	OT_DepthBias,
+	OT_SDepthBias,
+	OT_DepthClip,
+	OT_Scissor,
+	OT_Multisample,
+	OT_AALine,
+	OT_DepthRead,
+	OT_DepthWrite,
+	OT_CompareFunc,
+	OT_Stencil,
+	OT_StencilReadMask,
+	OT_StencilWriteMask,
+	OT_StencilOpFront,
+	OT_StencilOpBack,
+	OT_Fail,
+	OT_ZFail,
+	OT_AlphaToCoverage,
+	OT_IndependantBlend,
+	OT_Target,
+	OT_Index,
+	OT_Blend,
+	OT_Color,
+	OT_Alpha,
+	OT_WriteMask,
+	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_Parameters,
+	OT_Blocks,
+	OT_Parameter,
+	OT_Block,
+	OT_SamplerState
 };
 
 enum tagOptionDataType
@@ -44,7 +104,20 @@ enum tagOptionDataType
 	ODT_Float,
 	ODT_Bool,
 	ODT_String,
-	ODT_Complex
+	ODT_Complex,
+	ODT_Matrix
+};
+
+enum tagParamType
+{
+	PT_Float, PT_Float2, PT_Float3, PT_Float4,
+	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_ByteBuffer, PT_StructBuffer, PT_ByteBufferRW, PT_StructBufferRW,
+	PT_TypedBufferRW, PT_AppendBuffer, PT_ConsumeBuffer
 };
 
 struct tagNodeLink
@@ -73,6 +146,7 @@ union tagOptionData
 	int intValue;
 	float floatValue;
 	const char* strValue;
+	float matrixValue[16];
 	ASTFXNode* nodePtr;
 };
 
@@ -94,7 +168,6 @@ struct tagASTFXNode
 {
 	NodeType type;
 	NodeOptions* options;
-	// TODO - Add parameters and blocks
 };
 
 OptionInfo OPTION_LOOKUP[];
@@ -104,7 +177,7 @@ void nodeOptionDelete(NodeOption* option);
 void nodeOptionsDelete(NodeOptions* options);
 void nodeOptionsResize(void* context, NodeOptions* options, int size);
 void nodeOptionsGrowIfNeeded(void* context, NodeOptions* options);
-void nodeOptionsAdd(void* context, NodeOptions* options, NodeOption* option);
+void nodeOptionsAdd(void* context, NodeOptions* options, const NodeOption* option);
 
 ASTFXNode* nodeCreate(void* context, NodeType type);
 void nodeDelete(ASTFXNode* node);

BansheeSL/Source/BSMMAlloc.c

@@ -56,10 +56,10 @@ void mmfree(void* ptr)
 	free(buffer);
 }
 
-char* mmalloc_strdup(void* context, const char* input)
+char* mmalloc_strdup(void* context, char* input)
 {
 	size_t length = strlen(input);
-	char* output = mmalloc(context, sizeof(char) * (length + 1));
+	char* output = mmalloc(context, (int)(sizeof(char) * (length + 1)));
 
 	memcpy(output, input, length);
 	output[length] = '\0';

BansheeSL/Source/BsASTFX.c

@@ -3,10 +3,68 @@
 
 OptionInfo OPTION_LOOKUP[] =
 {
-	{ OT_Node, ODT_Complex },
+	{ OT_None, ODT_Int },
 	{ OT_Separable, ODT_Bool },
 	{ OT_Priority, ODT_Int },
 	{ OT_Queue, ODT_Int },
+	{ OT_Technique, ODT_Complex }, 
+	{ OT_Renderer, ODT_String }, 
+	{ OT_Language, ODT_String }, 
+	{ OT_Include, ODT_String }, 
+	{ OT_Pass, ODT_Complex }, 
+	{ OT_FillMode, ODT_Int }, 
+	{ OT_CullMode, ODT_Int },
+	{ OT_DepthBias, ODT_Float },
+	{ OT_SDepthBias, ODT_Float },
+	{ OT_DepthClip, ODT_Bool },
+	{ OT_Scissor, ODT_Bool },
+	{ OT_Multisample, ODT_Bool },
+	{ OT_AALine, ODT_Bool },
+	{ OT_DepthRead, ODT_Bool },
+	{ OT_DepthWrite, ODT_Bool },
+	{ OT_CompareFunc, ODT_Int },
+	{ OT_Stencil, ODT_Bool },
+	{ OT_StencilReadMask, ODT_Int },
+	{ OT_StencilWriteMask, ODT_Int },
+	{ OT_StencilOpFront, ODT_Complex },
+	{ OT_StencilOpBack, ODT_Complex },
+	{ OT_Fail, ODT_Int },
+	{ OT_ZFail, ODT_Int },
+	{ OT_AlphaToCoverage, ODT_Bool },
+	{ OT_IndependantBlend, ODT_Bool },
+	{ OT_Target, ODT_Complex },
+	{ OT_Index, ODT_Int },
+	{ OT_Blend, ODT_Bool },
+	{ OT_Color, ODT_Complex },
+	{ OT_Alpha, ODT_Complex },
+	{ OT_WriteMask, ODT_Int },
+	{ 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_Parameters, ODT_Complex },
+	{ OT_Blocks, ODT_Complex },
+	{ OT_Parameter, ODT_Complex },
+	{ OT_Block, ODT_Complex },
+	{ OT_SamplerState, ODT_Complex }
 };
 
 NodeOptions* nodeOptionsCreate(void* context)
@@ -85,7 +143,7 @@ void nodeOptionsGrowIfNeeded(void* context, NodeOptions* options)
 		nodeOptionsResize(context, options, options->bufferSize + BUFFER_GROW);
 }
 
-void nodeOptionsAdd(void* context, NodeOptions* options, NodeOption* option)
+void nodeOptionsAdd(void* context, NodeOptions* options, const NodeOption* option)
 {
 	nodeOptionsGrowIfNeeded(context, options);
 

TODO.txt

@@ -109,19 +109,6 @@ C# material interface:
 
 --------
 
-Consider creating a shader effect language first?
- - It needs support for multiple gpu programs (vertex, fragment, etc)
- - Multiple passes, each with options to set up blend/rasterizer/depth-stencil states
- - Actual GpuProgram code can be marked with HLSL, HLSL11, GLSL (and later BSL) to compile for only specific API
- - Also needs to support techniques
- - Also render queue, priority, renderer semantics
- - Default parameter values?
- - Parameter ranges?
-
-Then do I not need C# interface for anything but a Shader and Material. Shader doesn't need many (any?) properties and Material only needs property setters. Also potentially it also needs param block buffers and sampler states.
-
-While I'm at this I might also consider dealing with includes and shader combinations
-
 Questions:
  - How to deal with sampler states? Allow default ones in shader?
    - Yes, allow default ones. Plus allow sampler states to be tweaked from Material directly (without separate SamplerState class)
@@ -130,10 +117,6 @@ Questions:
 
 Check D:\ExampleBFX.txt for an example effects file
 
-Import:
- - A special importer for BFX files. It generates a HShader as its output. I MIGHT want to disable separate GpuProgram and state saving so
-  I don't need to deal with multi-resources yet.
-
 How to deal with includes?
  - You can do Include = "Path/to/CommonShader"
    - Path is relative to executable
@@ -144,8 +127,6 @@ How to deal with includes?
   - They are only resolved during import, after which just resource references are kept (i.e. its GUIDs)
   - The runtime should then be able to resolve the GUIDs easily
 
-Use Bison to avoid the need to reference C# code from C++?
-
 VALID KEYWORDS:
 <<RasterizerState>>
 Fill = Wire/Solid
@@ -245,48 +226,23 @@ Hull = code
 Domain = code
 Compute = code
 
-Make sure to allow multiple properties of the same name (e.g. multiple Targets or Techniques). Where this isn't valid the program can ignore the extra ones.
-
-<<<<<<<<AST>>>>>>>>>
-Node
-
-RootNode : OptionsNode
- - ParamsNode parameters
- - BlocksNode blocks
-
-OptionsNode : Node
- - Dictionary<string, int> options;(identifier -> sym table index)
-   - this can point to another node, float, int, bool, float2, etc.
-
-ParamsNode : Node
- - ParamNode[] params
-
-BlocksNode : Node
- - BlockNode[] blocks
-
-ParamNode : Node
- - enum Type
- - string name
- - ParamQualifierNode[] qualifiers;
- - ValueType value (ValueType can be a SamplerState or any of the primitive types)
-
-BlockNode : Node
- - string name
- - BlockQualifierNode[] qualififers;
-
-ParamQualifierNode
- - ParamQualifierType type
- - T Value (create different qualifier node types for each qualifier since each has its own type (or multiple values)?)
-  - But it's better just to have a void pointer and detect actual value stored here (it can be a struct with multiple values too)
-
-BlockQualifierNode
- - BlockQualifierType type
- - T Value (create different qualifier node types for each qualifier since each has its own type (or multiple values)?)
-  - But it's better just to have a void pointer and detect actual value stored here (it can be a struct with multiple values too)
-
 -------------------
 
-In lexer I use numbers to identify different values, but use enums instead so I can use the same ones when parsing AST
+TODO:
+ - BorderColor for SamplerState isn't implemented yet as I haven't decided how to deal with vectors/matrices yet
+ - Parser logic for parameters and blocks (with qualifier support)
+ - Code blocks (e.g. vertex/fragment/etc)
+ - In lexer I use numbers to identify different values, but use enums instead so I can use the same ones when parsing AST
+ - Generate Shader from parsed AST
+ - Make sure includes are handled properly
+ - Make sure default values are handled properly
+ -----
+ - Move all builtin shaders to the new .shader file model
+ - Optionally change how GpuPrograms are saved
+ -----
+ - Add GpuProgram caching (e.g. save compiled programs somewhere for later use)
+ - Consider adding restrictions on parameter ranges (probably via an additional qualifier)
+ - Parameter definitions don't support arrays (Leave this for a later iteration)
 
 ----------------------------------------------------------------------
 Scene View