Fixed shader parameter checking

GpuParamBlocks now make use of their "usage" flag

CamelotClient/CamelotClient.cpp

@@ -27,8 +27,8 @@ using namespace CamelotEngine;
 int _tmain(int argc, _TCHAR* argv[])
 {
 	//gApplication().startUp("CamelotGLRenderSystem", "CamelotForwardRenderer");
-	//gApplication().startUp("CamelotD3D9RenderSystem", "CamelotForwardRenderer");
-	gApplication().startUp("CamelotD3D11RenderSystem", "CamelotForwardRenderer");
+	gApplication().startUp("CamelotD3D9RenderSystem", "CamelotForwardRenderer");
+	//gApplication().startUp("CamelotD3D11RenderSystem", "CamelotForwardRenderer");
 
 	RenderSystem* renderSystem = RenderSystem::instancePtr();
 	RenderWindowPtr renderWindow = gApplication().getPrimaryRenderWindow();
@@ -51,51 +51,51 @@ int _tmain(int argc, _TCHAR* argv[])
 	HighLevelGpuProgramPtr vertProg;
 
 	/////////////////// HLSL 9 SHADERS //////////////////////////
-	//String fragShaderCode = "sampler2D tex;			\
-	//						float4 ps_main(float2 uv : TEXCOORD0) : COLOR0		\
-	//						{														\
-	//						float4 color = tex2D(tex, uv);				\
-	//						return color;										\
-	//						}";
-
-	//fragProg =  HighLevelGpuProgram::create(fragShaderCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_2_0);
-
-	//String vertShaderCode = "float4x4 matViewProjection;	\
-	//						void vs_main(										\
-	//						float4 inPos : POSITION,							\
-	//						float2 uv : TEXCOORD0,								\
-	//						out float4 oPosition : POSITION,					\
-	//						out float2 oUv : TEXCOORD0)							\
-	//						{														\
-	//						oPosition = mul(matViewProjection, inPos);			\
-	//						oUv = uv;											\
-	//						}";
-
-	//vertProg =  HighLevelGpuProgram::create(vertShaderCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
-
-	/////////////////// HLSL 11 SHADERS //////////////////////////
-	String fragShaderCode = "SamplerState samp : register(s0);			\
-							Texture2D tex : register(t0); \
-							float4 ps_main(in float4 inPos : SV_Position, float2 uv : TEXCOORD0) : SV_Target		\
+	String fragShaderCode = "sampler2D tex;			\
+							float4 ps_main(float2 uv : TEXCOORD0) : COLOR0		\
 							{														\
-							float4 color = tex.Sample(samp, uv);				\
+							float4 color = tex2D(tex, uv);				\
 							return color;										\
 							}";
 
-	fragProg =  HighLevelGpuProgram::create(fragShaderCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_4_0);
+	fragProg =  HighLevelGpuProgram::create(fragShaderCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_2_0);
 
 	String vertShaderCode = "float4x4 matViewProjection;	\
 							void vs_main(										\
-							in float4 inPos : POSITION,							\
-							in float2 uv : TEXCOORD0,								\
-							out float4 oPosition : SV_Position,					\
+							float4 inPos : POSITION,							\
+							float2 uv : TEXCOORD0,								\
+							out float4 oPosition : POSITION,					\
 							out float2 oUv : TEXCOORD0)							\
 							{														\
 							oPosition = mul(matViewProjection, inPos);			\
 							oUv = uv;											\
 							}";
 
-	vertProg =  HighLevelGpuProgram::create(vertShaderCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
+	vertProg =  HighLevelGpuProgram::create(vertShaderCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
+
+	/////////////////// HLSL 11 SHADERS //////////////////////////
+	//String fragShaderCode = "SamplerState samp : register(s0);			\
+	//						Texture2D tex : register(t0); \
+	//						float4 ps_main(in float4 inPos : SV_Position, float2 uv : TEXCOORD0) : SV_Target		\
+	//						{														\
+	//						float4 color = tex.Sample(samp, uv);				\
+	//						return color;										\
+	//						}";
+
+	//fragProg =  HighLevelGpuProgram::create(fragShaderCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_4_0);
+
+	//String vertShaderCode = "float4x4 matViewProjection;	\
+	//						void vs_main(										\
+	//						in float4 inPos : POSITION,							\
+	//						in float2 uv : TEXCOORD0,								\
+	//						out float4 oPosition : SV_Position,					\
+	//						out float2 oUv : TEXCOORD0)							\
+	//						{														\
+	//						oPosition = mul(matViewProjection, inPos);			\
+	//						oUv = uv;											\
+	//						}";
+
+	//vertProg =  HighLevelGpuProgram::create(vertShaderCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
 
 	/////////////////// CG SHADERS //////////////////////////
 	//String fragShaderCode = "sampler2D tex;					\

CamelotD3D11RenderSystem/Source/CmD3D11GpuParamBlock.cpp

@@ -27,7 +27,12 @@ namespace CamelotEngine
 			D3D11RenderSystem* d3d11rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
 			D3D11Device& device = d3d11rs->getPrimaryDevice();
 
-			mD3D11SharedData->mBuffer = new D3D11HardwareBuffer(D3D11HardwareBuffer::BT_CONSTANT, GBU_STATIC, 1, mSize, device);
+			if(mUsage == GPBU_STATIC)
+				mD3D11SharedData->mBuffer = new D3D11HardwareBuffer(D3D11HardwareBuffer::BT_CONSTANT, GBU_STATIC, 1, mSize, device);
+			else if(mUsage == GPBU_DYNAMIC)
+				mD3D11SharedData->mBuffer = new D3D11HardwareBuffer(D3D11HardwareBuffer::BT_CONSTANT, GBU_DYNAMIC, 1, mSize, device);
+			else
+				CM_EXCEPT(InternalErrorException, "Invalid gpu param block usage.");
 
 			sharedData->mInitialized = true;
 		}

CamelotGLRenderer/Source/CmGLGpuParamBlock.cpp

@@ -1,4 +1,5 @@
 #include "CmGLGpuParamBlock.h"
+#include "CmException.h"
 
 namespace CamelotEngine
 {
@@ -23,7 +24,13 @@ namespace CamelotEngine
 		{
 			glGenBuffers(1, &mGLSharedData->mGLHandle);
 			glBindBuffer(GL_UNIFORM_BUFFER, mGLSharedData->mGLHandle);
-			glBufferData(GL_UNIFORM_BUFFER, mSize, (GLvoid*)mData, GL_DYNAMIC_DRAW);
+			if(mUsage == GPBU_STATIC)
+				glBufferData(GL_UNIFORM_BUFFER, mSize, (GLvoid*)mData, GL_STATIC_DRAW);
+			else if(mUsage == GPBU_DYNAMIC)
+				glBufferData(GL_UNIFORM_BUFFER, mSize, (GLvoid*)mData, GL_DYNAMIC_DRAW);
+			else
+				CM_EXCEPT(InternalErrorException, "Invalid gpu param block usage.");
+
 			glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
 			sharedData->mInitialized = true;

CamelotRenderer/Include/CmGpuParamBlock.h

@@ -31,6 +31,7 @@ namespace CamelotEngine
 		static GpuParamBlockPtr create(const GpuParamBlockDesc& desc);
 	protected:
 		GpuParamBlockSharedData* sharedData;
+		GpuParamBlockUsage mUsage;
 		bool mOwnsSharedData;
 		UINT8* mData;
 		UINT32 mSize;

CamelotRenderer/Source/CmGpuParamBlock.cpp

@@ -6,7 +6,7 @@
 namespace CamelotEngine
 {
 	GpuParamBlock::GpuParamBlock(const GpuParamBlockDesc& desc, GpuParamBlockUsage usage)
-		:mSize(desc.blockSize * sizeof(UINT32)), mOwnsSharedData(true)
+		:mSize(desc.blockSize * sizeof(UINT32)), mOwnsSharedData(true), mUsage(usage)
 	{
 		mData = new UINT8[mSize];
 		memset(mData, 0, mSize);

CamelotRenderer/Source/CmMaterial.cpp

@@ -243,7 +243,7 @@ namespace CamelotEngine
 		map<String, const GpuParamDataDesc*>::type foundDataParams;
 		map<String, const GpuParamObjectDesc*>::type foundObjectParams;
 
-		set<String>::type validParameters;
+		map<String, bool>::type validParameters;
 
 		for(auto iter = paramDescs.begin(); iter != paramDescs.end(); ++iter)
 		{
@@ -263,7 +263,10 @@ namespace CamelotEngine
 				{
 					auto dataFindIter = foundDataParams.find(iter2->first);
 					if(dataFindIter == foundDataParams.end())
-						validParameters.insert(iter2->first);
+					{
+						validParameters[iter2->first] = true;
+						foundDataParams[iter2->first] = &curParam;
+					}
 					else
 					{
 						const GpuParamDataDesc* otherParam = dataFindIter->second;
@@ -273,7 +276,12 @@ namespace CamelotEngine
 				}
 
 				if(!isParameterValid)
-					validParameters.erase(iter2->first);
+				{
+					if(validParameters[iter2->first]) // Do this check so we only report this error once
+						LOGWRN("Found two parameters with the same name but different contents: " + iter2->first);
+
+					validParameters[iter2->first] = false;
+				}
 			}
 
 			// Check sampler params
@@ -290,7 +298,10 @@ namespace CamelotEngine
 				{
 					auto objectFindIter = foundObjectParams.find(iter2->first);
 					if(objectFindIter == foundObjectParams.end())
-						validParameters.insert(iter2->first);
+					{
+						validParameters[iter2->first] = true;
+						foundObjectParams[iter2->first] = &curParam;
+					}
 					else
 					{
 						const GpuParamObjectDesc* otherParam = objectFindIter->second;
@@ -300,7 +311,12 @@ namespace CamelotEngine
 				}
 
 				if(!isParameterValid)
-					validParameters.erase(iter2->first);
+				{
+					if(validParameters[iter2->first]) // Do this check so we only report this error once
+						LOGWRN("Found two parameters with the same name but different contents: " + iter2->first);
+
+					validParameters[iter2->first] = false;
+				}
 			}
 
 			// Check texture params
@@ -317,7 +333,10 @@ namespace CamelotEngine
 				{
 					auto objectFindIter = foundObjectParams.find(iter2->first);
 					if(objectFindIter == foundObjectParams.end())
-						validParameters.insert(iter2->first);
+					{
+						validParameters[iter2->first] = true;
+						foundObjectParams[iter2->first] = &curParam;
+					}
 					else
 					{
 						const GpuParamObjectDesc* otherParam = objectFindIter->second;
@@ -327,7 +346,12 @@ namespace CamelotEngine
 				}
 
 				if(!isParameterValid)
-					validParameters.erase(iter2->first);
+				{
+					if(validParameters[iter2->first]) // Do this check so we only report this error once
+						LOGWRN("Found two parameters with the same name but different contents: " + iter2->first);
+
+					validParameters[iter2->first] = false;
+				}
 			}
 
 			// Check buffer params
@@ -344,7 +368,10 @@ namespace CamelotEngine
 				{
 					auto objectFindIter = foundObjectParams.find(iter2->first);
 					if(objectFindIter == foundObjectParams.end())
-						validParameters.insert(iter2->first);
+					{
+						validParameters[iter2->first] = true;
+						foundObjectParams[iter2->first] = &curParam;
+					}
 					else
 					{
 						const GpuParamObjectDesc* otherParam = objectFindIter->second;
@@ -355,25 +382,29 @@ namespace CamelotEngine
 
 				if(!isParameterValid)
 				{
-					auto validParamIter = validParameters.find(iter2->first);
-
-					if(validParamIter != validParameters.end()) // Do this check so we only report this error once
-					{
+					if(validParameters[iter2->first]) // Do this check so we only report this error once
 						LOGWRN("Found two parameters with the same name but different contents: " + iter2->first);
-						validParameters.erase(validParamIter);
-					}
+
+					validParameters[iter2->first] = false;
 				}
 			}
 		}
 
-		return validParameters;
+		set<String>::type validParamsReturn;
+		for(auto iter = validParameters.begin(); iter != validParameters.end(); ++iter)
+		{
+			if(iter->second)
+				validParamsReturn.insert(iter->first);
+		}
+
+		return validParamsReturn;
 	}
 
 	set<String>::type Material::determineValidShareableParamBlocks(const vector<const GpuParamDesc*>::type& paramDescs) const
 	{
 		// Make sure param blocks with the same name actually are the same
 		map<String, std::pair<String, const GpuParamDesc*>>::type uniqueParamBlocks;
-		set<String>::type validParamBlocks;
+		map<String, bool>::type validParamBlocks;
 
 		for(auto iter = paramDescs.begin(); iter != paramDescs.end(); ++iter)
 		{
@@ -390,7 +421,7 @@ namespace CamelotEngine
 				if(iterFind == uniqueParamBlocks.end())
 				{
 					uniqueParamBlocks[blockIter->first] = std::make_pair(blockIter->first, *iter);
-					validParamBlocks.insert(blockIter->first);
+					validParamBlocks[blockIter->first] = true;
 					continue;
 				}
 
@@ -424,18 +455,23 @@ namespace CamelotEngine
 
 				if(!isBlockValid)
 				{
-					auto blockValidIter = validParamBlocks.find(blockIter->first);
-
-					if(blockValidIter != validParamBlocks.end()) // Do this check so we only report this error once
+					if(validParamBlocks[blockIter->first])
 					{
 						LOGWRN("Found two param blocks with the same name but different contents: " + blockIter->first);
-						validParamBlocks.erase(blockValidIter);
+						validParamBlocks[blockIter->first] = false;
 					}
 				}
 			}
 		}
 
-		return validParamBlocks;
+		set<String>::type validParamBlocksReturn;
+		for(auto iter = validParamBlocks.begin(); iter != validParamBlocks.end(); ++iter)
+		{
+			if(iter->second)
+				validParamBlocksReturn.insert(iter->first);
+		}
+
+		return validParamBlocksReturn;
 	}
 
 	map<String, String>::type Material::determineParameterToBlockMapping(const vector<const GpuParamDesc*>::type& paramDescs)

CamelotRenderer/TODO.txt

@@ -50,10 +50,7 @@ Stuff that needs destroy():
   - Shader
   - Technique
 
-GpuParamBlock usage is provided in the constructor but isn't used anywhere
 DX9 will have the same name for sampler and texture. This will cause an error in Material param checking.
-DX9 might have problems with checking if buffers are equal. Probably need to ignore "Global" param block
-
 
 Add support for include file resource
 Make sure we can add an include file to a HighLevelGpuProgram, and make sure it uses it