Material serialization (untested)

Added /bigopt options to the compiler as it was complaining

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;					\

CamelotClient/CamelotClient.vcxproj

@@ -94,6 +94,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\CamelotRenderer\Include;..\CamelotD3D9Renderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -110,6 +111,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\CamelotRenderer\Include;..\CamelotD3D9Renderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -128,6 +130,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\CamelotRenderer\Include;..\CamelotD3D9Renderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -148,6 +151,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\CamelotRenderer\Include;..\CamelotD3D9Renderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj

@@ -87,6 +87,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -101,6 +102,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -117,6 +119,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -135,6 +138,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -440,12 +440,12 @@ namespace CamelotEngine
 
 		for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)
 		{
-			SamplerStatePtr samplerState = params->getSamplerState(iter->second.slot);
+			SamplerStateHandle& samplerState = params->getSamplerState(iter->second.slot);
 
 			if(samplerState == nullptr)
 				setSamplerState(gptype, iter->second.slot, SamplerState::getDefault());
 			else
-				setSamplerState(gptype, iter->second.slot, samplerState);
+				setSamplerState(gptype, iter->second.slot, samplerState.getInternalPtr());
 		}
 
 		for(auto iter = paramDesc.textures.begin(); iter != paramDesc.textures.end(); ++iter)

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj

@@ -88,6 +88,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D9_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -102,6 +103,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D9_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -118,6 +120,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D9_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -136,6 +139,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D9_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -333,12 +333,12 @@ namespace CamelotEngine
 
 		for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)
 		{
-			SamplerStatePtr samplerState = params->getSamplerState(iter->second.slot);
+			SamplerStateHandle& samplerState = params->getSamplerState(iter->second.slot);
 
 			if(samplerState == nullptr)
 				setSamplerState(gptype, iter->second.slot, SamplerState::getDefault());
 			else
-				setSamplerState(gptype, iter->second.slot, samplerState);
+				setSamplerState(gptype, iter->second.slot, samplerState.getInternalPtr());
 		}
 
 		for(auto iter = paramDesc.textures.begin(); iter != paramDesc.textures.end(); ++iter)

CamelotFBXImporter/CamelotFBXImporter.vcxproj

@@ -87,6 +87,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FBX_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -101,6 +102,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FBX_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -117,6 +119,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FBX_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -135,6 +138,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FBX_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

CamelotForwardRenderer/CamelotForwardRenderer.vcxproj

@@ -87,6 +87,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FWDRND_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -101,6 +102,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FWDRND_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -117,6 +119,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FWDRND_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -135,6 +138,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_FWDRND_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

CamelotFreeImgImporter/CamelotFreeImgImporter.vcxproj

@@ -97,6 +97,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>CM_FREEIMG_EXPORTS;_MBCS;FREEIMAGE_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;./Dependencies/Include;../Dependencies/Include</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -111,6 +112,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>CM_FREEIMG_EXPORTS;_MBCS;FREEIMAGE_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;./Dependencies/Include;../Dependencies/Include</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -127,6 +129,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>CM_FREEIMG_EXPORTS;_MBCS;FREEIMAGE_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;./Dependencies/Include;../Dependencies/Include</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -145,6 +148,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>CM_FREEIMG_EXPORTS;_MBCS;FREEIMAGE_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;./Dependencies/Include;../Dependencies/Include</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

CamelotGLRenderer/CamelotGLRenderer.vcxproj

@@ -88,6 +88,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>./Source/win32;./Source/GLSL/include;./Source/atifs/include;../CamelotUtility/Include;../CamelotRenderer/Include;./Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;CM_RSGL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -102,6 +103,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>./Source/win32;./Source/GLSL/include;./Source/atifs/include;../CamelotUtility/Include;../CamelotRenderer/Include;./Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;CM_RSGL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -118,6 +120,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>./Source/win32;./Source/GLSL/include;./Source/atifs/include;../CamelotUtility/Include;../CamelotRenderer/Include;./Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;CM_RSGL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -136,6 +139,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>./Source/win32;./Source/GLSL/include;./Source/atifs/include;../CamelotUtility/Include;../CamelotRenderer/Include;./Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;CM_RSGL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -323,12 +323,12 @@ namespace CamelotEngine
 		UINT32 texUnit = 0;
 		for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)
 		{
-			SamplerStatePtr samplerState = params->getSamplerState(iter->second.slot);
+			SamplerStateHandle& samplerState = params->getSamplerState(iter->second.slot);
 
 			if(samplerState == nullptr)
 				setSamplerState(gptype, iter->second.slot, SamplerState::getDefault());
 			else
-				setSamplerState(gptype, iter->second.slot, samplerState);
+				setSamplerState(gptype, iter->second.slot, samplerState.getInternalPtr());
 
 			glProgramUniform1i(glProgram, iter->second.slot, getGLTextureUnit(gptype, texUnit));
 

CamelotOISInput/CamelotOISInput.vcxproj

@@ -87,6 +87,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_OIS_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -101,6 +102,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_OIS_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -117,6 +119,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_OIS_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -135,6 +138,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>../CamelotRenderer/Include;../CamelotUtility/Include;./Include;../Dependencies/Include;./Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_OIS_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>

CamelotRenderer/CamelotRenderer.vcxproj

@@ -102,6 +102,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;CM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>./Include;../CamelotUtility/Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>NotSet</SubSystem>
@@ -119,6 +120,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;CM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>./Include;../CamelotUtility/Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>NotSet</SubSystem>
@@ -138,6 +140,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;CM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>./Include;../CamelotUtility/Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>NotSet</SubSystem>
@@ -159,6 +162,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;CM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>./Include;../CamelotUtility/Include;../Dependencies/Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>NotSet</SubSystem>

CamelotRenderer/Include/CmCommonEnums.h

@@ -262,6 +262,12 @@ namespace CamelotEngine {
 		GPBU_DYNAMIC
 	};
 
+	enum GpuParamType
+	{
+		GPT_DATA,
+		GPT_OBJECT
+	};
+
 	enum GpuParamDataType
 	{
 		GPDT_FLOAT1 = 1,

CamelotRenderer/Include/CmGpuParams.h

@@ -43,11 +43,11 @@ namespace CamelotEngine
 		 */
 		void setParam(const String& name, const void* value, UINT32 sizeBytes, UINT32 arrayIndex = 0);
 
-		void setTexture(const String& name, TextureHandle val);
+		void setTexture(const String& name, TextureHandle& val);
 		TextureHandle getTexture(UINT32 slot);
 
-		void setSamplerState(const String& name, SamplerStatePtr val);
-		SamplerStatePtr getSamplerState(UINT32 slot);
+		void setSamplerState(const String& name, SamplerStateHandle& val);
+		SamplerStateHandle getSamplerState(UINT32 slot);
 
 		void setTransposeMatrices(bool transpose) { mTransposeMatrices = transpose; }
 
@@ -62,6 +62,6 @@ namespace CamelotEngine
 
 		vector<GpuParamBlockPtr>::type mParamBlocks;
 		vector<TextureHandle>::type mTextures;
-		vector<SamplerStatePtr>::type mSamplerStates;
+		vector<SamplerStateHandle>::type mSamplerStates;
 	};
 }

CamelotRenderer/Include/CmMaterial.h

@@ -51,14 +51,14 @@ namespace CamelotEngine
 		ShaderPtr getShader() const { return mShader; }
 
 		void setTexture(const String& name, TextureHandle& value);
-		void setSamplerState(const String& name, SamplerStatePtr samplerState);
-		void setFloat(const String& name, float value);
-		void setColor(const String& name, const Color& value);
-		void setVec2(const String& name, const Vector2& value);
-		void setVec3(const String& name, const Vector3& value);
-		void setVec4(const String& name, const Vector4& value);
-		void setMat3(const String& name, const Matrix3& value);
-		void setMat4(const String& name, const Matrix4& value);
+		void setSamplerState(const String& name, SamplerStateHandle& samplerState);
+		void setFloat(const String& name, float value, UINT32 arrayIdx = 0);
+		void setColor(const String& name, const Color& value, UINT32 arrayIdx = 0);
+		void setVec2(const String& name, const Vector2& value, UINT32 arrayIdx = 0);
+		void setVec3(const String& name, const Vector3& value, UINT32 arrayIdx = 0);
+		void setVec4(const String& name, const Vector4& value, UINT32 arrayIdx = 0);
+		void setMat3(const String& name, const Matrix3& value, UINT32 arrayIdx = 0);
+		void setMat4(const String& name, const Matrix4& value, UINT32 arrayIdx = 0);
 
 		void setParamBlock(const String& name, GpuParamBlockPtr paramBlock);
 
@@ -77,10 +77,21 @@ namespace CamelotEngine
 
 		vector<PassParametersPtr>::type mParametersPerPass;
 
+		// These maps aren't necessary as we can read these values from the GpuParams directly
+		// but they make many things (especially serializing and getting values) so much easier
+		map<String, vector<float>::type>::type mFloatValues;
+		map<String, vector<Vector2>::type>::type mVec2Values;
+		map<String, vector<Vector3>::type>::type mVec3Values;
+		map<String, vector<Vector4>::type>::type mVec4Values;
+		map<String, vector<Matrix3>::type>::type mMat3Values;
+		map<String, vector<Matrix4>::type>::type mMat4Values;
+		map<String, TextureHandle>::type mTextureValues;
+		map<String, SamplerStateHandle>::type mSamplerValues;
+
 		void throwIfNotInitialized() const;
 
 		template <typename T>
-		void setParam(const String& name, T& value)
+		void setParam(const String& name, T& value, UINT32 arrayIdx)
 		{
 			for(auto iter = mParametersPerPass.begin(); iter != mParametersPerPass.end(); ++iter)
 			{
@@ -92,12 +103,23 @@ namespace CamelotEngine
 					if(paramPtr)
 					{
 						if(paramPtr->hasParam(name))
-							paramPtr->setParam(name, value);
+							paramPtr->setParam(name, value, arrayIdx);
 					}
 				}
 			}
 		}
 
+		const set<String>::type& getValidParamNames() const { return mValidParams; }
+
+		TextureHandle getTexture(const String& name) const;
+		SamplerStateHandle getSamplerState(const String& name) const;
+		float getFloat(const String& name, UINT32 arrayIdx = 0) const;
+		Vector2 getVec2(const String& name, UINT32 arrayIdx = 0) const;
+		Vector3 getVec3(const String& name, UINT32 arrayIdx = 0) const;
+		Vector4 getVec4(const String& name, UINT32 arrayIdx = 0) const;
+		Matrix3 getMat3(const String& name, UINT32 arrayIdx = 0) const;
+		Matrix4 getMat4(const String& name, UINT32 arrayIdx = 0) const;
+
 		void initBestTechnique();
 
 		set<String>::type determineValidParameters(const vector<const GpuParamDesc*>::type& paramDescs) const;

CamelotRenderer/Include/CmMaterialRTTI.h

@@ -17,352 +17,435 @@
 
 namespace CamelotEngine
 {
-	class CM_EXPORT MaterialRTTI : public RTTIType<Material, Resource, MaterialRTTI>
+	/************************************************************************/
+	/* 					HELPER STRUCTS TO HELP SERIALIZING                  */
+	/************************************************************************/
+
+	class CM_EXPORT MaterialFloatParam : public IReflectable
 	{
-	private:
-		struct FloatParam
+	public:
+		String name;
+		float value;
+		UINT32 arrayIdx;
+
+		friend class MaterialFloatParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialVec2Param : public IReflectable
+	{
+	public:
+		String name;
+		Vector2 value;
+		UINT32 arrayIdx;
+
+		friend class MaterialVec2ParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialVec3Param : public IReflectable
+	{
+	public:
+		String name;
+		Vector3 value;
+		UINT32 arrayIdx;
+
+		friend class MaterialVec3ParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialVec4Param : public IReflectable
+	{
+	public:
+		String name;
+		Vector4 value;
+		UINT32 arrayIdx;
+
+		friend class MaterialVec4ParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialMat3Param : public IReflectable
+	{
+	public:
+		String name;
+		Matrix3 value;
+		UINT32 arrayIdx;
+
+		friend class MaterialMat3ParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialMat4Param : public IReflectable
+	{
+	public:
+		String name;
+		Matrix4 value;
+		UINT32 arrayIdx;
+
+		friend class MaterialMat4ParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialTextureParam : public IReflectable
+	{
+	public:
+		String name;
+		TextureHandle value;
+
+		friend class MaterialTextureParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialSamplerStateParam : public IReflectable
+	{
+	public:
+		String name;
+		SamplerStateHandle value;
+
+		friend class MaterialSamplerStateParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	class CM_EXPORT MaterialParams : public IReflectable
+	{
+	public:
+		vector<MaterialFloatParam>::type floatParams;
+		vector<MaterialVec2Param>::type vec2Params;
+		vector<MaterialVec3Param>::type vec3Params;
+		vector<MaterialVec4Param>::type vec4Params;
+		vector<MaterialMat3Param>::type mat3Params;
+		vector<MaterialMat4Param>::type mat4Params;
+		vector<MaterialTextureParam>::type textureParams;
+		vector<MaterialSamplerStateParam>::type samplerStateParams;
+
+		friend class MaterialParamsRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
+	};
+
+	/************************************************************************/
+	/* 				RTTI FOR HELPER STRUCTS TO HELP SERIALIZING             */
+	/************************************************************************/
+
+	class CM_EXPORT MaterialFloatParamRTTI : public RTTIType<MaterialFloatParam, IReflectable, MaterialFloatParamRTTI>
+	{
+	public:
+		String& getName(MaterialFloatParam* obj) { return obj->name; }
+		void setName(MaterialFloatParam* obj, String& name) { obj->name = name; }
+
+		float& getValue(MaterialFloatParam* obj) { return obj->value; }
+		void setValue(MaterialFloatParam* obj, float& value) { obj->value = value; }
+
+		UINT32& getArrayIdx(MaterialFloatParam* obj) { return obj->arrayIdx; }
+		void setArrayIdx(MaterialFloatParam* obj, UINT32& value) { obj->arrayIdx = value; }
+
+		MaterialFloatParamRTTI()
+		{
+			addPlainField("name", 0, &MaterialFloatParamRTTI::getName, &MaterialFloatParamRTTI::setName);
+			addPlainField("value", 1, &MaterialFloatParamRTTI::getValue, &MaterialFloatParamRTTI::setValue);
+			addPlainField("arrayIdx", 2, &MaterialFloatParamRTTI::getArrayIdx, &MaterialFloatParamRTTI::setArrayIdx);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "MaterialFloatParam";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParamFloat; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialFloatParam()); }
+	};
+
+	class CM_EXPORT MaterialVec2ParamRTTI : public RTTIType<MaterialVec2Param, IReflectable, MaterialVec2ParamRTTI>
+	{
+	public:
+		String& getName(MaterialVec2Param* obj) { return obj->name; }
+		void setName(MaterialVec2Param* obj, String& name) { obj->name = name; }
+
+		Vector2& getValue(MaterialVec2Param* obj) { return obj->value; }
+		void setValue(MaterialVec2Param* obj, Vector2& value) { obj->value = value; }
+
+		UINT32& getArrayIdx(MaterialVec2Param* obj) { return obj->arrayIdx; }
+		void setArrayIdx(MaterialVec2Param* obj, UINT32& value) { obj->arrayIdx = value; }
+
+		MaterialVec2ParamRTTI()
+		{
+			addPlainField("name", 0, &MaterialVec2ParamRTTI::getName, &MaterialVec2ParamRTTI::setName);
+			addPlainField("value", 1, &MaterialVec2ParamRTTI::getValue, &MaterialVec2ParamRTTI::setValue);
+			addPlainField("arrayIdx", 2, &MaterialVec2ParamRTTI::getArrayIdx, &MaterialVec2ParamRTTI::setArrayIdx);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "MaterialVec2Param";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParamVec2; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialVec2Param()); }
+	};
+
+	class CM_EXPORT MaterialVec3ParamRTTI : public RTTIType<MaterialVec3Param, IReflectable, MaterialVec3ParamRTTI>
+	{
+	public:
+		String& getName(MaterialVec3Param* obj) { return obj->name; }
+		void setName(MaterialVec3Param* obj, String& name) { obj->name = name; }
+
+		Vector3& getValue(MaterialVec3Param* obj) { return obj->value; }
+		void setValue(MaterialVec3Param* obj, Vector3& value) { obj->value = value; }
+
+		UINT32& getArrayIdx(MaterialVec3Param* obj) { return obj->arrayIdx; }
+		void setArrayIdx(MaterialVec3Param* obj, UINT32& value) { obj->arrayIdx = value; }
+
+		MaterialVec3ParamRTTI()
+		{
+			addPlainField("name", 0, &MaterialVec3ParamRTTI::getName, &MaterialVec3ParamRTTI::setName);
+			addPlainField("value", 1, &MaterialVec3ParamRTTI::getValue, &MaterialVec3ParamRTTI::setValue);
+			addPlainField("arrayIdx", 2, &MaterialVec3ParamRTTI::getArrayIdx, &MaterialVec3ParamRTTI::setArrayIdx);
+		}
+
+		virtual const String& getRTTIName()
 		{
-			FloatParam() {}
+			static String name = "MaterialVec3Param";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParamVec3; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialVec3Param()); }
+	};
+
+	class CM_EXPORT MaterialVec4ParamRTTI : public RTTIType<MaterialVec4Param, IReflectable, MaterialVec4ParamRTTI>
+	{
+	public:
+		String& getName(MaterialVec4Param* obj) { return obj->name; }
+		void setName(MaterialVec4Param* obj, String& name) { obj->name = name; }
+
+		Vector4& getValue(MaterialVec4Param* obj) { return obj->value; }
+		void setValue(MaterialVec4Param* obj, Vector4& value) { obj->value = value; }
+
+		UINT32& getArrayIdx(MaterialVec4Param* obj) { return obj->arrayIdx; }
+		void setArrayIdx(MaterialVec4Param* obj, UINT32& value) { obj->arrayIdx = value; }
+
+		MaterialVec4ParamRTTI()
+		{
+			addPlainField("name", 0, &MaterialVec4ParamRTTI::getName, &MaterialVec4ParamRTTI::setName);
+			addPlainField("value", 1, &MaterialVec4ParamRTTI::getValue, &MaterialVec4ParamRTTI::setValue);
+			addPlainField("arrayIdx", 2, &MaterialVec4ParamRTTI::getArrayIdx, &MaterialVec4ParamRTTI::setArrayIdx);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "MaterialVec4Param";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParamVec4; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialVec4Param()); }
+	};
+
+	class CM_EXPORT MaterialMat3ParamRTTI : public RTTIType<MaterialMat3Param, IReflectable, MaterialMat3ParamRTTI>
+	{
+	public:
+		String& getName(MaterialMat3Param* obj) { return obj->name; }
+		void setName(MaterialMat3Param* obj, String& name) { obj->name = name; }
+
+		Matrix3& getValue(MaterialMat3Param* obj) { return obj->value; }
+		void setValue(MaterialMat3Param* obj, Matrix3& value) { obj->value = value; }
+
+		UINT32& getArrayIdx(MaterialMat3Param* obj) { return obj->arrayIdx; }
+		void setArrayIdx(MaterialMat3Param* obj, UINT32& value) { obj->arrayIdx = value; }
+
+		MaterialMat3ParamRTTI()
+		{
+			addPlainField("name", 0, &MaterialMat3ParamRTTI::getName, &MaterialMat3ParamRTTI::setName);
+			addPlainField("value", 1, &MaterialMat3ParamRTTI::getValue, &MaterialMat3ParamRTTI::setValue);
+			addPlainField("arrayIdx", 2, &MaterialMat3ParamRTTI::getArrayIdx, &MaterialMat3ParamRTTI::setArrayIdx);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "MaterialMat3Param";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParamMat3; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialMat3Param()); }
+	};
+
+	class CM_EXPORT MaterialMat4ParamRTTI : public RTTIType<MaterialMat4Param, IReflectable, MaterialMat4ParamRTTI>
+	{
+	public:
+		String& getName(MaterialMat4Param* obj) { return obj->name; }
+		void setName(MaterialMat4Param* obj, String& name) { obj->name = name; }
+
+		Matrix4& getValue(MaterialMat4Param* obj) { return obj->value; }
+		void setValue(MaterialMat4Param* obj, Matrix4& value) { obj->value = value; }
+
+		UINT32& getArrayIdx(MaterialMat4Param* obj) { return obj->arrayIdx; }
+		void setArrayIdx(MaterialMat4Param* obj, UINT32& value) { obj->arrayIdx = value; }
+
+		MaterialMat4ParamRTTI()
+		{
+			addPlainField("name", 0, &MaterialMat4ParamRTTI::getName, &MaterialMat4ParamRTTI::setName);
+			addPlainField("value", 1, &MaterialMat4ParamRTTI::getValue, &MaterialMat4ParamRTTI::setValue);
+			addPlainField("arrayIdx", 2, &MaterialMat4ParamRTTI::getArrayIdx, &MaterialMat4ParamRTTI::setArrayIdx);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "MaterialMat4Param";
+			return name;
+		}
 
-			FloatParam(UINT32 bufferIdx, GpuConstantType type, UINT32 count)
-				:mBufferIdx(bufferIdx), mType(type), mCount(count)
-			{ }
+		virtual UINT32 getRTTIId() { return TID_MaterialParamMat4; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialMat4Param()); }
+	};
 
-			UINT32 mBufferIdx;
-			UINT32 mCount;
-			GpuConstantType mType;
-		};
+	class CM_EXPORT MaterialTextureParamRTTI : public RTTIType<MaterialTextureParam, IReflectable, MaterialTextureParamRTTI>
+	{
+	public:
+		String& getName(MaterialTextureParam* obj) { return obj->name; }
+		void setName(MaterialTextureParam* obj, String& name) { obj->name = name; }
 
-		class FloatParamKVPRTTI;
-		typedef KeyValuePair<String, FloatParam, FloatParamKVPRTTI> FloatParamKVP;
+		TextureHandle& getValue(MaterialTextureParam* obj) { return obj->value; }
+		void setValue(MaterialTextureParam* obj, TextureHandle& value) { obj->value = value; }
 
-		class FloatParamKVPRTTI : public RTTIType<FloatParamKVP, IReflectable, FloatParamKVPRTTI>
+		MaterialTextureParamRTTI()
 		{
-		private:
-			String& getKey(FloatParamKVP* obj) { return obj->mKey; }
-			void setKey(FloatParamKVP* obj,  String& val) { obj->mKey = val; }
-
-			FloatParam& getValue(FloatParamKVP* obj) { return obj->mValue; }
-			void setValue(FloatParamKVP* obj,  FloatParam& val) { obj->mValue = val; }
-
-		public:
-			FloatParamKVPRTTI()
-			{
-				addPlainField("mKey", 0, &FloatParamKVPRTTI::getKey, &FloatParamKVPRTTI::setKey);
-				addPlainField("mValue", 1, &FloatParamKVPRTTI::getValue, &FloatParamKVPRTTI::setValue);
-			}
-
-		public:
-			virtual const String& getRTTIName()
-			{
-				static String name = "FloatParamKVP";
-				return name;
-			}
-
-			virtual UINT32 getRTTIId()
-			{
-				return TID_FloatParamKVP;
-			}
-
-			virtual std::shared_ptr<IReflectable> newRTTIObject()
-			{
-				return std::shared_ptr<FloatParamKVP>(new FloatParamKVP());
-			}
-		};
-
-		class TexParamKVPRTTI;
-		typedef KeyValuePair<String, TextureHandle, TexParamKVPRTTI> TexParamKVP;
-
-		class TexParamKVPRTTI : public RTTIType<TexParamKVP, IReflectable, TexParamKVPRTTI>
+			addPlainField("name", 0, &MaterialTextureParamRTTI::getName, &MaterialTextureParamRTTI::setName);
+			addReflectableField("value", 1, &MaterialTextureParamRTTI::getValue, &MaterialTextureParamRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
 		{
-		private:
-			String& getKey(TexParamKVP* obj) { return obj->mKey; }
-			void setKey(TexParamKVP* obj,  String& val) { obj->mKey = val; }
-
-			TextureHandle& getValue(TexParamKVP* obj) { return obj->mValue; }
-			void setValue(TexParamKVP* obj,  TextureHandle& val) { obj->mValue = val; }
-
-		public:
-			TexParamKVPRTTI()
-			{
-				addPlainField("mKey", 0, &TexParamKVPRTTI::getKey, &TexParamKVPRTTI::setKey);
-				addReflectableField("mValue", 1, &TexParamKVPRTTI::getValue, &TexParamKVPRTTI::setValue);
-			}
-
-		public:
-			virtual const String& getRTTIName()
-			{
-				static String name = "TexParamKVP";
-				return name;
-			}
-
-			virtual UINT32 getRTTIId()
-			{
-				return TID_MaterialTexParamKVP;
-			}
-
-			virtual std::shared_ptr<IReflectable> newRTTIObject()
-			{
-				return std::shared_ptr<TexParamKVP>(new TexParamKVP());
-			}
-		};
-
-		class SamplerStateParamKVPRTTI;
-		typedef KeyValuePair<String, SamplerStatePtr, SamplerStateParamKVPRTTI> SamplerStateKVP;
-
-		class SamplerStateParamKVPRTTI : public RTTIType<SamplerStateKVP, IReflectable, SamplerStateParamKVPRTTI>
+			static String name = "MaterialTextureParam";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParamTexture; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialTextureParam()); }
+	};
+
+	class CM_EXPORT MaterialSamplerStateParamRTTI : public RTTIType<MaterialSamplerStateParam, IReflectable, MaterialSamplerStateParamRTTI>
+	{
+	public:
+		String& getName(MaterialSamplerStateParam* obj) { return obj->name; }
+		void setName(MaterialSamplerStateParam* obj, String& name) { obj->name = name; }
+
+		SamplerStateHandle& getValue(MaterialSamplerStateParam* obj) { return obj->value; }
+		void setValue(MaterialSamplerStateParam* obj, SamplerStateHandle& value) { obj->value = value; }
+
+		MaterialSamplerStateParamRTTI()
 		{
-		private:
-			String& getKey(SamplerStateKVP* obj) { return obj->mKey; }
-			void setKey(SamplerStateKVP* obj,  String& val) { obj->mKey = val; }
-
-			SamplerStatePtr getValue(SamplerStateKVP* obj) { return obj->mValue; }
-			void setValue(SamplerStateKVP* obj,  SamplerStatePtr val) { obj->mValue = val; }
-
-		public:
-			SamplerStateParamKVPRTTI()
-			{
-				addPlainField("mKey", 0, &SamplerStateParamKVPRTTI::getKey, &SamplerStateParamKVPRTTI::setKey);
-				addReflectablePtrField("mValue", 1, &SamplerStateParamKVPRTTI::getValue, &SamplerStateParamKVPRTTI::setValue);
-			}
-
-		public:
-			virtual const String& getRTTIName()
-			{
-				static String name = "SamplerStateKVP";
-				return name;
-			}
-
-			virtual UINT32 getRTTIId()
-			{
-				return TID_SamplerStateParamKVP;
-			}
-
-			virtual std::shared_ptr<IReflectable> newRTTIObject()
-			{
-				return std::shared_ptr<SamplerStateKVP>(new SamplerStateKVP());
-			}
-		};
-
-		class MaterialParamsRTTI;
-
-		struct MaterialParams : public IReflectable
+			addPlainField("name", 0, &MaterialSamplerStateParamRTTI::getName, &MaterialSamplerStateParamRTTI::setName);
+			addReflectableField("value", 1, &MaterialSamplerStateParamRTTI::getValue, &MaterialSamplerStateParamRTTI::setValue);
+		}
+
+		virtual const String& getRTTIName()
 		{
-			map<String, FloatParam>::type mFloatParams;
-			map<String, TextureHandle>::type mTextureParams;
-			map<String, SamplerStatePtr>::type mSamplerStateParams;
+			static String name = "MaterialSamplerStateParam";
+			return name;
+		}
 
-			vector<float>::type mFloatBuffer;
+		virtual UINT32 getRTTIId() { return TID_MaterialParamSamplerState; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialSamplerStateParam()); }
+	};
 
-			/************************************************************************/
-			/* 								RTTI		                     		*/
-			/************************************************************************/
+	class CM_EXPORT MaterialParamsRTTI : public RTTIType<MaterialParams, IReflectable, MaterialParamsRTTI>
+	{
+	public:
+		MaterialFloatParam& getFloatParam(MaterialParams* obj, UINT32 idx) { return obj->floatParams[idx]; }
+		void setFloatParam(MaterialParams* obj, UINT32 idx, MaterialFloatParam& param) { obj->floatParams[idx] = param; }
+		UINT32 getFloatArraySize(MaterialParams* obj) { return (UINT32)obj->floatParams.size(); }
+		void setFloatArraySize(MaterialParams* obj, UINT32 size) { obj->floatParams.resize(size); }
+
+		MaterialVec2Param& getVec2Param(MaterialParams* obj, UINT32 idx) { return obj->vec2Params[idx]; }
+		void setVec2Param(MaterialParams* obj, UINT32 idx, MaterialVec2Param& param) { obj->vec2Params[idx] = param; }
+		UINT32 getVec2ArraySize(MaterialParams* obj) { return (UINT32)obj->vec2Params.size(); }
+		void setVec2ArraySize(MaterialParams* obj, UINT32 size) { obj->vec2Params.resize(size); }
+
+		MaterialVec3Param& getVec3Param(MaterialParams* obj, UINT32 idx) { return obj->vec3Params[idx]; }
+		void setVec3Param(MaterialParams* obj, UINT32 idx, MaterialVec3Param& param) { obj->vec3Params[idx] = param; }
+		UINT32 getVec3ArraySize(MaterialParams* obj) { return (UINT32)obj->vec3Params.size(); }
+		void setVec3ArraySize(MaterialParams* obj, UINT32 size) { obj->vec3Params.resize(size); }
+
+		MaterialVec4Param& getVec4Param(MaterialParams* obj, UINT32 idx) { return obj->vec4Params[idx]; }
+		void setVec4Param(MaterialParams* obj, UINT32 idx, MaterialVec4Param& param) { obj->vec4Params[idx] = param; }
+		UINT32 getVec4ArraySize(MaterialParams* obj) { return (UINT32)obj->vec4Params.size(); }
+		void setVec4ArraySize(MaterialParams* obj, UINT32 size) { obj->vec4Params.resize(size); }
+
+		MaterialMat3Param& getMat3Param(MaterialParams* obj, UINT32 idx) { return obj->mat3Params[idx]; }
+		void setMat3Param(MaterialParams* obj, UINT32 idx, MaterialMat3Param& param) { obj->mat3Params[idx] = param; }
+		UINT32 getMat3ArraySize(MaterialParams* obj) { return (UINT32)obj->mat3Params.size(); }
+		void setMat3ArraySize(MaterialParams* obj, UINT32 size) { obj->mat3Params.resize(size); }
+
+		MaterialMat4Param& getMat4Param(MaterialParams* obj, UINT32 idx) { return obj->mat4Params[idx]; }
+		void setMat4Param(MaterialParams* obj, UINT32 idx, MaterialMat4Param& param) { obj->mat4Params[idx] = param; }
+		UINT32 getMat4ArraySize(MaterialParams* obj) { return (UINT32)obj->mat4Params.size(); }
+		void setMat4ArraySize(MaterialParams* obj, UINT32 size) { obj->mat4Params.resize(size); }
+
+		MaterialTextureParam& getTextureParam(MaterialParams* obj, UINT32 idx) { return obj->textureParams[idx]; }
+		void setTextureParam(MaterialParams* obj, UINT32 idx, MaterialTextureParam& param) { obj->textureParams[idx] = param; }
+		UINT32 getTextureArraySize(MaterialParams* obj) { return (UINT32)obj->textureParams.size(); }
+		void setTextureArraySize(MaterialParams* obj, UINT32 size) { obj->textureParams.resize(size); }
+
+		MaterialSamplerStateParam& getSamplerStateParam(MaterialParams* obj, UINT32 idx) { return obj->samplerStateParams[idx]; }
+		void setSamplerStateParam(MaterialParams* obj, UINT32 idx, MaterialSamplerStateParam& param) { obj->samplerStateParams[idx] = param; }
+		UINT32 getSamplerStateArraySize(MaterialParams* obj) { return (UINT32)obj->samplerStateParams.size(); }
+		void setSamplerStateArraySize(MaterialParams* obj, UINT32 size) { obj->samplerStateParams.resize(size); }
+
+		MaterialParamsRTTI()
+		{
+			addReflectableArrayField("floatParams", 0, &MaterialParamsRTTI::getFloatParam, 
+				&MaterialParamsRTTI::getFloatArraySize, &MaterialParamsRTTI::setFloatParam, &MaterialParamsRTTI::setFloatArraySize);
 
-		public:
-			friend class MaterialRTTI::MaterialParamsRTTI;
+			addReflectableArrayField("vec2Params", 1, &MaterialParamsRTTI::getVec2Param, 
+				&MaterialParamsRTTI::getVec2ArraySize, &MaterialParamsRTTI::setVec2Param, &MaterialParamsRTTI::setVec2ArraySize);
 
-			static RTTITypeBase* getRTTIStatic();
-			RTTITypeBase* getRTTI() const;
-		};
+			addReflectableArrayField("vec3Params", 2, &MaterialParamsRTTI::getVec3Param, 
+				&MaterialParamsRTTI::getVec3ArraySize, &MaterialParamsRTTI::setVec3Param, &MaterialParamsRTTI::setVec3ArraySize);
 
-		class MaterialParamsRTTI : public RTTIType<MaterialParams, IReflectable, MaterialParamsRTTI>
+			addReflectableArrayField("vec4Params", 3, &MaterialParamsRTTI::getVec4Param, 
+				&MaterialParamsRTTI::getVec4ArraySize, &MaterialParamsRTTI::setVec4Param, &MaterialParamsRTTI::setVec4ArraySize);
+
+			addReflectableArrayField("mat3Params", 4, &MaterialParamsRTTI::getMat3Param, 
+				&MaterialParamsRTTI::getMat3ArraySize, &MaterialParamsRTTI::setMat3Param, &MaterialParamsRTTI::setMat3ArraySize);
+
+			addReflectableArrayField("mat4Params", 5, &MaterialParamsRTTI::getMat4Param, 
+				&MaterialParamsRTTI::getMat4ArraySize, &MaterialParamsRTTI::setMat4Param, &MaterialParamsRTTI::setMat4ArraySize);
+
+			addReflectableArrayField("textureParams", 6, &MaterialParamsRTTI::getTextureParam, 
+				&MaterialParamsRTTI::getTextureArraySize, &MaterialParamsRTTI::setTextureParam, &MaterialParamsRTTI::setTextureArraySize);
+
+			addReflectableArrayField("samplerStateParams", 7, &MaterialParamsRTTI::getSamplerStateParam, 
+				&MaterialParamsRTTI::getSamplerStateArraySize, &MaterialParamsRTTI::setSamplerStateParam, &MaterialParamsRTTI::setSamplerStateArraySize);
+		}
+
+		virtual const String& getRTTIName()
 		{
-		private:
-			struct TempParams
-			{
-				vector<std::shared_ptr<FloatParamKVP>>::type mFloatParams;
-				vector<std::shared_ptr<TexParamKVP>>::type mTexParams;
-				vector<std::shared_ptr<SamplerStateKVP>>::type mSamplerStateParams;
-			};
-
-			std::shared_ptr<FloatParamKVP> getFloatParam(MaterialParams* obj, UINT32 idx)
-			{
-				UINT32 curIdx = 0;
-				for(auto iter = obj->mFloatParams.begin(); iter != obj->mFloatParams.end(); ++iter)
-				{
-					if(curIdx == idx)
-					{
-						return std::shared_ptr<FloatParamKVP>(new FloatParamKVP(iter->first, iter->second));
-					}
-
-					curIdx++;
-				}
-
-				CM_EXCEPT(InternalErrorException, "Invalid index.");
-			}
-
-			void setFloatParam(MaterialParams* obj, UINT32 idx, std::shared_ptr<FloatParamKVP> value)
-			{
-				TempParams* tempParams = boost::any_cast<TempParams*>(obj->mRTTIData);
-				tempParams->mFloatParams.push_back(value);
-			}
-
-			void setNumFloatParams(MaterialParams* obj, UINT32 size)
-			{
-				// Do nothing. Map is expanded automatically as entries are added
-			}
-
-			UINT32 getNumFloatParams(MaterialParams* obj)
-			{
-				return (UINT32)obj->mFloatParams.size();
-			}
-
-			std::shared_ptr<TexParamKVP> getTexParam(MaterialParams* obj, UINT32 idx)
-			{
-				UINT32 curIdx = 0;
-				for(auto iter = obj->mTextureParams.begin(); iter != obj->mTextureParams.end(); ++iter)
-				{
-					if(curIdx == idx)
-					{
-						return std::shared_ptr<TexParamKVP>(new TexParamKVP(iter->first, iter->second));
-					}
-
-					curIdx++;
-				}
-
-				CM_EXCEPT(InternalErrorException, "Invalid index.");
-			}
-
-			void setTexParam(MaterialParams* obj, UINT32 idx, std::shared_ptr<TexParamKVP> value)
-			{
-				TempParams* tempParams = boost::any_cast<TempParams*>(obj->mRTTIData);
-				tempParams->mTexParams.push_back(value);
-			}
-
-			void setNumTexParams(MaterialParams* obj, UINT32 size)
-			{
-				// Do nothing. Map is expanded automatically as entries are added
-			}
-
-			UINT32 getNumTexParams(MaterialParams* obj)
-			{
-				return (UINT32)obj->mTextureParams.size();
-			}
-
-			std::shared_ptr<SamplerStateKVP> getSamplerStateParam(MaterialParams* obj, UINT32 idx)
-			{
-				UINT32 curIdx = 0;
-				for(auto iter = obj->mSamplerStateParams.begin(); iter != obj->mSamplerStateParams.end(); ++iter)
-				{
-					if(curIdx == idx)
-					{
-						return std::shared_ptr<SamplerStateKVP>(new SamplerStateKVP(iter->first, iter->second));
-					}
-
-					curIdx++;
-				}
-
-				CM_EXCEPT(InternalErrorException, "Invalid index.");
-			}
-
-			void setSamplerStateParam(MaterialParams* obj, UINT32 idx, std::shared_ptr<SamplerStateKVP> value)
-			{
-				TempParams* tempParams = boost::any_cast<TempParams*>(obj->mRTTIData);
-				tempParams->mSamplerStateParams.push_back(value);
-			}
-
-			void setNumSamplerStateParams(MaterialParams* obj, UINT32 size)
-			{
-				// Do nothing. Map is expanded automatically as entries are added
-			}
-
-			UINT32 getNumSamplerStateParams(MaterialParams* obj)
-			{
-				return (UINT32)obj->mSamplerStateParams.size();
-			}
-
-			ManagedDataBlock getFloatBuffer(MaterialParams* obj)
-			{
-				UINT32 bufferSize = (UINT32)obj->mFloatBuffer.size();
-				float* buffer = new float[bufferSize];
-
-				for(UINT32 i = 0; i < bufferSize; i++)
-					buffer[i] = obj->mFloatBuffer[i];
-
-				return ManagedDataBlock((UINT8*)buffer, bufferSize, true);
-			}
-
-			void setFloatBuffer(MaterialParams* obj, ManagedDataBlock data)
-			{
-				obj->mFloatBuffer.clear();
-
-				float* buffer = (float*)data.getData();
-				for(UINT32 i = 0; i < data.getSize(); i++)
-					obj->mFloatBuffer.push_back(buffer[i]);
-
-				data.destroy();
-			}
-
-		public:
-			MaterialParamsRTTI()
-			{
-				addReflectablePtrArrayField("mFloatParams", 0, &MaterialParamsRTTI::getFloatParam, &MaterialParamsRTTI::getNumFloatParams, 
-					&MaterialParamsRTTI::setFloatParam, &MaterialParamsRTTI::setNumFloatParams);
-				addReflectablePtrArrayField("mTexParams", 1, &MaterialParamsRTTI::getTexParam, &MaterialParamsRTTI::getNumTexParams, 
-					&MaterialParamsRTTI::setTexParam, &MaterialParamsRTTI::setNumTexParams);
-				addReflectablePtrArrayField("mSamplerStateParams", 2, &MaterialParamsRTTI::getSamplerStateParam, &MaterialParamsRTTI::getNumSamplerStateParams, 
-					&MaterialParamsRTTI::setSamplerStateParam, &MaterialParamsRTTI::setNumSamplerStateParams);
-				addDataBlockField("mFloatBuffer", 3, &MaterialParamsRTTI::getFloatBuffer, &MaterialParamsRTTI::setFloatBuffer);
-			}
-
-			virtual void onDeserializationStarted(IReflectable* obj)
-			{
-				MaterialParams* materialParams = static_cast<MaterialParams*>(obj);
-				materialParams->mRTTIData = new TempParams();
-			}
-
-			virtual void onDeserializationEnded(IReflectable* obj)
-			{
-				// TODO Low priority:
-				// Due to the way serialization is done I cannot guarantee "value"s key/value fields
-				// have been set, so I need to delay accessing them until the end of serialization.
-				// I'd really like to avoid this as its not intuitive to think in this way.
-
-				MaterialParams* materialParams = static_cast<MaterialParams*>(obj);
-
-				if(materialParams->mRTTIData.empty())
-					return;
-
-				TempParams* tempParams = boost::any_cast<TempParams*>(materialParams->mRTTIData);
-
-				for(auto iter = tempParams->mFloatParams.begin(); iter != tempParams->mFloatParams.end(); ++iter)
-				{
-					std::shared_ptr<FloatParamKVP> floatParam = *iter;
-					materialParams->mFloatParams[floatParam->mKey] = floatParam->mValue;
-				}
-
-				for(auto iter = tempParams->mTexParams.begin(); iter != tempParams->mTexParams.end(); ++iter)
-				{
-					std::shared_ptr<TexParamKVP> texParam = *iter;
-					materialParams->mTextureParams[texParam->mKey] = texParam->mValue;
-				}
-
-				for(auto iter = tempParams->mSamplerStateParams.begin(); iter != tempParams->mSamplerStateParams.end(); ++iter)
-				{
-					std::shared_ptr<SamplerStateKVP> samplerStateParam = *iter;
-					materialParams->mSamplerStateParams[samplerStateParam->mKey] = samplerStateParam->mValue;
-				}
-
-				materialParams->mRTTIData = nullptr;
-			}
-
-			virtual const String& getRTTIName()
-			{
-				static String name = "MaterialParams";
-				return name;
-			}
-
-			virtual UINT32 getRTTIId()
-			{
-				return TID_MaterialParams;
-			}
-
-			virtual std::shared_ptr<IReflectable> newRTTIObject()
-			{
-				return std::shared_ptr<MaterialParams>(new MaterialParams());
-			}
-		};
+			static String name = "MaterialParams";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParams; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialParams()); }
+	};
+
+	// TODO - Add MaterialParamsRTTI
+	// - Add a way to fill and read from MaterialParams
 
+	class CM_EXPORT MaterialRTTI : public RTTIType<Material, Resource, MaterialRTTI>
+	{
+	private:
 		ShaderPtr getShader(Material* obj)
 		{
 			return obj->mShader;

CamelotRenderer/Include/CmPrerequisites.h

@@ -232,7 +232,15 @@ namespace CamelotEngine
 		TID_SamplerStateParamKVP = 1022,
 		TID_BlendState = 1023,
 		TID_RasterizerState = 1024,
-		TID_DepthStencilState = 1025
+		TID_DepthStencilState = 1025,
+		TID_MaterialParamFloat = 1026,
+		TID_MaterialParamVec2 = 1027,
+		TID_MaterialParamVec3 = 1028,
+		TID_MaterialParamVec4 = 1029,
+		TID_MaterialParamMat3 = 1030,
+		TID_MaterialParamMat4 = 1031,
+		TID_MaterialParamTexture = 1032,
+		TID_MaterialParamSamplerState = 1033
 	};
 }
 
@@ -250,6 +258,7 @@ namespace CamelotEngine
 	typedef ResourceHandle<GpuProgram> GpuProgramHandle;
 	typedef ResourceHandle<HighLevelGpuProgram> HighLevelGpuProgramHandle;
 	typedef ResourceHandle<Material> MaterialHandle;
+	typedef ResourceHandle<SamplerState> SamplerStateHandle;
 	typedef ResourceHandle<RasterizerState> RasterizerStateHandle;
 	typedef ResourceHandle<DepthStencilState> DepthStencilStateHandle;
 	typedef ResourceHandle<BlendState> BlendStateHandle;

CamelotRenderer/Include/CmShader.h

@@ -67,10 +67,20 @@ namespace CamelotEngine
 		void removeParameter(const String& name);
 		void setParamBlockAttribs(const String& name, bool shared, GpuParamBlockUsage usage);
 
+		GpuParamType getParamType(const String& name) const;
+		const SHADER_DATA_PARAM_DESC& getDataParamDesc(const String& name) const;
+		const SHADER_OBJECT_PARAM_DESC& getObjectParamDesc(const String& name) const;
+
+		bool hasDataParam(const String& name) const;
+		bool hasObjectParam(const String& name) const;
+
 		const map<String, SHADER_DATA_PARAM_DESC>::type& getDataParams() const { return mDataParams; }
 		const map<String, SHADER_OBJECT_PARAM_DESC>::type& getObjectParams() const { return mObjectParams; }
 		const map<String, SHADER_PARAM_BLOCK_DESC>::type& getParamBlocks() const { return mParamBlocks; }
 
+		static bool isSampler(GpuParamObjectType type);
+		static bool isTexture(GpuParamObjectType type);
+		static bool isBuffer(GpuParamObjectType type);
 	private:
 		String mName;
 		vector<TechniquePtr>::type mTechniques;

CamelotRenderer/Source/CmGpuParams.cpp

@@ -220,7 +220,7 @@ namespace CamelotEngine
 		}
 	}
 
-	void GpuParams::setTexture(const String& name, TextureHandle val)
+	void GpuParams::setTexture(const String& name, TextureHandle& val)
 	{
 		auto paramIter = mParamDesc.textures.find(name);
 		if(paramIter == mParamDesc.textures.end())
@@ -243,7 +243,7 @@ namespace CamelotEngine
 		return mTextures[slot];
 	}
 
-	void GpuParams::setSamplerState(const String& name, SamplerStatePtr val)
+	void GpuParams::setSamplerState(const String& name, SamplerStateHandle& val)
 	{
 		auto paramIter = mParamDesc.samplers.find(name);
 		if(paramIter == mParamDesc.samplers.end())
@@ -255,7 +255,7 @@ namespace CamelotEngine
 		mSamplerStates[paramIter->second.slot] = val;
 	}
 
-	SamplerStatePtr GpuParams::getSamplerState(UINT32 slot)
+	SamplerStateHandle GpuParams::getSamplerState(UINT32 slot)
 	{
 		if(slot < 0 || slot >= (UINT32)mSamplerStates.size())
 		{

CamelotRenderer/Source/CmMaterial.cpp

@@ -35,6 +35,14 @@ namespace CamelotEngine
 	{
 		mBestTechnique = nullptr;
 		mParametersPerPass.clear();
+		mFloatValues.clear();
+		mVec2Values.clear();
+		mVec3Values.clear();
+		mVec4Values.clear();
+		mMat3Values.clear();
+		mMat4Values.clear();
+		mTextureValues.clear();
+		mSamplerValues.clear();
 
 		if(mShader)
 		{
@@ -153,6 +161,30 @@ namespace CamelotEngine
 
 				String& paramBlockName = findBlockIter->second;
 				mValidParams.insert(iter->first);
+
+				switch(iter->second.type)
+				{
+				case GPDT_FLOAT1:
+					mFloatValues[iter->first].resize(iter->second.arraySize);
+					break;
+				case GPDT_FLOAT2:
+					mVec2Values[iter->first].resize(iter->second.arraySize);
+					break;
+				case GPDT_FLOAT3:
+					mVec3Values[iter->first].resize(iter->second.arraySize);
+					break;
+				case GPDT_FLOAT4:
+					mVec4Values[iter->first].resize(iter->second.arraySize);
+					break;
+				case GPDT_MATRIX_3X3:
+					mMat3Values[iter->first].resize(iter->second.arraySize);
+					break;
+				case GPDT_MATRIX_4X4:
+					mMat4Values[iter->first].resize(iter->second.arraySize);
+					break;
+				default:
+					CM_EXCEPT(InternalErrorException, "Unsupported data type.");
+				}
 			}
 
 			// Create object param mappings
@@ -166,6 +198,23 @@ namespace CamelotEngine
 					continue;
 
 				mValidParams.insert(iter->first);
+
+				if(Shader::isSampler(iter->second.type))
+				{
+					mSamplerValues[iter->first] = SamplerStateHandle();
+				}
+				else if(Shader::isTexture(iter->second.type))
+				{
+					mTextureValues[iter->first] = TextureHandle();
+				}
+				else if(Shader::isBuffer(iter->second.type))
+				{
+					// TODO
+
+					CM_EXCEPT(NotImplementedException, "Buffers not implemented.");
+				}
+				else
+					CM_EXCEPT(InternalErrorException, "Invalid object param type.");
 			}
 
 			for(UINT32 i = 0; i < mBestTechnique->getNumPasses(); i++)
@@ -556,9 +605,11 @@ namespace CamelotEngine
 				}
 			}
 		}
+
+		mTextureValues[name] = value;
 	}
 
-	void Material::setSamplerState(const String& name, SamplerStatePtr samplerState)
+	void Material::setSamplerState(const String& name, SamplerStateHandle& samplerState)
 	{
 		throwIfNotInitialized();
 
@@ -583,9 +634,11 @@ namespace CamelotEngine
 				}
 			}
 		}
+
+		mSamplerValues[name] = samplerState;
 	}
 
-	void Material::setFloat(const String& name, float value)
+	void Material::setFloat(const String& name, float value, UINT32 arrayIdx)
 	{
 		throwIfNotInitialized();
 
@@ -596,10 +649,13 @@ namespace CamelotEngine
 			return;
 		}
 
-		setParam(name, value);
+		setParam(name, value, arrayIdx);
+
+		auto savedValue = mFloatValues[name];
+		savedValue[arrayIdx] = value;
 	}
 
-	void Material::setColor(const String& name, const Color& value)
+	void Material::setColor(const String& name, const Color& value, UINT32 arrayIdx)
 	{
 		throwIfNotInitialized();
 
@@ -610,10 +666,13 @@ namespace CamelotEngine
 			return;
 		}
 
-		setParam(name, value);
+		setParam(name, value, arrayIdx);
+
+		auto savedValue = mVec4Values[name];
+		savedValue[arrayIdx] = Vector4(value.r, value.g, value.b, value.a);
 	}
 
-	void Material::setVec2(const String& name, const Vector2& value)
+	void Material::setVec2(const String& name, const Vector2& value, UINT32 arrayIdx)
 	{
 		throwIfNotInitialized();
 
@@ -624,10 +683,13 @@ namespace CamelotEngine
 			return;
 		}
 
-		setParam(name, value);
+		setParam(name, value, arrayIdx);
+
+		auto savedValue = mVec2Values[name];
+		savedValue[arrayIdx] = value;
 	}
 
-	void Material::setVec3(const String& name, const Vector3& value)
+	void Material::setVec3(const String& name, const Vector3& value, UINT32 arrayIdx)
 	{
 		throwIfNotInitialized();
 
@@ -638,10 +700,13 @@ namespace CamelotEngine
 			return;
 		}
 
-		setParam(name, value);
+		setParam(name, value, arrayIdx);
+
+		auto savedValue = mVec3Values[name];
+		savedValue[arrayIdx] = value;
 	}
 
-	void Material::setVec4(const String& name, const Vector4& value)
+	void Material::setVec4(const String& name, const Vector4& value, UINT32 arrayIdx)
 	{
 		throwIfNotInitialized();
 
@@ -652,10 +717,13 @@ namespace CamelotEngine
 			return;
 		}
 
-		setParam(name, value);
+		setParam(name, value, arrayIdx);
+
+		auto savedValue = mVec4Values[name];
+		savedValue[arrayIdx] = value;
 	}
 
-	void Material::setMat3(const String& name, const Matrix3& value)
+	void Material::setMat3(const String& name, const Matrix3& value, UINT32 arrayIdx)
 	{
 		throwIfNotInitialized();
 
@@ -666,10 +734,13 @@ namespace CamelotEngine
 			return;
 		}
 
-		setParam(name, value);
+		setParam(name, value, arrayIdx);
+
+		auto savedValue = mMat3Values[name];
+		savedValue[arrayIdx] = value;
 	}
 
-	void Material::setMat4(const String& name, const Matrix4& value)
+	void Material::setMat4(const String& name, const Matrix4& value, UINT32 arrayIdx)
 	{
 		throwIfNotInitialized();
 
@@ -680,9 +751,11 @@ namespace CamelotEngine
 			return;
 		}
 
-		setParam(name, value);
-	}
+		setParam(name, value, arrayIdx);
 
+		auto savedValue = mMat4Values[name];
+		savedValue[arrayIdx] = value;
+	}
 
 	void Material::setParamBlock(const String& name, GpuParamBlockPtr paramBlock)
 	{
@@ -732,6 +805,86 @@ namespace CamelotEngine
 		return mParametersPerPass[passIdx];
 	}
 
+	TextureHandle Material::getTexture(const String& name) const
+	{
+		auto iterFind = mTextureValues.find(name);
+
+		if(iterFind == mTextureValues.end())
+			CM_EXCEPT(InternalErrorException, "No texture parameter with the name: " + name);
+
+		return iterFind->second;
+	}
+
+	SamplerStateHandle Material::getSamplerState(const String& name) const
+	{
+		auto iterFind = mSamplerValues.find(name);
+
+		if(iterFind == mSamplerValues.end())
+			CM_EXCEPT(InternalErrorException, "No sampler state parameter with the name: " + name);
+
+		return iterFind->second;
+	}
+
+	float Material::getFloat(const String& name, UINT32 arrayIdx) const
+	{
+		auto iterFind = mFloatValues.find(name);
+
+		if(iterFind == mFloatValues.end())
+			CM_EXCEPT(InternalErrorException, "No float parameter with the name: " + name);
+
+		return iterFind->second.at(arrayIdx);
+	}
+
+	Vector2 Material::getVec2(const String& name, UINT32 arrayIdx) const
+	{
+		auto iterFind = mVec2Values.find(name);
+
+		if(iterFind == mVec2Values.end())
+			CM_EXCEPT(InternalErrorException, "No float parameter with the name: " + name);
+
+		return iterFind->second.at(arrayIdx);
+	}
+
+	Vector3 Material::getVec3(const String& name, UINT32 arrayIdx) const
+	{
+		auto iterFind = mVec3Values.find(name);
+
+		if(iterFind == mVec3Values.end())
+			CM_EXCEPT(InternalErrorException, "No float parameter with the name: " + name);
+
+		return iterFind->second.at(arrayIdx);
+	}
+
+	Vector4 Material::getVec4(const String& name, UINT32 arrayIdx) const
+	{
+		auto iterFind = mVec4Values.find(name);
+
+		if(iterFind == mVec4Values.end())
+			CM_EXCEPT(InternalErrorException, "No float parameter with the name: " + name);
+
+		return iterFind->second.at(arrayIdx);
+	}
+
+	Matrix3 Material::getMat3(const String& name, UINT32 arrayIdx) const
+	{
+		auto iterFind = mMat3Values.find(name);
+
+		if(iterFind == mMat3Values.end())
+			CM_EXCEPT(InternalErrorException, "No float parameter with the name: " + name);
+
+		return iterFind->second.at(arrayIdx);
+	}
+
+	Matrix4 Material::getMat4(const String& name, UINT32 arrayIdx) const
+	{
+		auto iterFind = mMat4Values.find(name);
+
+		if(iterFind == mMat4Values.end())
+			CM_EXCEPT(InternalErrorException, "No float parameter with the name: " + name);
+
+		return iterFind->second.at(arrayIdx);
+	}
+
 	RTTITypeBase* Material::getRTTIStatic()
 	{
 		return MaterialRTTI::instance();

CamelotRenderer/Source/CmMaterialRTTI.cpp

@@ -3,103 +3,164 @@
 
 namespace CamelotEngine
 {
-	RTTITypeBase* MaterialRTTI::MaterialParams::getRTTIStatic()
-	{
-		return MaterialParamsRTTI::instance();
-	}
+	RTTITypeBase* MaterialFloatParam::getRTTIStatic() { return MaterialFloatParamRTTI::instance(); }
+	RTTITypeBase* MaterialFloatParam::getRTTI() const { return MaterialFloatParam::getRTTIStatic(); }
 
-	RTTITypeBase* MaterialRTTI::MaterialParams::getRTTI() const
-	{
-		return MaterialParams::getRTTIStatic();
-	}
+	RTTITypeBase* MaterialVec2Param::getRTTIStatic() { return MaterialVec2ParamRTTI::instance(); }
+	RTTITypeBase* MaterialVec2Param::getRTTI() const { return MaterialVec2Param::getRTTIStatic(); }
 
-	void MaterialRTTI::onSerializationStarted(IReflectable* obj)
-	{
-		Material* material = static_cast<Material*>(obj);
-		std::shared_ptr<MaterialParams> params = std::shared_ptr<MaterialParams>(new MaterialParams());
+	RTTITypeBase* MaterialVec3Param::getRTTIStatic() { return MaterialVec3ParamRTTI::instance(); }
+	RTTITypeBase* MaterialVec3Param::getRTTI() const { return MaterialVec3Param::getRTTIStatic(); }
 
-		vector<GpuParamsPtr>::type allParams;
-		//for(size_t i = 0; i < material->mParameters.size(); i++)
-		//{
-		//	if(material->mParameters[i]->mFragParams != nullptr)
-		//		allParams.push_back(material->mParameters[i]->mFragParams);
+	RTTITypeBase* MaterialVec4Param::getRTTIStatic() { return MaterialVec4ParamRTTI::instance(); }
+	RTTITypeBase* MaterialVec4Param::getRTTI() const { return MaterialVec4Param::getRTTIStatic(); }
 
-		//	if(material->mParameters[i]->mVertParams != nullptr)
-		//		allParams.push_back(material->mParameters[i]->mVertParams);
+	RTTITypeBase* MaterialMat3Param::getRTTIStatic() { return MaterialMat3ParamRTTI::instance(); }
+	RTTITypeBase* MaterialMat3Param::getRTTI() const { return MaterialMat3Param::getRTTIStatic(); }
 
-		//	if(material->mParameters[i]->mGeomParams != nullptr)
-		//		allParams.push_back(material->mParameters[i]->mGeomParams);
-		//}
+	RTTITypeBase* MaterialMat4Param::getRTTIStatic() { return MaterialMat4ParamRTTI::instance(); }
+	RTTITypeBase* MaterialMat4Param::getRTTI() const { return MaterialMat4Param::getRTTIStatic(); }
 
-		for(size_t i = 0; i < allParams.size(); i++)
-		{
-			const GpuParamDesc& paramDesc = allParams[i]->getParamDesc();
+	RTTITypeBase* MaterialTextureParam::getRTTIStatic() { return MaterialTextureParamRTTI::instance(); }
+	RTTITypeBase* MaterialTextureParam::getRTTI() const { return MaterialTextureParam::getRTTIStatic(); }
 
-			for(auto iter = paramDesc.textures.begin(); iter != paramDesc.textures.end(); ++iter)
-			{
-				params->mTextureParams[iter->first] = allParams[i]->getTexture(iter->second.slot);
-			}
+	RTTITypeBase* MaterialSamplerStateParam::getRTTIStatic() { return MaterialSamplerStateParamRTTI::instance(); }
+	RTTITypeBase* MaterialSamplerStateParam::getRTTI() const { return MaterialSamplerStateParam::getRTTIStatic(); }
 
-			for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)
-			{
-				params->mSamplerStateParams[iter->first] = allParams[i]->getSamplerState(iter->second.slot);
-			}
+	RTTITypeBase* MaterialParams::getRTTIStatic() { return MaterialParamsRTTI::instance(); }
+	RTTITypeBase* MaterialParams::getRTTI() const { return MaterialParams::getRTTIStatic(); }
 
-			for(auto iter = paramDesc.params.begin(); iter != paramDesc.params.end(); ++iter)
-			{
-				// TODO - Need to save float/int/bool parameters!
-			}
+	void MaterialRTTI::onSerializationStarted(IReflectable* obj)
+	{
+		Material* material = static_cast<Material*>(obj);
+		std::shared_ptr<MaterialParams> params = std::shared_ptr<MaterialParams>(new MaterialParams());
 
-			/*const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
+		ShaderPtr shader = material->getShader();
+		if(shader != nullptr)
+		{
+			const set<String>::type& validParamNames = material->getValidParamNames();
 
-			float tempValue[16];
-			for(auto iter = namedConstants.map.begin(); iter != namedConstants.map.end(); ++iter)
+			for(auto iter = validParamNames.begin(); iter != validParamNames.end(); ++iter)
 			{
-				const GpuConstantDefinition& def = iter->second;
+				GpuParamType type = shader->getParamType(*iter);
 
-				if(def.constType == GCT_SAMPLER2D)
+				if(type == GPT_DATA)
 				{
-					TextureHandle texture;
-					allParams[i]->getTexture(iter->second.physicalIndex, texture);
-					params->mTextureParams[iter->first] = texture;
+					const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(*iter);
 
-					SamplerStatePtr samplerState = allParams[i]->getSamplerState(iter->second.physicalIndex);
-					params->mSamplerStateParams[iter->first] = samplerState;
-				}
-				else
-				{
-					UINT32 fieldSize = def.getElementSize(def.constType, false);
-					switch(def.constType)
+					switch(paramDesc.type)
 					{
-					case GCT_FLOAT1:
-					case GCT_FLOAT2:
-					case GCT_FLOAT3:
-					case GCT_FLOAT4:
-					case GCT_MATRIX_3X3:
-					case GCT_MATRIX_4X4:
-					case GCT_SAMPLER2D:
+					case GPDT_FLOAT1:
+						{
+							for(UINT32 i = 0; i < paramDesc.arraySize; i++)
+							{
+								MaterialFloatParam param;
+								param.name = *iter;
+								param.value = material->getFloat(*iter, i);
+								param.arrayIdx = i;
+
+								params->floatParams.push_back(param);
+							}
+						}
+						break;
+					case GPDT_FLOAT2:
+						{
+							for(UINT32 i = 0; i < paramDesc.arraySize; i++)
+							{
+								MaterialVec2Param param;
+								param.name = *iter;
+								param.value = material->getVec2(*iter, i);
+								param.arrayIdx = i;
+
+								params->vec2Params.push_back(param);
+							}
+						}
+						break;
+					case GPDT_FLOAT3:
+						{
+							for(UINT32 i = 0; i < paramDesc.arraySize; i++)
+							{
+								MaterialVec3Param param;
+								param.name = *iter;
+								param.value = material->getVec3(*iter, i);
+								param.arrayIdx = i;
+
+								params->vec3Params.push_back(param);
+							}
+						}
+						break;
+					case GPDT_FLOAT4:
+						{
+							for(UINT32 i = 0; i < paramDesc.arraySize; i++)
+							{
+								MaterialVec4Param param;
+								param.name = *iter;
+								param.value = material->getVec4(*iter, i);
+								param.arrayIdx = i;
+
+								params->vec4Params.push_back(param);
+							}
+						}
+						break;
+					case GPDT_MATRIX_3X3:
+						{
+							for(UINT32 i = 0; i < paramDesc.arraySize; i++)
+							{
+								MaterialMat3Param param;
+								param.name = *iter;
+								param.value = material->getMat3(*iter, i);
+								param.arrayIdx = i;
+
+								params->mat3Params.push_back(param);
+							}
+						}
+						break;
+					case GPDT_MATRIX_4X4:
+						{
+							for(UINT32 i = 0; i < paramDesc.arraySize; i++)
+							{
+								MaterialMat4Param param;
+								param.name = *iter;
+								param.value = material->getMat4(*iter, i);
+								param.arrayIdx = i;
+
+								params->mat4Params.push_back(param);
+							}
+						}
 						break;
 					default:
-						CM_EXCEPT(InternalErrorException, "Material parameter type not supported! Type: " + toString(def.constType));
+						CM_EXCEPT(InternalErrorException, "Cannot serialize this paramater type: " + toString(paramDesc.type));
 					}
+				}
+				else if(type == GPT_OBJECT)
+				{
+					const SHADER_OBJECT_PARAM_DESC& paramDesc = shader->getObjectParamDesc(*iter);
 
-					if(fieldSize > 16)
-						CM_EXCEPT(InternalErrorException, "Field size larger than the supported size.");
-
-					allParams[i]->_readRawConstants(iter->second.physicalIndex, fieldSize, tempValue);
-
-					auto iterFind = params->mFloatParams.find(iter->first);
-					if(iterFind == params->mFloatParams.end())
+					if(Shader::isSampler(paramDesc.type))
 					{
-						params->mFloatParams[iter->first] = FloatParam((UINT32)params->mFloatBuffer.size(), def.constType, fieldSize);
-
-						for(UINT32 j = 0; j < fieldSize; j++)
-							params->mFloatBuffer.push_back(tempValue[j]);
+						MaterialSamplerStateParam param;
+						param.name = *iter;
+						param.value = material->getSamplerState(*iter);
+					}
+					else if(Shader::isTexture(paramDesc.type))
+					{
+						MaterialTextureParam param;
+						param.name = *iter;
+						param.value = material->getTexture(*iter);
+					}
+					else if(Shader::isBuffer(paramDesc.type))
+					{
+						CM_EXCEPT(NotImplementedException, "Buffers can't be serialized yet."); // TODO
 					}
 					else
-						gDebug().logWarning("While saving material found multiple parameters with the same name. Only saving the first.");
+					{
+						CM_EXCEPT(InternalErrorException, "Cannot serialize this paramater type: " + toString(paramDesc.type));
+					}
 				}
-			}*/
+				else
+					CM_EXCEPT(InternalErrorException, "Invalid parameter type.");
+
+			}
 		}
 
 		material->mRTTIData = params;
@@ -127,86 +188,112 @@ namespace CamelotEngine
 
 		std::shared_ptr<MaterialParams> params = boost::any_cast<std::shared_ptr<MaterialParams>>(material->mRTTIData);
 
-		vector<GpuParamsPtr>::type allParams;
-		//for(size_t i = 0; i < material->mParameters.size(); i++)
-		//{
-		//	if(material->mParameters[i]->mFragParams != nullptr)
-		//		allParams.push_back(material->mParameters[i]->mFragParams);
+		ShaderPtr shader = material->getShader();
+		if(shader != nullptr)
+		{
+			for(auto iter = params->floatParams.begin(); iter != params->floatParams.end(); ++iter)
+			{
+				if(!shader->hasDataParam(iter->name))
+					continue;
 
-		//	if(material->mParameters[i]->mVertParams != nullptr)
-		//		allParams.push_back(material->mParameters[i]->mVertParams);
+				const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(iter->name);
 
-		//	if(material->mParameters[i]->mGeomParams != nullptr)
-		//		allParams.push_back(material->mParameters[i]->mGeomParams);
-		//}
+				if(paramDesc.type != GPDT_FLOAT1 || iter->arrayIdx < 0 || iter->arrayIdx >= paramDesc.arraySize)
+					continue;
 
-		for(size_t i = 0; i < allParams.size(); i++)
-		{
-			const GpuParamDesc& paramDesc = allParams[i]->getParamDesc();
+				material->setFloat(iter->name, iter->value, iter->arrayIdx);
+			}
 
-			for(auto iter = paramDesc.textures.begin(); iter != paramDesc.textures.end(); ++iter)
+			for(auto iter = params->vec2Params.begin(); iter != params->vec2Params.end(); ++iter)
 			{
-				auto iterFind = params->mTextureParams.find(iter->first);
+				if(!shader->hasDataParam(iter->name))
+					continue;
+
+				const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(iter->name);
+
+				if(paramDesc.type != GPDT_FLOAT2 || iter->arrayIdx < 0 || iter->arrayIdx >= paramDesc.arraySize)
+					continue;
 
-				if(iterFind != params->mTextureParams.end())
-					allParams[i]->setTexture(iter->first, iterFind->second);
+				material->setVec2(iter->name, iter->value, iter->arrayIdx);
 			}
 
-			for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)
+			for(auto iter = params->vec3Params.begin(); iter != params->vec3Params.end(); ++iter)
 			{
-				auto iterFind = params->mSamplerStateParams.find(iter->first);
+				if(!shader->hasDataParam(iter->name))
+					continue;
+
+				const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(iter->name);
+
+				if(paramDesc.type != GPDT_FLOAT3 || iter->arrayIdx < 0 || iter->arrayIdx >= paramDesc.arraySize)
+					continue;
 
-				if(iterFind != params->mSamplerStateParams.end())
-					allParams[i]->setSamplerState(iter->first, iterFind->second);
+				material->setVec3(iter->name, iter->value, iter->arrayIdx);
 			}
 
-			for(auto iter = paramDesc.params.begin(); iter != paramDesc.params.end(); ++iter)
+			for(auto iter = params->vec4Params.begin(); iter != params->vec4Params.end(); ++iter)
 			{
-				// TODO - Need to load float/int/bool parameters!
+				if(!shader->hasDataParam(iter->name))
+					continue;
+
+				const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(iter->name);
+
+				if(paramDesc.type != GPDT_FLOAT4 || iter->arrayIdx < 0 || iter->arrayIdx >= paramDesc.arraySize)
+					continue;
+
+				material->setVec4(iter->name, iter->value, iter->arrayIdx);
 			}
 
+			for(auto iter = params->mat3Params.begin(); iter != params->mat3Params.end(); ++iter)
+			{
+				if(!shader->hasDataParam(iter->name))
+					continue;
 
-			/*const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
+				const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(iter->name);
 
-			float tempValue[16];
-			for(auto iter = namedConstants.map.begin(); iter != namedConstants.map.end(); ++iter)
+				if(paramDesc.type != GPDT_MATRIX_3X3 || iter->arrayIdx < 0 || iter->arrayIdx >= paramDesc.arraySize)
+					continue;
+
+				material->setMat3(iter->name, iter->value, iter->arrayIdx);
+			}
+
+			for(auto iter = params->mat4Params.begin(); iter != params->mat4Params.end(); ++iter)
 			{
-				const GpuConstantDefinition& def = iter->second;
+				if(!shader->hasDataParam(iter->name))
+					continue;
 
-				if(def.constType == GCT_SAMPLER2D)
-				{
-					auto iterFind = params->mTextureParams.find(iter->first);
+				const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(iter->name);
 
-					if(iterFind != params->mTextureParams.end())
-						allParams[i]->setNamedConstant(iter->first, iterFind->second);
+				if(paramDesc.type != GPDT_MATRIX_4X4 || iter->arrayIdx < 0 || iter->arrayIdx >= paramDesc.arraySize)
+					continue;
 
-					auto iterFind2 = params->mSamplerStateParams.find(iter->first);
+				material->setMat4(iter->name, iter->value, iter->arrayIdx);
+			}
 
-					if(iterFind2 != params->mSamplerStateParams.end())
-						allParams[i]->setNamedConstant(iter->first, iterFind2->second);
-				}
-				else
-				{
-					auto iterFind = params->mFloatParams.find(iter->first);
+			for(auto iter = params->samplerStateParams.begin(); iter != params->samplerStateParams.end(); ++iter)
+			{
+				if(!shader->hasObjectParam(iter->name))
+					continue;
 
-					if(iterFind != params->mFloatParams.end() && iterFind->second.mType == def.constType)
-					{
-						FloatParam param = iterFind->second;
-						UINT32 fieldSize = def.getElementSize(def.constType, false);
+				const SHADER_OBJECT_PARAM_DESC& paramDesc = shader->getObjectParamDesc(iter->name);
 
-						if(fieldSize != param.mCount)
-							CM_EXCEPT(InternalErrorException, "Deserializing material parameter but field sizes don't match.");
+				if(!Shader::isSampler(paramDesc.type))
+					continue;
 
-						if(fieldSize > 16)
-							CM_EXCEPT(InternalErrorException, "Field size larger than the supported size.");
+				material->setSamplerState(iter->name, iter->value);
+			}
 
-						for(size_t j = 0; j < fieldSize; j++)
-							tempValue[j] = params->mFloatBuffer[param.mBufferIdx + j];
+			for(auto iter = params->textureParams.begin(); iter != params->textureParams.end(); ++iter)
+			{
+				if(!shader->hasObjectParam(iter->name))
+					continue;
 
-						allParams[i]->_writeRawConstants(def.physicalIndex, tempValue, fieldSize);
-					}
-				}
-			}*/
+				const SHADER_OBJECT_PARAM_DESC& paramDesc = shader->getObjectParamDesc(iter->name);
+
+				if(!Shader::isTexture(paramDesc.type))
+					continue;
+
+				material->setTexture(iter->name, iter->value);
+			}
 		}
 
 		material->mRTTIData = nullptr; // This will delete temporary data as it's stored in a unique ptr

CamelotRenderer/Source/CmShader.cpp

@@ -89,6 +89,55 @@ namespace CamelotEngine
 		mDataParams.erase(name);
 	}
 
+	GpuParamType Shader::getParamType(const String& name) const
+	{
+		auto findIterData = mDataParams.find(name);
+		if(findIterData != mDataParams.end())
+			return GPT_DATA;
+
+		auto findIterObject = mObjectParams.find(name);
+		if(findIterObject != mObjectParams.end())
+			return GPT_OBJECT;
+
+		CM_EXCEPT(InternalErrorException, "Cannot find the parameter with the name: " + name);
+	}
+
+	const SHADER_DATA_PARAM_DESC& Shader::getDataParamDesc(const String& name) const
+	{
+		auto findIterData = mDataParams.find(name);
+		if(findIterData != mDataParams.end())
+			return findIterData->second;
+
+		CM_EXCEPT(InternalErrorException, "Cannot find the parameter with the name: " + name);
+	}
+
+	const SHADER_OBJECT_PARAM_DESC& Shader::getObjectParamDesc(const String& name) const
+	{
+		auto findIterObject = mObjectParams.find(name);
+		if(findIterObject != mObjectParams.end())
+			return findIterObject->second;
+
+		CM_EXCEPT(InternalErrorException, "Cannot find the parameter with the name: " + name);
+	}
+
+	bool Shader::hasDataParam(const String& name) const
+	{
+		auto findIterData = mDataParams.find(name);
+		if(findIterData != mDataParams.end())
+			return true;
+
+		return false;
+	}
+
+	bool Shader::hasObjectParam(const String& name) const
+	{
+		auto findIterObject = mObjectParams.find(name);
+		if(findIterObject != mObjectParams.end())
+			return true;
+
+		return false;
+	}
+
 	void Shader::removeParameter(const String& name)
 	{
 		mDataParams.erase(name);
@@ -105,6 +154,55 @@ namespace CamelotEngine
 		mParamBlocks[name] = desc;
 	}
 
+	bool Shader::isSampler(GpuParamObjectType type)
+	{
+		switch(type)
+		{
+			case GPOT_SAMPLER1D:
+			case GPOT_SAMPLER2D:
+			case GPOT_SAMPLER3D:
+			case GPOT_SAMPLERCUBE:
+				return true;
+		}
+
+		return false;
+	}
+
+	bool Shader::isTexture(GpuParamObjectType type)
+	{
+		switch(type)
+		{
+		case GPOT_TEXTURE1D:
+		case GPOT_TEXTURE2D:
+		case GPOT_TEXTURE3D:
+		case GPOT_TEXTURECUBE:
+		case GPOT_RWTEXTURE1D:
+		case GPOT_RWTEXTURE2D:
+		case GPOT_RWTEXTURE3D:
+			return true;
+		}
+
+		return false;
+	}
+
+	bool Shader::isBuffer(GpuParamObjectType type)
+	{
+		switch(type)
+		{
+		case GPOT_BYTE_BUFFER:
+		case GPOT_STRUCTURED_BUFFER:
+		case GPOT_RWBYTE_BUFFER:
+		case GPOT_RWAPPEND_BUFFER:
+		case GPOT_RWCONSUME_BUFFER:
+		case GPOT_RWSTRUCTURED_BUFFER:
+		case GPOT_RWSTRUCTURED_BUFFER_WITH_COUNTER:
+		case GPOT_RWTYPED_BUFFER:
+			return true;
+		}
+
+		return false;
+	}
+
 	RTTITypeBase* Shader::getRTTIStatic()
 	{
 		return ShaderRTTI::instance();

CamelotRenderer/TODO.txt

@@ -50,6 +50,8 @@ Stuff that needs destroy():
   - Shader
   - Technique
 
+  Material RTTI should also serialize shared buffers (they need to be made into a resource)
+
 DX9 will have the same name for sampler and texture. This will cause an error in Material param checking.
 
 Add support for include file resource

CamelotUtility/CamelotUtility.vcxproj

@@ -87,6 +87,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>./Include;../Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_UTILITY_EXPORTS</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -105,6 +106,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>./Include;../Dependencies/Include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_UTILITY_EXPORTS</PreprocessorDefinitions>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -125,6 +127,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>CM_UTILITY_EXPORTS</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>./Include;../Dependencies/Include</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -144,6 +147,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>CM_UTILITY_EXPORTS</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>./Include;../Dependencies/Include</AdditionalIncludeDirectories>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>