Game builds now properly resolve gbuffer

BansheeD3D11RenderAPI/Source/BsD3D11HLSLParamParser.cpp

@@ -1,364 +1,365 @@
-#include "BsD3D11HLSLParamParser.h"
-#include "BsD3D11Mappings.h"
-#include "BsGpuParamDesc.h"
-#include "BsException.h"
-#include "BsDebug.h"
-
-namespace BansheeEngine
-{
-	void D3D11HLSLParamParser::parse(ID3DBlob* microcode, GpuParamDesc& desc, List<VertexElement>* inputParams)
-	{
-		const char* commentString = nullptr;
-		ID3DBlob* pIDisassembly = nullptr;
-		char* pDisassembly = nullptr;
-
-		HRESULT hr = D3DDisassemble((UINT*)microcode->GetBufferPointer(), 
-			microcode->GetBufferSize(), D3D_DISASM_ENABLE_COLOR_CODE, commentString, &pIDisassembly);
-
-		const char* assemblyCode =  static_cast<const char*>(pIDisassembly->GetBufferPointer());
-
-		if (FAILED(hr))
-			BS_EXCEPT(RenderingAPIException, "Unable to disassemble shader.");
-
-		ID3D11ShaderReflection* shaderReflection;
-		hr = D3DReflect((void*)microcode->GetBufferPointer(), microcode->GetBufferSize(),
-			IID_ID3D11ShaderReflection, (void**)&shaderReflection);
-
-		if (FAILED(hr))
-			BS_EXCEPT(RenderingAPIException, "Cannot reflect D3D11 high-level shader.");
-
-		D3D11_SHADER_DESC shaderDesc;
-		hr = shaderReflection->GetDesc(&shaderDesc);
-
-		if (FAILED(hr))
-			BS_EXCEPT(RenderingAPIException, "Cannot reflect D3D11 high-level shader.");
-
-		if (inputParams != nullptr)
-		{
-			D3D11_SIGNATURE_PARAMETER_DESC inputParamDesc;
-			for (UINT32 i = 0; i < shaderDesc.InputParameters; i++)
-			{
-				hr = shaderReflection->GetInputParameterDesc(i, &inputParamDesc);
-
-				if (FAILED(hr))
-					BS_EXCEPT(RenderingAPIException, "Cannot get input param desc with index: " + toString(i));
-
-				// We don't care about system value semantics
-				if (StringUtil::startsWith(String(inputParamDesc.SemanticName), "sv_"))
-					continue;
-
-				inputParams->push_back(VertexElement(inputParamDesc.Stream, inputParamDesc.Register,
-					D3D11Mappings::getInputType(inputParamDesc.ComponentType), D3D11Mappings::get(inputParamDesc.SemanticName), inputParamDesc.SemanticIndex));
-			}
-		}
-
-		for(UINT32 i = 0; i < shaderDesc.BoundResources; i++)
-		{
-			D3D11_SHADER_INPUT_BIND_DESC bindingDesc;
-			hr = shaderReflection->GetResourceBindingDesc(i, &bindingDesc);
-
-			if (FAILED(hr))
-				BS_EXCEPT(RenderingAPIException, "Cannot get resource binding desc with index: " + toString(i));
-
-			parseResource(bindingDesc, desc);
-		}
-
-		for(UINT32 i = 0; i < shaderDesc.ConstantBuffers; i++)
-		{
-			ID3D11ShaderReflectionConstantBuffer* shaderReflectionConstantBuffer;
-			shaderReflectionConstantBuffer = shaderReflection->GetConstantBufferByIndex(i);
-			
-			parseBuffer(shaderReflectionConstantBuffer, desc);
-		}
-
-		// TODO - Parse:
-		//  - Tex arrays, RW tex arrays and MS textures
-		//	- UINT8, UINT and double values
-
-		shaderReflection->Release();
-	}
-
-	void D3D11HLSLParamParser::parseResource(D3D11_SHADER_INPUT_BIND_DESC& resourceDesc, GpuParamDesc& desc)
-	{
-		for(UINT32 i = 0; i < resourceDesc.BindCount; i++)
-		{
-			if(resourceDesc.Type == D3D_SIT_CBUFFER || resourceDesc.Type == D3D_SIT_TBUFFER)
-			{
-				GpuParamBlockDesc blockDesc;
-				blockDesc.name = resourceDesc.Name;
-				blockDesc.slot = resourceDesc.BindPoint + i;
-				blockDesc.blockSize = 0; // Calculated manually as we add parameters
-
-				if(strcmp(resourceDesc.Name, "$Globals") == 0 || strcmp(resourceDesc.Name, "$Param") == 0) // Special buffers, as defined by DX11 docs
-					blockDesc.isShareable = false;
-				else
-					blockDesc.isShareable = true;
-
-				desc.paramBlocks.insert(std::make_pair(blockDesc.name, blockDesc));
-			}
-			else
-			{
-				GpuParamObjectDesc memberDesc;
-				memberDesc.name = resourceDesc.Name;
-				memberDesc.slot = resourceDesc.BindPoint + i;
-				memberDesc.type = GPOT_UNKNOWN;
-
-				switch(resourceDesc.Type)
-				{
-				case D3D_SIT_SAMPLER:
-					memberDesc.type = GPOT_SAMPLER2D; // Actual dimension of the sampler doesn't matter
-					desc.samplers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D_SIT_TEXTURE:
-					switch(resourceDesc.Dimension)
-					{
-					case D3D_SRV_DIMENSION_TEXTURE1D:
-						memberDesc.type = GPOT_TEXTURE1D;
-						break;
-					case D3D_SRV_DIMENSION_TEXTURE2D:
-						memberDesc.type = GPOT_TEXTURE2D;
-						break;
-					case D3D_SRV_DIMENSION_TEXTURE3D:
-						memberDesc.type = GPOT_TEXTURE3D;
-						break;
-					case D3D_SRV_DIMENSION_TEXTURECUBE:
-						memberDesc.type = GPOT_TEXTURECUBE;
-						break;
-					case D3D_SRV_DIMENSION_TEXTURE2DMS:
-						memberDesc.type = GPOT_TEXTURE2DMS;
-						break;
-					default:
-						LOGWRN("Skipping texture because it has unsupported dimension: " + toString(resourceDesc.Dimension));
-					}
-
-					if(memberDesc.type != GPOT_UNKNOWN)
-						desc.textures.insert(std::make_pair(memberDesc.name, memberDesc));
-
-					break;
-				case D3D_SIT_STRUCTURED:
-					memberDesc.type = GPOT_STRUCTURED_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D_SIT_BYTEADDRESS:
-					memberDesc.type = GPOT_BYTE_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D11_SIT_UAV_RWTYPED:
-					memberDesc.type = GPOT_RWTYPED_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D11_SIT_UAV_RWSTRUCTURED:
-					memberDesc.type = GPOT_RWSTRUCTURED_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D11_SIT_UAV_RWBYTEADDRESS:
-					memberDesc.type = GPOT_RWBYTE_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D_SIT_UAV_APPEND_STRUCTURED:
-					memberDesc.type = GPOT_RWAPPEND_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D_SIT_UAV_CONSUME_STRUCTURED:
-					memberDesc.type = GPOT_RWCONSUME_BUFFER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
-					memberDesc.type = GPOT_RWSTRUCTURED_BUFFER_WITH_COUNTER;
-					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
-					break;
-				default:
-					LOGWRN("Skipping resource because it has unsupported type: " + toString(resourceDesc.Type));
-				}
-			}
-		}
-	}
-
-	void D3D11HLSLParamParser::parseBuffer(ID3D11ShaderReflectionConstantBuffer* bufferReflection, GpuParamDesc& desc)
-	{
-		D3D11_SHADER_BUFFER_DESC constantBufferDesc;
-		HRESULT hr = bufferReflection->GetDesc(&constantBufferDesc);
-		if (FAILED(hr))
-			BS_EXCEPT(RenderingAPIException, "Failed to retrieve HLSL constant buffer description.");
-
-		if(constantBufferDesc.Type != D3D_CT_CBUFFER && constantBufferDesc.Type != D3D_CT_TBUFFER)
-		{
-			LOGWRN("D3D11 HLSL parsing: Unsupported constant buffer type, skipping. Type: " + toString(constantBufferDesc.Type));
-			return;
-		}
-
-		GpuParamBlockDesc& blockDesc = desc.paramBlocks[constantBufferDesc.Name];
-
-		for(UINT32 j = 0; j < constantBufferDesc.Variables; j++)
-		{
-			ID3D11ShaderReflectionVariable* varRef;
-			varRef = bufferReflection->GetVariableByIndex(j);
-			D3D11_SHADER_VARIABLE_DESC varDesc;
-			HRESULT hr = varRef->GetDesc(&varDesc);
-
-			if (FAILED(hr))
-				BS_EXCEPT(RenderingAPIException, "Failed to retrieve HLSL constant buffer variable description.");
-
-			ID3D11ShaderReflectionType* varRefType;
-			varRefType = varRef->GetType();
-			D3D11_SHADER_TYPE_DESC varTypeDesc;
-			varRefType->GetDesc(&varTypeDesc);
-
-			parseVariable(varTypeDesc, varDesc, desc, blockDesc);
-		}
-
-		blockDesc.blockSize = constantBufferDesc.Size / 4;
-	}
-
-	void D3D11HLSLParamParser::parseVariable(D3D11_SHADER_TYPE_DESC& varTypeDesc, D3D11_SHADER_VARIABLE_DESC& varDesc, GpuParamDesc& desc, GpuParamBlockDesc& paramBlock)
-	{
-		GpuParamDataDesc memberDesc;
-		memberDesc.name = varDesc.Name;
-		memberDesc.paramBlockSlot = paramBlock.slot;
-		memberDesc.arraySize = varTypeDesc.Elements == 0 ? 1 : varTypeDesc.Elements;
-		memberDesc.gpuMemOffset = varDesc.StartOffset / 4;
-		memberDesc.cpuMemOffset = varDesc.StartOffset / 4;
-		
-		// Determine individual element size in the array
-		if(memberDesc.arraySize > 1)
-		{
-			// Find array element size (reported size is total size of array, minus unused register slots)
-			int totalArraySize = (varDesc.Size / 4);
-
-			int totalSlotsUsedByArray = (totalArraySize / 4 + 1) * 4;
-			int unusedSlotsInArray = totalSlotsUsedByArray - totalArraySize;
-
-			memberDesc.arrayElementStride = totalSlotsUsedByArray / memberDesc.arraySize;
-			memberDesc.elementSize = memberDesc.arrayElementStride - unusedSlotsInArray;
-		}
-		else
-		{
-			memberDesc.elementSize = varDesc.Size / 4; // Stored in multiples of 4
-			memberDesc.arrayElementStride = memberDesc.elementSize;
-		}
-			
-		switch(varTypeDesc.Class)
-		{
-		case D3D_SVC_SCALAR:
-			{
-				switch(varTypeDesc.Type)
-				{
-				case D3D_SVT_BOOL:
-					memberDesc.type = GPDT_BOOL;
-					break;
-				case D3D_SVT_INT:
-					memberDesc.type = GPDT_INT1;
-					break;
-				case D3D_SVT_FLOAT:
-					memberDesc.type = GPDT_FLOAT1;
-					break;
-				default:
-					LOGWRN("Skipping variable because it has unsupported type: " + toString(varTypeDesc.Type));
-				}
-			}
-			break;
-		case D3D_SVC_VECTOR:
-			{
-				switch(varTypeDesc.Type)
-				{
-				case D3D_SVT_INT:
-					{
-						switch(varTypeDesc.Columns)
-						{
-						case 1:
-							memberDesc.type = GPDT_INT1;
-							break;
-						case 2:
-							memberDesc.type = GPDT_INT2;
-							break;
-						case 3:
-							memberDesc.type = GPDT_INT3;
-							break;
-						case 4:
-							memberDesc.type = GPDT_INT4;
-							break;
-						}
-					}
-					
-					break;
-				case D3D_SVT_FLOAT:
-					{
-						switch(varTypeDesc.Columns)
-						{
-						case 1:
-							memberDesc.type = GPDT_FLOAT1;
-							break;
-						case 2:
-							memberDesc.type = GPDT_FLOAT2;
-							break;
-						case 3:
-							memberDesc.type = GPDT_FLOAT3;
-							break;
-						case 4:
-							memberDesc.type = GPDT_FLOAT4;
-							break;
-						}
-					}
-
-					break;
-				}
-			}
-			break;
-		case D3D_SVC_MATRIX_COLUMNS:
-		case D3D_SVC_MATRIX_ROWS:
-			switch(varTypeDesc.Rows)
-			{
-			case 2:
-				switch(varTypeDesc.Columns)
-				{
-				case 2:
-					memberDesc.type = GPDT_MATRIX_2X2;
-					break;
-				case 3:
-					memberDesc.type = GPDT_MATRIX_2X3;
-					break;
-				case 4:
-					memberDesc.type = GPDT_MATRIX_2X4;
-					break;
-				}
-				break;
-			case 3:
-				switch(varTypeDesc.Columns)
-				{
-				case 2:
-					memberDesc.type = GPDT_MATRIX_3X2;
-					break;
-				case 3:
-					memberDesc.type = GPDT_MATRIX_3X3;
-					break;
-				case 4:
-					memberDesc.type = GPDT_MATRIX_3X4;
-					break;
-				}
-				break;
-			case 4:
-				switch(varTypeDesc.Columns)
-				{
-				case 2:
-					memberDesc.type = GPDT_MATRIX_4X2;
-					break;
-				case 3:
-					memberDesc.type = GPDT_MATRIX_4X3;
-					break;
-				case 4:
-					memberDesc.type = GPDT_MATRIX_4X4;
-					break;
-				}
-				break;
-			}
-			break;
-		case D3D_SVC_STRUCT:
-			memberDesc.type = GPDT_STRUCT;
-			break;
-		default:
-			LOGWRN("Skipping variable because it has unsupported class: " + toString(varTypeDesc.Class));
-		}
-
-		desc.params.insert(std::make_pair(memberDesc.name, memberDesc));
-	}
+#include "BsD3D11HLSLParamParser.h"
+#include "BsD3D11Mappings.h"
+#include "BsGpuParamDesc.h"
+#include "BsException.h"
+#include "BsDebug.h"
+
+namespace BansheeEngine
+{
+	void D3D11HLSLParamParser::parse(ID3DBlob* microcode, GpuParamDesc& desc, List<VertexElement>* inputParams)
+	{
+		const char* commentString = nullptr;
+		ID3DBlob* pIDisassembly = nullptr;
+		char* pDisassembly = nullptr;
+
+		HRESULT hr = D3DDisassemble((UINT*)microcode->GetBufferPointer(), 
+			microcode->GetBufferSize(), D3D_DISASM_ENABLE_COLOR_CODE, commentString, &pIDisassembly);
+
+		const char* assemblyCode =  static_cast<const char*>(pIDisassembly->GetBufferPointer());
+
+		if (FAILED(hr))
+			BS_EXCEPT(RenderingAPIException, "Unable to disassemble shader.");
+
+		ID3D11ShaderReflection* shaderReflection;
+		hr = D3DReflect((void*)microcode->GetBufferPointer(), microcode->GetBufferSize(),
+			IID_ID3D11ShaderReflection, (void**)&shaderReflection);
+
+		if (FAILED(hr))
+			BS_EXCEPT(RenderingAPIException, "Cannot reflect D3D11 high-level shader.");
+
+		D3D11_SHADER_DESC shaderDesc;
+		hr = shaderReflection->GetDesc(&shaderDesc);
+
+		if (FAILED(hr))
+			BS_EXCEPT(RenderingAPIException, "Cannot reflect D3D11 high-level shader.");
+
+		if (inputParams != nullptr)
+		{
+			D3D11_SIGNATURE_PARAMETER_DESC inputParamDesc;
+			for (UINT32 i = 0; i < shaderDesc.InputParameters; i++)
+			{
+				hr = shaderReflection->GetInputParameterDesc(i, &inputParamDesc);
+
+				if (FAILED(hr))
+					BS_EXCEPT(RenderingAPIException, "Cannot get input param desc with index: " + toString(i));
+
+				// We don't care about system value semantics
+				if (StringUtil::startsWith(String(inputParamDesc.SemanticName), "sv_"))
+					continue;
+
+				inputParams->push_back(VertexElement(inputParamDesc.Stream, inputParamDesc.Register,
+					D3D11Mappings::getInputType(inputParamDesc.ComponentType), D3D11Mappings::get(inputParamDesc.SemanticName), inputParamDesc.SemanticIndex));
+			}
+		}
+
+		for(UINT32 i = 0; i < shaderDesc.BoundResources; i++)
+		{
+			D3D11_SHADER_INPUT_BIND_DESC bindingDesc;
+			hr = shaderReflection->GetResourceBindingDesc(i, &bindingDesc);
+
+			if (FAILED(hr))
+				BS_EXCEPT(RenderingAPIException, "Cannot get resource binding desc with index: " + toString(i));
+
+			parseResource(bindingDesc, desc);
+		}
+
+		for(UINT32 i = 0; i < shaderDesc.ConstantBuffers; i++)
+		{
+			ID3D11ShaderReflectionConstantBuffer* shaderReflectionConstantBuffer;
+			shaderReflectionConstantBuffer = shaderReflection->GetConstantBufferByIndex(i);
+			
+			parseBuffer(shaderReflectionConstantBuffer, desc);
+		}
+
+		// TODO - Parse:
+		//  - Tex arrays, RW tex arrays and MS textures
+		//	- UINT8, UINT and double values
+
+		shaderReflection->Release();
+	}
+
+	void D3D11HLSLParamParser::parseResource(D3D11_SHADER_INPUT_BIND_DESC& resourceDesc, GpuParamDesc& desc)
+	{
+		for(UINT32 i = 0; i < resourceDesc.BindCount; i++)
+		{
+			if(resourceDesc.Type == D3D_SIT_CBUFFER || resourceDesc.Type == D3D_SIT_TBUFFER)
+			{
+				GpuParamBlockDesc blockDesc;
+				blockDesc.name = resourceDesc.Name;
+				blockDesc.slot = resourceDesc.BindPoint + i;
+				blockDesc.blockSize = 0; // Calculated manually as we add parameters
+
+				if(strcmp(resourceDesc.Name, "$Globals") == 0 || strcmp(resourceDesc.Name, "$Param") == 0) // Special buffers, as defined by DX11 docs
+					blockDesc.isShareable = false;
+				else
+					blockDesc.isShareable = true;
+
+				desc.paramBlocks.insert(std::make_pair(blockDesc.name, blockDesc));
+			}
+			else
+			{
+				GpuParamObjectDesc memberDesc;
+				memberDesc.name = resourceDesc.Name;
+				memberDesc.slot = resourceDesc.BindPoint + i;
+				memberDesc.type = GPOT_UNKNOWN;
+
+				switch(resourceDesc.Type)
+				{
+				case D3D_SIT_SAMPLER:
+					memberDesc.type = GPOT_SAMPLER2D; // Actual dimension of the sampler doesn't matter
+					desc.samplers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D_SIT_TEXTURE:
+					switch(resourceDesc.Dimension)
+					{
+					case D3D_SRV_DIMENSION_TEXTURE1D:
+						memberDesc.type = GPOT_TEXTURE1D;
+						break;
+					case D3D_SRV_DIMENSION_TEXTURE2D:
+						memberDesc.type = GPOT_TEXTURE2D;
+						break;
+					case D3D_SRV_DIMENSION_TEXTURE3D:
+						memberDesc.type = GPOT_TEXTURE3D;
+						break;
+					case D3D_SRV_DIMENSION_TEXTURECUBE:
+						memberDesc.type = GPOT_TEXTURECUBE;
+						break;
+					case D3D_SRV_DIMENSION_TEXTURE2DMS:
+						memberDesc.type = GPOT_TEXTURE2DMS;
+						break;
+					default:
+						LOGWRN("Skipping texture because it has unsupported dimension: " + toString(resourceDesc.Dimension));
+					}
+
+					if(memberDesc.type != GPOT_UNKNOWN)
+						desc.textures.insert(std::make_pair(memberDesc.name, memberDesc));
+
+					break;
+				case D3D_SIT_STRUCTURED:
+					memberDesc.type = GPOT_STRUCTURED_BUFFER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D_SIT_BYTEADDRESS:
+					memberDesc.type = GPOT_BYTE_BUFFER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D11_SIT_UAV_RWTYPED:
+					memberDesc.type = GPOT_RWTYPED_BUFFER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D11_SIT_UAV_RWSTRUCTURED:
+					memberDesc.type = GPOT_RWSTRUCTURED_BUFFER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D11_SIT_UAV_RWBYTEADDRESS:
+					memberDesc.type = GPOT_RWBYTE_BUFFER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D_SIT_UAV_APPEND_STRUCTURED:
+					memberDesc.type = GPOT_RWAPPEND_BUFFER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D_SIT_UAV_CONSUME_STRUCTURED:
+					memberDesc.type = GPOT_RWCONSUME_BUFFER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER:
+					memberDesc.type = GPOT_RWSTRUCTURED_BUFFER_WITH_COUNTER;
+					desc.buffers.insert(std::make_pair(memberDesc.name, memberDesc));
+					break;
+				default:
+					LOGWRN("Skipping resource because it has unsupported type: " + toString(resourceDesc.Type));
+				}
+			}
+		}
+	}
+
+	void D3D11HLSLParamParser::parseBuffer(ID3D11ShaderReflectionConstantBuffer* bufferReflection, GpuParamDesc& desc)
+	{
+		D3D11_SHADER_BUFFER_DESC constantBufferDesc;
+		HRESULT hr = bufferReflection->GetDesc(&constantBufferDesc);
+		if (FAILED(hr))
+			BS_EXCEPT(RenderingAPIException, "Failed to retrieve HLSL constant buffer description.");
+
+		if(constantBufferDesc.Type != D3D_CT_CBUFFER && constantBufferDesc.Type != D3D_CT_TBUFFER)
+		{
+			LOGWRN("D3D11 HLSL parsing: Unsupported constant buffer type, skipping. Type: " + toString(constantBufferDesc.Type));
+			return;
+		}
+
+		GpuParamBlockDesc& blockDesc = desc.paramBlocks[constantBufferDesc.Name];
+
+		for(UINT32 j = 0; j < constantBufferDesc.Variables; j++)
+		{
+			ID3D11ShaderReflectionVariable* varRef;
+			varRef = bufferReflection->GetVariableByIndex(j);
+			D3D11_SHADER_VARIABLE_DESC varDesc;
+			HRESULT hr = varRef->GetDesc(&varDesc);
+
+			if (FAILED(hr))
+				BS_EXCEPT(RenderingAPIException, "Failed to retrieve HLSL constant buffer variable description.");
+
+			ID3D11ShaderReflectionType* varRefType;
+			varRefType = varRef->GetType();
+			D3D11_SHADER_TYPE_DESC varTypeDesc;
+			varRefType->GetDesc(&varTypeDesc);
+
+			parseVariable(varTypeDesc, varDesc, desc, blockDesc);
+		}
+
+		blockDesc.blockSize = constantBufferDesc.Size / 4;
+	}
+
+	void D3D11HLSLParamParser::parseVariable(D3D11_SHADER_TYPE_DESC& varTypeDesc, D3D11_SHADER_VARIABLE_DESC& varDesc, GpuParamDesc& desc, GpuParamBlockDesc& paramBlock)
+	{
+		GpuParamDataDesc memberDesc;
+		memberDesc.name = varDesc.Name;
+		memberDesc.paramBlockSlot = paramBlock.slot;
+		memberDesc.arraySize = varTypeDesc.Elements == 0 ? 1 : varTypeDesc.Elements;
+		memberDesc.gpuMemOffset = varDesc.StartOffset / 4;
+		memberDesc.cpuMemOffset = varDesc.StartOffset / 4;
+		
+		// Determine individual element size in the array
+		if(memberDesc.arraySize > 1)
+		{
+			// Find array element size (reported size is total size of array, minus unused register slots)
+			int totalArraySize = (varDesc.Size / 4);
+
+			int totalSlotsUsedByArray = (totalArraySize / 4 + 1) * 4;
+			int unusedSlotsInArray = totalSlotsUsedByArray - totalArraySize;
+
+			memberDesc.arrayElementStride = totalSlotsUsedByArray / memberDesc.arraySize;
+			memberDesc.elementSize = memberDesc.arrayElementStride - unusedSlotsInArray;
+		}
+		else
+		{
+			memberDesc.elementSize = varDesc.Size / 4; // Stored in multiples of 4
+			memberDesc.arrayElementStride = memberDesc.elementSize;
+		}
+			
+		switch(varTypeDesc.Class)
+		{
+		case D3D_SVC_SCALAR:
+			{
+				switch(varTypeDesc.Type)
+				{
+				case D3D_SVT_BOOL:
+					memberDesc.type = GPDT_BOOL;
+					break;
+				case D3D_SVT_INT:
+				case D3D_SVT_UINT:
+					memberDesc.type = GPDT_INT1;
+					break;
+				case D3D_SVT_FLOAT:
+					memberDesc.type = GPDT_FLOAT1;
+					break;
+				default:
+					LOGWRN("Skipping variable because it has unsupported type: " + toString(varTypeDesc.Type));
+				}
+			}
+			break;
+		case D3D_SVC_VECTOR:
+			{
+				switch(varTypeDesc.Type)
+				{
+				case D3D_SVT_INT:
+					{
+						switch(varTypeDesc.Columns)
+						{
+						case 1:
+							memberDesc.type = GPDT_INT1;
+							break;
+						case 2:
+							memberDesc.type = GPDT_INT2;
+							break;
+						case 3:
+							memberDesc.type = GPDT_INT3;
+							break;
+						case 4:
+							memberDesc.type = GPDT_INT4;
+							break;
+						}
+					}
+					
+					break;
+				case D3D_SVT_FLOAT:
+					{
+						switch(varTypeDesc.Columns)
+						{
+						case 1:
+							memberDesc.type = GPDT_FLOAT1;
+							break;
+						case 2:
+							memberDesc.type = GPDT_FLOAT2;
+							break;
+						case 3:
+							memberDesc.type = GPDT_FLOAT3;
+							break;
+						case 4:
+							memberDesc.type = GPDT_FLOAT4;
+							break;
+						}
+					}
+
+					break;
+				}
+			}
+			break;
+		case D3D_SVC_MATRIX_COLUMNS:
+		case D3D_SVC_MATRIX_ROWS:
+			switch(varTypeDesc.Rows)
+			{
+			case 2:
+				switch(varTypeDesc.Columns)
+				{
+				case 2:
+					memberDesc.type = GPDT_MATRIX_2X2;
+					break;
+				case 3:
+					memberDesc.type = GPDT_MATRIX_2X3;
+					break;
+				case 4:
+					memberDesc.type = GPDT_MATRIX_2X4;
+					break;
+				}
+				break;
+			case 3:
+				switch(varTypeDesc.Columns)
+				{
+				case 2:
+					memberDesc.type = GPDT_MATRIX_3X2;
+					break;
+				case 3:
+					memberDesc.type = GPDT_MATRIX_3X3;
+					break;
+				case 4:
+					memberDesc.type = GPDT_MATRIX_3X4;
+					break;
+				}
+				break;
+			case 4:
+				switch(varTypeDesc.Columns)
+				{
+				case 2:
+					memberDesc.type = GPDT_MATRIX_4X2;
+					break;
+				case 3:
+					memberDesc.type = GPDT_MATRIX_4X3;
+					break;
+				case 4:
+					memberDesc.type = GPDT_MATRIX_4X4;
+					break;
+				}
+				break;
+			}
+			break;
+		case D3D_SVC_STRUCT:
+			memberDesc.type = GPDT_STRUCT;
+			break;
+		default:
+			LOGWRN("Skipping variable because it has unsupported class: " + toString(varTypeDesc.Class));
+		}
+
+		desc.params.insert(std::make_pair(memberDesc.name, memberDesc));
+	}
 }

BansheeEditor/Source/BsHandleDrawManager.cpp

@@ -370,6 +370,6 @@ namespace BansheeEngine
 
 		// Set alpha of everything that was drawn to 1 so we can overlay this texture onto GUI using transparency
 		gRendererUtility().setPass(mClearMaterial.mat, 0);
-		gRendererUtility().drawScreenQuad(*camera->getViewport());
+		gRendererUtility().drawScreenQuad();
 	}
 }

BansheeEngine/Include/BsRendererUtility.h

@@ -4,6 +4,7 @@
 #include "BsModule.h"
 #include "BsRect2.h"
 #include "BsVector2I.h"
+#include "BsRect2I.h"
 #include "BsRendererMaterial.h"
 
 namespace BansheeEngine
@@ -13,6 +14,9 @@ namespace BansheeEngine
 	 *  @{
 	 */
 
+	class ResolveMat;
+	class BlitMat;
+
 	/**
 	 * Contains various utility methods that make various common operations in the renderer easier.
 	 * 			
@@ -51,10 +55,19 @@ namespace BansheeEngine
 		 */
 		void draw(const SPtr<MeshCoreBase>& mesh, const SubMesh& subMesh);
 
+		/**
+		 * Blits contents of the provided texture into the currently bound render target. If the provided texture contains
+		 * multiple samples, they will be resolved.
+		 *
+		 * @param[in]	texture	Source texture to blit.
+		 * @param[in]	area	Area of the source texture to blit in pixels. If width or height is zero it is assumed
+		 *						the entire texture should be blitted.
+		 */
+		void blit(const SPtr<TextureCore>& texture, const Rect2I& area = Rect2I::EMPTY);
+
 		/**
 		 * Draws a quad over the entire viewport in normalized device coordinates.
 		 * 			
-		 * @param[in]	viewport	Destination viewport to draw the quad in.
 		 * @param[in]	uv			UV coordinates to assign to the corners of the quad.
 		 * @param[in]	textureSize	Size of the texture the UV coordinates are specified for. If the UV coordinates are 
 		 *							already in normalized (0, 1) range then keep this value as is. If the UV coordinates 
@@ -63,8 +76,7 @@ namespace BansheeEngine
 		 * 			
 		 * @note	Core thread.
 		 */
-		void drawScreenQuad(const ViewportCore& viewport, const Rect2& uv = Rect2(0.0f, 0.0f, 1.0f, 1.0f), 
-			const Vector2I& textureSize = Vector2I(1, 1));
+		void drawScreenQuad(const Rect2& uv = Rect2(0.0f, 0.0f, 1.0f, 1.0f), const Vector2I& textureSize = Vector2I(1, 1));
 
 		/** Returns a stencil mesh used for a point light (a unit sphere). */
 		SPtr<MeshCore> getPointLightStencil() const { return mPointLightStencilMesh; }
@@ -76,6 +88,8 @@ namespace BansheeEngine
 		SPtr<MeshCore> mFullScreenQuadMesh;
 		SPtr<MeshCore> mPointLightStencilMesh;
 		SPtr<MeshCore> mSpotLightStencilMesh;
+		SPtr<ResolveMat> mResolveMat;
+		SPtr<BlitMat> mBlitMat;
 	};
 
 	/**
@@ -100,6 +114,20 @@ namespace BansheeEngine
 		MaterialParamTextureCore mSource;
 	};
 
+	/** Shader that copies a source texture into a render target. */
+	class BlitMat : public RendererMaterial<BlitMat>
+	{
+		RMAT_DEF("Blit.bsl");
+
+	public:
+		BlitMat();
+
+		/** Updates the parameter buffers used by the material. */
+		void setParameters(const SPtr<TextureCore>& source);
+	private:
+		MaterialParamTextureCore mSource;
+	};
+
 	/** @} */
 	/** @endcond */
 }

BansheeEngine/Source/BsRendererUtility.cpp

@@ -101,11 +101,15 @@ namespace BansheeEngine
 
 			mSpotLightStencilMesh = MeshCore::create(meshData);
 		}
+
+		// TODO - When I add proper preprocessor support, merge these into a single material
+		mResolveMat = bs_shared_ptr_new<ResolveMat>();
+		mBlitMat = bs_shared_ptr_new<BlitMat>();
 	}
 
 	RendererUtility::~RendererUtility()
 	{
-		
+
 	}
 
 	void RendererUtility::setPass(const SPtr<MaterialCore>& material, UINT32 passIdx)
@@ -296,16 +300,44 @@ namespace BansheeEngine
 		mesh->_notifyUsedOnGPU();
 	}
 
-	void RendererUtility::drawScreenQuad(const ViewportCore& viewport, const Rect2& uv, const Vector2I& textureSize)
+	void RendererUtility::blit(const SPtr<TextureCore>& texture, const Rect2I& area)
 	{
-		// Note: Consider drawing the quad using a single large triangle for possibly better performance
-		Rect2I viewArea = viewport.getArea();
+		auto& texProps = texture->getProperties();
+		SPtr<MaterialCore> mat;
+		if (texProps.getMultisampleCount() > 1)
+		{
+			mat = mResolveMat->getMaterial();
+			mResolveMat->setParameters(texture);
+		}
+		else
+		{
+			mat = mBlitMat->getMaterial();
+			mBlitMat->setParameters(texture);
+		}
+
+		setPass(mat, 0);
+		setPassParams(mat);
+
+		Rect2 fArea((float)area.x, (float)area.y, (float)area.width, (float)area.height);
+		if(area.width == 0 || area.height == 0)
+		{
+			fArea.x = 0.0f;
+			fArea.y = 0.0f;
+			fArea.width = (float)texProps.getWidth();
+			fArea.height = (float)texProps.getHeight();
+		}
 
+		drawScreenQuad(fArea);
+	}
+
+	void RendererUtility::drawScreenQuad(const Rect2& uv, const Vector2I& textureSize)
+	{
+		// Note: Consider drawing the quad using a single large triangle for possibly better performance
 		Vector3 vertices[4];
-		vertices[0] = Vector3((float)viewArea.x, (float)viewArea.y, 0.0f);
-		vertices[1] = Vector3((float)viewArea.x + (float)viewArea.width, (float)viewArea.y, 0.0f);
-		vertices[2] = Vector3((float)viewArea.x, (float)viewArea.y + (float)viewArea.height, 0.0f);
-		vertices[3] = Vector3((float)viewArea.x + (float)viewArea.width, (float)viewArea.y + (float)viewArea.height, 0.0f);
+		vertices[0] = Vector3(-1.0f, 1.0f, 0.0f);
+		vertices[1] = Vector3(1.0f, 1.0f, 0.0f);
+		vertices[2] = Vector3(-1.0f, -1.0f, 0.0f);
+		vertices[3] = Vector3(1.0f, -1.0f, 0.0f);
 
 		Vector2 uvs[4];
 		uvs[0] = Vector2(uv.x, uv.y);
@@ -313,13 +345,8 @@ namespace BansheeEngine
 		uvs[2] = Vector2(uv.x, uv.y + uv.height);
 		uvs[3] = Vector2(uv.x + uv.width, uv.y + uv.height);
 
-		auto targetProps = viewport.getTarget()->getProperties();;
-		RenderAPICore& rapi = RenderAPICore::instance();
 		for (int i = 0; i < 4; i++)
 		{
-			vertices[i].x = -1.0f + 2.0f * (vertices[i].x + rapi.getHorizontalTexelOffset()) / targetProps.getWidth();
-			vertices[i].y = 1.0f - 2.0f * (vertices[i].y + rapi.getVerticalTexelOffset()) / targetProps.getHeight();
-
 			uvs[i].x /= (float)textureSize.x;
 			uvs[i].y /= (float)textureSize.y;
 		}
@@ -352,9 +379,19 @@ namespace BansheeEngine
 		return RendererUtility::instance();
 	}
 
+	BlitMat::BlitMat()
+	{
+		mSource = mMaterial->getParamTexture("gSource");
+	}
+
+	void BlitMat::setParameters(const SPtr<TextureCore>& source)
+	{
+		mSource.set(source);
+	}
+
 	ResolveMat::ResolveMat()
 	{
-		mSource = mMaterial->getParamTexture("gSource");;
+		mSource = mMaterial->getParamTexture("gSource");
 		mMaterial->getParam("gNumSamples", mNumSamples);
 	}
 

BansheeSL/BsLexerFX.h

@@ -335,7 +335,7 @@ extern int yylex \
 #undef YY_DECL
 #endif
 
-#line 229 "BsLexerFX.l"
+#line 234 "BsLexerFX.l"
 
 #line 341 "BsLexerFX.h"
 #undef yyIN_HEADER

BansheeSL/BsLexerFX.l

@@ -1,229 +1,234 @@
-%{
-#include "BsParserFX.h"
-
-#define YY_USER_ACTION yylloc->first_column = yycolumn + 1; yylloc->first_line = yylineno + 1; yycolumn += (int)yyleng;
-#define YY_USER_INIT yylineno = 0; yycolumn = 0;
-%}
- 
-%option yylineno reentrant noyywrap nounistd never-interactive warn nodefault bison-bridge bison-locations
-%option outfile="BsLexerFX.c" header-file="BsLexerFX.h"
-%option extra-type="struct tagParseState *"
-
-INTEGER			-?[0-9][0-9]*
-INTEGER_16		0[xX][0-9a-fA-F]+
-FLOAT			[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?
-STRING			\"[^"\n]*\"
-IDENTIFIER		[_a-zA-Z][_a-zA-Z0-9]*
-WS				[ \r\n\t]*
-COMMENT			\/\/[^\n]*
-
-%%
-
-{WS}			{ /* Skip blank */ }
-{INTEGER}       { yylval->intValue = atoi(yytext); return TOKEN_INTEGER; }
-{INTEGER_16}    { yylval->intValue = (int)strtol(yytext, 0, 0); return TOKEN_INTEGER; }
-{FLOAT}			{ yylval->floatValue = (float)atof(yytext); return TOKEN_FLOAT; }
-{STRING}		{ yylval->strValue = mmalloc_strdup(yyextra->memContext, yytext); return TOKEN_STRING; }
-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; }
-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; }
-
-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; }
-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; }
-Include			{ return TOKEN_INCLUDE; }
-Pass			{ return TOKEN_PASS; }
-
-	/* Pass keywords */
-Vertex			{ return TOKEN_VERTEX; }
-Fragment		{ return TOKEN_FRAGMENT; }
-Geometry		{ return TOKEN_GEOMETRY; }
-Hull			{ return TOKEN_HULL; }
-Domain			{ return TOKEN_DOMAIN; }
-Compute			{ return TOKEN_COMPUTE; }
-Common			{ return TOKEN_COMMON; }
-StencilRef		{ return TOKEN_STENCILREF; }
-
-	/* Rasterizer state keywords */
-Fill			{ return TOKEN_FILLMODE; }
-Cull			{ return TOKEN_CULLMODE; }
-DepthBias		{ return TOKEN_DEPTHBIAS; }
-ScaledDepthBias	{ return TOKEN_SDEPTHBIAS; }
-DepthClip		{ return TOKEN_DEPTHCLIP; }
-Scissor			{ return TOKEN_SCISSOR; }
-Multisample		{ return TOKEN_MULTISAMPLE; }
-AALine			{ return TOKEN_AALINE; }
-
-	/* Depth-stencil state keywords */
-DepthRead			{ return TOKEN_DEPTHREAD; }
-DepthWrite			{ return TOKEN_DEPTHWRITE; }
-CompareFunc			{ return TOKEN_COMPAREFUNC; }
-Stencil				{ return TOKEN_STENCIL; }
-StencilReadMask		{ return TOKEN_STENCILREADMASK; }
-StencilWriteMask	{ return TOKEN_STENCILWRITEMASK; }
-StencilOpFront		{ return TOKEN_STENCILOPFRONT; }
-StencilOpBack		{ return TOKEN_STENCILOPBACK; }
-Fail				{ return TOKEN_FAIL; }
-ZFail				{ return TOKEN_ZFAIL; }
-
-	/* Blend state keywords */
-AlphaToCoverage		{ return TOKEN_ALPHATOCOVERAGE; }
-IndependantBlend	{ return TOKEN_INDEPENDANTBLEND; }
-Target				{ return TOKEN_TARGET; }
-Index				{ return TOKEN_INDEX; }
-Blend				{ return TOKEN_BLEND; }
-Color				{ return TOKEN_COLOR; }
-Alpha				{ return TOKEN_ALPHA; }
-WriteMask			{ return TOKEN_WRITEMASK; }
-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; }
-
-	/* State values */
-WIRE			{ yylval->intValue = FMV_Wire; return TOKEN_FILLMODEVALUE; }
-SOLID			{ yylval->intValue = FMV_Solid; return TOKEN_FILLMODEVALUE; }
-
-NOCULL			{ yylval->intValue = CMV_None; return TOKEN_CULLMODEVALUE; }
-CW				{ yylval->intValue = CMV_CW; return TOKEN_CULLMODEVALUE; }
-CCW				{ yylval->intValue = CMV_CCW; return TOKEN_CULLMODEVALUE; }
-
-FAIL			{ yylval->intValue = CFV_Fail; return TOKEN_COMPFUNCVALUE; }
-PASS			{ yylval->intValue = CFV_Pass; return TOKEN_COMPFUNCVALUE; }
-LT				{ yylval->intValue = CFV_LT; return TOKEN_COMPFUNCVALUE; }
-LTE				{ yylval->intValue = CFV_LTE; return TOKEN_COMPFUNCVALUE; }
-EQ				{ yylval->intValue = CFV_EQ; return TOKEN_COMPFUNCVALUE; }
-NEQ				{ yylval->intValue = CFV_NEQ; return TOKEN_COMPFUNCVALUE; }
-GTE				{ yylval->intValue = CFV_GTE; return TOKEN_COMPFUNCVALUE; }
-GT				{ yylval->intValue = CFV_GT; return TOKEN_COMPFUNCVALUE; }
-
-KEEP				{ yylval->intValue = OV_Keep; return TOKEN_OPVALUE; }
-ZERO				{ yylval->intValue = OV_Zero; return TOKEN_OPVALUE; }
-REPLACE				{ yylval->intValue = OV_Replace; return TOKEN_OPVALUE; }
-INC					{ yylval->intValue = OV_Incr; return TOKEN_OPVALUE; }
-DEC					{ yylval->intValue = OV_Decr; return TOKEN_OPVALUE; }
-INCWRAP				{ yylval->intValue = OV_IncrWrap; return TOKEN_OPVALUE; }
-DECWRAP				{ yylval->intValue = OV_DecrWrap; return TOKEN_OPVALUE; }
-INV					{ yylval->intValue = OV_Invert; return TOKEN_OPVALUE; }
-ONE					{ yylval->intValue = OV_One; return TOKEN_OPVALUE; }
-DSTRGB				{ yylval->intValue = OV_DestColor; return TOKEN_OPVALUE; }
-SRCRGB				{ yylval->intValue = OV_SrcColor; return TOKEN_OPVALUE; }
-DSTIRGB				{ yylval->intValue = OV_InvDestColor; return TOKEN_OPVALUE; }
-SRCIRGB				{ yylval->intValue = OV_InvSrcColor; return TOKEN_OPVALUE; }
-DSTA				{ yylval->intValue = OV_DestAlpha; return TOKEN_OPVALUE; }
-SRCA				{ yylval->intValue = OV_SrcAlpha; return TOKEN_OPVALUE; }
-DSTIA				{ yylval->intValue = OV_InvDestAlpha; return TOKEN_OPVALUE; }
-SRCIA				{ yylval->intValue = OV_InvSrcAlpha; return TOKEN_OPVALUE; }
-
-ADD					{ yylval->intValue = BOV_Add; return TOKEN_BLENDOPVALUE; }
-SUB					{ yylval->intValue = BOV_Subtract; return TOKEN_BLENDOPVALUE; }
-RSUB				{ yylval->intValue = BOV_RevSubtract; return TOKEN_BLENDOPVALUE; }
-MIN					{ yylval->intValue = BOV_Min; return TOKEN_BLENDOPVALUE; }
-MAX					{ yylval->intValue = BOV_Max; return TOKEN_BLENDOPVALUE; }
-
-NOCOLOR			{ yylval->intValue = 0x0; return TOKEN_COLORMASK; }
-R				{ yylval->intValue = 0x1; return TOKEN_COLORMASK; }
-G				{ yylval->intValue = 0x2; return TOKEN_COLORMASK; }
-B				{ yylval->intValue = 0x4; return TOKEN_COLORMASK; }
-A				{ yylval->intValue = 0x8; return TOKEN_COLORMASK; }
-RG				{ yylval->intValue = 0x3; return TOKEN_COLORMASK; }
-RB				{ yylval->intValue = 0x5; return TOKEN_COLORMASK; }
-RA				{ yylval->intValue = 0x9; return TOKEN_COLORMASK; }
-GB				{ yylval->intValue = 0x6; return TOKEN_COLORMASK; }
-GA				{ yylval->intValue = 0xA; return TOKEN_COLORMASK; }
-BA				{ yylval->intValue = 0xC; return TOKEN_COLORMASK; }
-RGB				{ yylval->intValue = 0x7; return TOKEN_COLORMASK; }
-RGA				{ yylval->intValue = 0xB; return TOKEN_COLORMASK; }
-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; }
-
-{COMMENT}		{ }
-{IDENTIFIER}	{ yylval->strValue = mmalloc_strdup(yyextra->memContext, yytext); return TOKEN_IDENTIFIER; }
-.				{ return yytext[0]; }
+%{
+#include "BsParserFX.h"
+
+#define YY_USER_ACTION yylloc->first_column = yycolumn + 1; yylloc->first_line = yylineno + 1; yycolumn += (int)yyleng;
+#define YY_USER_INIT yylineno = 0; yycolumn = 0;
+%}
+ 
+%option yylineno reentrant noyywrap nounistd never-interactive warn nodefault bison-bridge bison-locations
+%option outfile="BsLexerFX.c" header-file="BsLexerFX.h"
+%option extra-type="struct tagParseState *"
+
+INTEGER			-?[0-9][0-9]*
+INTEGER_16		0[xX][0-9a-fA-F]+
+FLOAT			[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?
+STRING			\"[^"\n]*\"
+IDENTIFIER		[_a-zA-Z][_a-zA-Z0-9]*
+WS				[ \r\n\t]*
+COMMENT			\/\/[^\n]*
+
+%%
+
+{WS}			{ /* Skip blank */ }
+{INTEGER}       { yylval->intValue = atoi(yytext); return TOKEN_INTEGER; }
+{INTEGER_16}    { yylval->intValue = (int)strtol(yytext, 0, 0); return TOKEN_INTEGER; }
+{FLOAT}			{ yylval->floatValue = (float)atof(yytext); return TOKEN_FLOAT; }
+{STRING}		{ yylval->strValue = mmalloc_strdup(yyextra->memContext, yytext); return TOKEN_STRING; }
+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; }
+
+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; }
+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; }
+Include			{ return TOKEN_INCLUDE; }
+Pass			{ return TOKEN_PASS; }
+
+	/* Pass keywords */
+Vertex			{ return TOKEN_VERTEX; }
+Fragment		{ return TOKEN_FRAGMENT; }
+Geometry		{ return TOKEN_GEOMETRY; }
+Hull			{ return TOKEN_HULL; }
+Domain			{ return TOKEN_DOMAIN; }
+Compute			{ return TOKEN_COMPUTE; }
+Common			{ return TOKEN_COMMON; }
+StencilRef		{ return TOKEN_STENCILREF; }
+
+	/* Rasterizer state keywords */
+Fill			{ return TOKEN_FILLMODE; }
+Cull			{ return TOKEN_CULLMODE; }
+DepthBias		{ return TOKEN_DEPTHBIAS; }
+ScaledDepthBias	{ return TOKEN_SDEPTHBIAS; }
+DepthClip		{ return TOKEN_DEPTHCLIP; }
+Scissor			{ return TOKEN_SCISSOR; }
+Multisample		{ return TOKEN_MULTISAMPLE; }
+AALine			{ return TOKEN_AALINE; }
+
+	/* Depth-stencil state keywords */
+DepthRead			{ return TOKEN_DEPTHREAD; }
+DepthWrite			{ return TOKEN_DEPTHWRITE; }
+CompareFunc			{ return TOKEN_COMPAREFUNC; }
+Stencil				{ return TOKEN_STENCIL; }
+StencilReadMask		{ return TOKEN_STENCILREADMASK; }
+StencilWriteMask	{ return TOKEN_STENCILWRITEMASK; }
+StencilOpFront		{ return TOKEN_STENCILOPFRONT; }
+StencilOpBack		{ return TOKEN_STENCILOPBACK; }
+Fail				{ return TOKEN_FAIL; }
+ZFail				{ return TOKEN_ZFAIL; }
+
+	/* Blend state keywords */
+AlphaToCoverage		{ return TOKEN_ALPHATOCOVERAGE; }
+IndependantBlend	{ return TOKEN_INDEPENDANTBLEND; }
+Target				{ return TOKEN_TARGET; }
+Index				{ return TOKEN_INDEX; }
+Blend				{ return TOKEN_BLEND; }
+Color				{ return TOKEN_COLOR; }
+Alpha				{ return TOKEN_ALPHA; }
+WriteMask			{ return TOKEN_WRITEMASK; }
+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; }
+
+	/* State values */
+WIRE			{ yylval->intValue = FMV_Wire; return TOKEN_FILLMODEVALUE; }
+SOLID			{ yylval->intValue = FMV_Solid; return TOKEN_FILLMODEVALUE; }
+
+NOCULL			{ yylval->intValue = CMV_None; return TOKEN_CULLMODEVALUE; }
+CW				{ yylval->intValue = CMV_CW; return TOKEN_CULLMODEVALUE; }
+CCW				{ yylval->intValue = CMV_CCW; return TOKEN_CULLMODEVALUE; }
+
+FAIL			{ yylval->intValue = CFV_Fail; return TOKEN_COMPFUNCVALUE; }
+PASS			{ yylval->intValue = CFV_Pass; return TOKEN_COMPFUNCVALUE; }
+LT				{ yylval->intValue = CFV_LT; return TOKEN_COMPFUNCVALUE; }
+LTE				{ yylval->intValue = CFV_LTE; return TOKEN_COMPFUNCVALUE; }
+EQ				{ yylval->intValue = CFV_EQ; return TOKEN_COMPFUNCVALUE; }
+NEQ				{ yylval->intValue = CFV_NEQ; return TOKEN_COMPFUNCVALUE; }
+GTE				{ yylval->intValue = CFV_GTE; return TOKEN_COMPFUNCVALUE; }
+GT				{ yylval->intValue = CFV_GT; return TOKEN_COMPFUNCVALUE; }
+
+KEEP				{ yylval->intValue = OV_Keep; return TOKEN_OPVALUE; }
+ZERO				{ yylval->intValue = OV_Zero; return TOKEN_OPVALUE; }
+REPLACE				{ yylval->intValue = OV_Replace; return TOKEN_OPVALUE; }
+INC					{ yylval->intValue = OV_Incr; return TOKEN_OPVALUE; }
+DEC					{ yylval->intValue = OV_Decr; return TOKEN_OPVALUE; }
+INCWRAP				{ yylval->intValue = OV_IncrWrap; return TOKEN_OPVALUE; }
+DECWRAP				{ yylval->intValue = OV_DecrWrap; return TOKEN_OPVALUE; }
+INV					{ yylval->intValue = OV_Invert; return TOKEN_OPVALUE; }
+ONE					{ yylval->intValue = OV_One; return TOKEN_OPVALUE; }
+DSTRGB				{ yylval->intValue = OV_DestColor; return TOKEN_OPVALUE; }
+SRCRGB				{ yylval->intValue = OV_SrcColor; return TOKEN_OPVALUE; }
+DSTIRGB				{ yylval->intValue = OV_InvDestColor; return TOKEN_OPVALUE; }
+SRCIRGB				{ yylval->intValue = OV_InvSrcColor; return TOKEN_OPVALUE; }
+DSTA				{ yylval->intValue = OV_DestAlpha; return TOKEN_OPVALUE; }
+SRCA				{ yylval->intValue = OV_SrcAlpha; return TOKEN_OPVALUE; }
+DSTIA				{ yylval->intValue = OV_InvDestAlpha; return TOKEN_OPVALUE; }
+SRCIA				{ yylval->intValue = OV_InvSrcAlpha; return TOKEN_OPVALUE; }
+
+ADD					{ yylval->intValue = BOV_Add; return TOKEN_BLENDOPVALUE; }
+SUB					{ yylval->intValue = BOV_Subtract; return TOKEN_BLENDOPVALUE; }
+RSUB				{ yylval->intValue = BOV_RevSubtract; return TOKEN_BLENDOPVALUE; }
+MIN					{ yylval->intValue = BOV_Min; return TOKEN_BLENDOPVALUE; }
+MAX					{ yylval->intValue = BOV_Max; return TOKEN_BLENDOPVALUE; }
+
+NOCOLOR			{ yylval->intValue = 0x0; return TOKEN_COLORMASK; }
+R				{ yylval->intValue = 0x1; return TOKEN_COLORMASK; }
+G				{ yylval->intValue = 0x2; return TOKEN_COLORMASK; }
+B				{ yylval->intValue = 0x4; return TOKEN_COLORMASK; }
+A				{ yylval->intValue = 0x8; return TOKEN_COLORMASK; }
+RG				{ yylval->intValue = 0x3; return TOKEN_COLORMASK; }
+RB				{ yylval->intValue = 0x5; return TOKEN_COLORMASK; }
+RA				{ yylval->intValue = 0x9; return TOKEN_COLORMASK; }
+GB				{ yylval->intValue = 0x6; return TOKEN_COLORMASK; }
+GA				{ yylval->intValue = 0xA; return TOKEN_COLORMASK; }
+BA				{ yylval->intValue = 0xC; return TOKEN_COLORMASK; }
+RGB				{ yylval->intValue = 0x7; return TOKEN_COLORMASK; }
+RGA				{ yylval->intValue = 0xB; return TOKEN_COLORMASK; }
+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; }
+
+{COMMENT}		{ }
+{IDENTIFIER}	{ yylval->strValue = mmalloc_strdup(yyextra->memContext, yytext); return TOKEN_IDENTIFIER; }
+.				{ return yytext[0]; }

BansheeSL/BsParserFX.h

@@ -95,98 +95,102 @@ extern int yydebug;
      TOKEN_FLOAT2TYPE = 273,
      TOKEN_FLOAT3TYPE = 274,
      TOKEN_FLOAT4TYPE = 275,
-     TOKEN_COLORTYPE = 276,
-     TOKEN_MAT2x2TYPE = 277,
-     TOKEN_MAT2x3TYPE = 278,
-     TOKEN_MAT2x4TYPE = 279,
-     TOKEN_MAT3x2TYPE = 280,
-     TOKEN_MAT3x3TYPE = 281,
-     TOKEN_MAT3x4TYPE = 282,
-     TOKEN_MAT4x2TYPE = 283,
-     TOKEN_MAT4x3TYPE = 284,
-     TOKEN_MAT4x4TYPE = 285,
-     TOKEN_SAMPLER1D = 286,
-     TOKEN_SAMPLER2D = 287,
-     TOKEN_SAMPLER3D = 288,
-     TOKEN_SAMPLERCUBE = 289,
-     TOKEN_SAMPLER2DMS = 290,
-     TOKEN_TEXTURE1D = 291,
-     TOKEN_TEXTURE2D = 292,
-     TOKEN_TEXTURE3D = 293,
-     TOKEN_TEXTURECUBE = 294,
-     TOKEN_TEXTURE2DMS = 295,
-     TOKEN_BYTEBUFFER = 296,
-     TOKEN_STRUCTBUFFER = 297,
-     TOKEN_RWTYPEDBUFFER = 298,
-     TOKEN_RWBYTEBUFFER = 299,
-     TOKEN_RWSTRUCTBUFFER = 300,
-     TOKEN_RWAPPENDBUFFER = 301,
-     TOKEN_RWCONSUMEBUFFER = 302,
-     TOKEN_PARAMSBLOCK = 303,
-     TOKEN_AUTO = 304,
-     TOKEN_ALIAS = 305,
-     TOKEN_SHARED = 306,
-     TOKEN_USAGE = 307,
-     TOKEN_SEPARABLE = 308,
-     TOKEN_QUEUE = 309,
-     TOKEN_PRIORITY = 310,
-     TOKEN_TRANSPARENT = 311,
-     TOKEN_PARAMETERS = 312,
-     TOKEN_BLOCKS = 313,
-     TOKEN_TECHNIQUE = 314,
-     TOKEN_RENDERER = 315,
-     TOKEN_LANGUAGE = 316,
-     TOKEN_INCLUDE = 317,
-     TOKEN_PASS = 318,
-     TOKEN_VERTEX = 319,
-     TOKEN_FRAGMENT = 320,
-     TOKEN_GEOMETRY = 321,
-     TOKEN_HULL = 322,
-     TOKEN_DOMAIN = 323,
-     TOKEN_COMPUTE = 324,
-     TOKEN_COMMON = 325,
-     TOKEN_STENCILREF = 326,
-     TOKEN_FILLMODE = 327,
-     TOKEN_CULLMODE = 328,
-     TOKEN_DEPTHBIAS = 329,
-     TOKEN_SDEPTHBIAS = 330,
-     TOKEN_DEPTHCLIP = 331,
-     TOKEN_SCISSOR = 332,
-     TOKEN_MULTISAMPLE = 333,
-     TOKEN_AALINE = 334,
-     TOKEN_DEPTHREAD = 335,
-     TOKEN_DEPTHWRITE = 336,
-     TOKEN_COMPAREFUNC = 337,
-     TOKEN_STENCIL = 338,
-     TOKEN_STENCILREADMASK = 339,
-     TOKEN_STENCILWRITEMASK = 340,
-     TOKEN_STENCILOPFRONT = 341,
-     TOKEN_STENCILOPBACK = 342,
-     TOKEN_FAIL = 343,
-     TOKEN_ZFAIL = 344,
-     TOKEN_ALPHATOCOVERAGE = 345,
-     TOKEN_INDEPENDANTBLEND = 346,
-     TOKEN_TARGET = 347,
-     TOKEN_INDEX = 348,
-     TOKEN_BLEND = 349,
-     TOKEN_COLOR = 350,
-     TOKEN_ALPHA = 351,
-     TOKEN_WRITEMASK = 352,
-     TOKEN_SOURCE = 353,
-     TOKEN_DEST = 354,
-     TOKEN_OP = 355,
-     TOKEN_ADDRMODE = 356,
-     TOKEN_MINFILTER = 357,
-     TOKEN_MAGFILTER = 358,
-     TOKEN_MIPFILTER = 359,
-     TOKEN_MAXANISO = 360,
-     TOKEN_MIPBIAS = 361,
-     TOKEN_MIPMIN = 362,
-     TOKEN_MIPMAX = 363,
-     TOKEN_BORDERCOLOR = 364,
-     TOKEN_U = 365,
-     TOKEN_V = 366,
-     TOKEN_W = 367
+     TOKEN_INTTYPE = 276,
+     TOKEN_INT2TYPE = 277,
+     TOKEN_INT3TYPE = 278,
+     TOKEN_INT4TYPE = 279,
+     TOKEN_COLORTYPE = 280,
+     TOKEN_MAT2x2TYPE = 281,
+     TOKEN_MAT2x3TYPE = 282,
+     TOKEN_MAT2x4TYPE = 283,
+     TOKEN_MAT3x2TYPE = 284,
+     TOKEN_MAT3x3TYPE = 285,
+     TOKEN_MAT3x4TYPE = 286,
+     TOKEN_MAT4x2TYPE = 287,
+     TOKEN_MAT4x3TYPE = 288,
+     TOKEN_MAT4x4TYPE = 289,
+     TOKEN_SAMPLER1D = 290,
+     TOKEN_SAMPLER2D = 291,
+     TOKEN_SAMPLER3D = 292,
+     TOKEN_SAMPLERCUBE = 293,
+     TOKEN_SAMPLER2DMS = 294,
+     TOKEN_TEXTURE1D = 295,
+     TOKEN_TEXTURE2D = 296,
+     TOKEN_TEXTURE3D = 297,
+     TOKEN_TEXTURECUBE = 298,
+     TOKEN_TEXTURE2DMS = 299,
+     TOKEN_BYTEBUFFER = 300,
+     TOKEN_STRUCTBUFFER = 301,
+     TOKEN_RWTYPEDBUFFER = 302,
+     TOKEN_RWBYTEBUFFER = 303,
+     TOKEN_RWSTRUCTBUFFER = 304,
+     TOKEN_RWAPPENDBUFFER = 305,
+     TOKEN_RWCONSUMEBUFFER = 306,
+     TOKEN_PARAMSBLOCK = 307,
+     TOKEN_AUTO = 308,
+     TOKEN_ALIAS = 309,
+     TOKEN_SHARED = 310,
+     TOKEN_USAGE = 311,
+     TOKEN_SEPARABLE = 312,
+     TOKEN_QUEUE = 313,
+     TOKEN_PRIORITY = 314,
+     TOKEN_TRANSPARENT = 315,
+     TOKEN_PARAMETERS = 316,
+     TOKEN_BLOCKS = 317,
+     TOKEN_TECHNIQUE = 318,
+     TOKEN_RENDERER = 319,
+     TOKEN_LANGUAGE = 320,
+     TOKEN_INCLUDE = 321,
+     TOKEN_PASS = 322,
+     TOKEN_VERTEX = 323,
+     TOKEN_FRAGMENT = 324,
+     TOKEN_GEOMETRY = 325,
+     TOKEN_HULL = 326,
+     TOKEN_DOMAIN = 327,
+     TOKEN_COMPUTE = 328,
+     TOKEN_COMMON = 329,
+     TOKEN_STENCILREF = 330,
+     TOKEN_FILLMODE = 331,
+     TOKEN_CULLMODE = 332,
+     TOKEN_DEPTHBIAS = 333,
+     TOKEN_SDEPTHBIAS = 334,
+     TOKEN_DEPTHCLIP = 335,
+     TOKEN_SCISSOR = 336,
+     TOKEN_MULTISAMPLE = 337,
+     TOKEN_AALINE = 338,
+     TOKEN_DEPTHREAD = 339,
+     TOKEN_DEPTHWRITE = 340,
+     TOKEN_COMPAREFUNC = 341,
+     TOKEN_STENCIL = 342,
+     TOKEN_STENCILREADMASK = 343,
+     TOKEN_STENCILWRITEMASK = 344,
+     TOKEN_STENCILOPFRONT = 345,
+     TOKEN_STENCILOPBACK = 346,
+     TOKEN_FAIL = 347,
+     TOKEN_ZFAIL = 348,
+     TOKEN_ALPHATOCOVERAGE = 349,
+     TOKEN_INDEPENDANTBLEND = 350,
+     TOKEN_TARGET = 351,
+     TOKEN_INDEX = 352,
+     TOKEN_BLEND = 353,
+     TOKEN_COLOR = 354,
+     TOKEN_ALPHA = 355,
+     TOKEN_WRITEMASK = 356,
+     TOKEN_SOURCE = 357,
+     TOKEN_DEST = 358,
+     TOKEN_OP = 359,
+     TOKEN_ADDRMODE = 360,
+     TOKEN_MINFILTER = 361,
+     TOKEN_MAGFILTER = 362,
+     TOKEN_MIPFILTER = 363,
+     TOKEN_MAXANISO = 364,
+     TOKEN_MIPBIAS = 365,
+     TOKEN_MIPMIN = 366,
+     TOKEN_MIPMAX = 367,
+     TOKEN_BORDERCOLOR = 368,
+     TOKEN_U = 369,
+     TOKEN_V = 370,
+     TOKEN_W = 371
    };
 #endif
 
@@ -199,13 +203,14 @@ typedef union YYSTYPE
 	int intValue;
 	float floatValue;
 	float matrixValue[16];
+	int intVectorValue[4];
 	const char* strValue;
 	ASTFXNode* nodePtr;
 	NodeOption nodeOption;
 
 
 /* Line 2579 of glr.c  */
-#line 209 "BsParserFX.h"
+#line 214 "BsParserFX.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */

BansheeSL/BsParserFX.y

@@ -46,6 +46,7 @@ void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const cha
 	int intValue;
 	float floatValue;
 	float matrixValue[16];
+	int intVectorValue[4];
 	const char* strValue;
 	ASTFXNode* nodePtr;
 	NodeOption nodeOption;
@@ -72,6 +73,10 @@ void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const cha
 %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 
@@ -188,6 +193,9 @@ void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const cha
 %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;
@@ -198,6 +206,10 @@ void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const cha
 %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
@@ -217,6 +229,10 @@ void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const cha
 %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
@@ -573,6 +589,18 @@ 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 '}'	
@@ -651,6 +679,10 @@ parameter
 	| 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; }
@@ -694,6 +726,22 @@ 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); }
 	;
@@ -788,6 +836,26 @@ param_body_float4
 	| '=' 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)); }

BansheeSL/Include/BsASTFX.h

@@ -124,7 +124,8 @@ enum tagOptionDataType
 
 enum tagParamType
 {
-	PT_Float, PT_Float2, PT_Float3, PT_Float4, PT_Color,
+	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,
@@ -213,6 +214,7 @@ union tagOptionData
 	float floatValue;
 	const char* strValue;
 	float matrixValue[16];
+	int intVectorValue[4];
 	ASTFXNode* nodePtr;
 };
 

BansheeSL/Source/BsSLFXCompiler.cpp

@@ -736,6 +736,11 @@ namespace BansheeEngine
 			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_Mat2x2] = { { GPDT_MATRIX_2X2 }, false };
 			lookup[PT_Mat2x3] = { { GPDT_MATRIX_2X3 }, false };
 			lookup[PT_Mat2x4] = { { GPDT_MATRIX_2X4 }, false };

RenderBeast/Source/BsRenderBeast.cpp

@@ -609,7 +609,7 @@ namespace BansheeEngine
 
 				// TODO - Bind parameters to the pipeline manually as I don't need to re-bind gbuffer textures for every light
 				setPassParams(dirMaterial->getPassParameters(0), nullptr);
-				gRendererUtility().drawScreenQuad(*viewport);
+				gRendererUtility().drawScreenQuad();
 			}
 
 			SPtr<MaterialCore> pointMaterial = mPointLightMat->getMaterial();

RenderBeast/Source/BsRenderTargets.cpp

@@ -3,6 +3,7 @@
 #include "BsViewport.h"
 #include "BsRenderAPI.h"
 #include "BsTextureManager.h"
+#include "BsRendererUtility.h"
 
 namespace BansheeEngine
 {
@@ -185,7 +186,8 @@ namespace BansheeEngine
 					mViewport->getClearDepthValue(), mViewport->getClearStencilValue());
 			}
 
-			// TODO - Copy from internal scene color to final scene color
+			// TODO - Merge this blit into some post-processing shader, no reason for it to be on its own
+			gRendererUtility().blit(mSceneColorTex->texture);
 		}
 	}