New shader param system actually works with DX9

CamelotClient/CamelotClient.cpp

@@ -50,37 +50,14 @@ int _tmain(int argc, _TCHAR* argv[])
 	HighLevelGpuProgramPtr vertProg;
 
 	/////////////////// HLSL 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);
-
-	/////////////////// CG SHADERS //////////////////////////
-	String fragShaderCode = "sampler2D tex;					\
+	String fragShaderCode = "sampler2D tex;			\
 							float4 ps_main(float2 uv : TEXCOORD0) : COLOR0		\
 							{														\
-							float4 color = tex2D(tex, uv);						\
+							float4 color = tex2D(tex, uv);				\
 							return color;										\
 							}";
 
-	fragProg =  HighLevelGpuProgram::create(fragShaderCode, "ps_main", "cg", GPT_FRAGMENT_PROGRAM, GPP_PS_2_0);
+	fragProg =  HighLevelGpuProgram::create(fragShaderCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_PS_2_0);
 
 	String vertShaderCode = "float4x4 matViewProjection;	\
 							void vs_main(										\
@@ -93,7 +70,30 @@ int _tmain(int argc, _TCHAR* argv[])
 							oUv = uv;											\
 							}";
 
-	vertProg =  HighLevelGpuProgram::create(vertShaderCode, "vs_main", "cg", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
+	vertProg =  HighLevelGpuProgram::create(vertShaderCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
+
+	/////////////////// CG 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", "cg", 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", "cg", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
 
 	///////////////// GLSL SHADERS ////////////////////////////
 	//String fragShaderCode = "uniform sampler2D tex; \

CamelotD3D9Renderer/Include/CmD3D9GpuProgram.h

@@ -82,7 +82,7 @@ namespace CamelotEngine {
             populate any implementation-specific extras (like named parameters) where
             they are appropriate.
         */
-        virtual void createParameters_internal(AsyncOp& op);
+        virtual GpuParamsPtr createParameters();
 	protected:    
 		bool mColumnMajorMatrices;
 		ID3DXBuffer* mpExternalMicrocode;

CamelotD3D9Renderer/Include/CmD3D9HLSLProgram.h

@@ -81,7 +81,7 @@ namespace CamelotEngine {
         /// Overridden from GpuProgram
         bool isSupported(void) const;
         /// Overridden from GpuProgram
-        void createParameters_internal(AsyncOp& op);
+        GpuParamsPtr createParameters();
         /// Overridden from GpuProgram
         const String& getLanguage(void) const;
 

CamelotD3D9Renderer/Source/CmD3D9GpuProgram.cpp

@@ -30,6 +30,7 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmD3D9Mappings.h"
 #include "CmD3D9RenderSystem.h"
+#include "CmGpuParams.h"
 #include "CmAsyncOp.h"
 
 namespace CamelotEngine {
@@ -158,16 +159,13 @@ namespace CamelotEngine {
 		SAFE_RELEASE(errors);
 	}
     //-----------------------------------------------------------------------
-    void D3D9GpuProgram::createParameters_internal(AsyncOp& op)
-    {
-        // Call superclass
-        GpuProgram::createParameters_internal(op);
-
-		GpuProgramParametersSharedPtr params = op.getReturnValue<GpuProgramParametersSharedPtr>();
+	GpuParamsPtr D3D9GpuProgram::createParameters()
+	{
+		GpuParamsPtr params(new GpuParams(mParametersDesc));
+		params->setTransposeMatrices(mColumnMajorMatrices);
 
-        // Need to transpose matrices if compiled with column-major matrices
-        params->setTransposeMatrices(mColumnMajorMatrices);
-    }	
+		return params;
+	}
 	//-----------------------------------------------------------------------------
 	D3D9GpuVertexProgram::D3D9GpuVertexProgram(const String& source, const String& entryPoint, const String& language, GpuProgramType gptype, GpuProgramProfile profile) 
         : D3D9GpuProgram(source, entryPoint, language, gptype, profile)       

CamelotD3D9Renderer/Source/CmD3D9HLSLProgram.cpp

@@ -31,6 +31,7 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmRenderSystem.h"
 #include "CmAsyncOp.h"
+#include "CmGpuParams.h"
 #include "CmD3D9HLSLProgramRTTI.h"
 
 namespace CamelotEngine {
@@ -337,6 +338,7 @@ namespace CamelotEngine {
 				} // columns
 				break;
 			}
+			break;
 		case D3DXPT_BOOL:
 			memberDesc.type = GMT_BOOL;
 			memberDesc.elementSize = 1;
@@ -505,6 +507,9 @@ namespace CamelotEngine {
 				GPP_NONE);
 			static_cast<D3D9GpuProgram*>(mAssemblerProgram.get())->setExternalMicrocode(mpMicroCode);
 		}
+
+		D3D9HLSLParamParser paramParser(mpConstTable);
+		mParametersDesc = paramParser.buildParameterDescriptions();
     }
     //-----------------------------------------------------------------------
     void D3D9HLSLProgram::unload_internal(void)
@@ -805,17 +810,14 @@ namespace CamelotEngine {
 		RenderSystem* rs = CamelotEngine::RenderSystem::instancePtr();
 		return rs->getCapabilities()->isShaderProfileSupported(hlslProfile);
     }
-    //-----------------------------------------------------------------------
-    void D3D9HLSLProgram::createParameters_internal(AsyncOp& op)
-    {
-        // Call superclass
-       HighLevelGpuProgram::createParameters_internal(op);
-
-	    GpuProgramParametersSharedPtr params = op.getReturnValue<GpuProgramParametersSharedPtr>();
+	//-----------------------------------------------------------------------
+	GpuParamsPtr D3D9HLSLProgram::createParameters()
+	{
+		GpuParamsPtr params(new GpuParams(mParametersDesc));
+		params->setTransposeMatrices(mColumnMajorMatrices);
 
-        // Need to transpose matrices if compiled with column-major matrices
-        params->setTransposeMatrices(mColumnMajorMatrices);
-    }
+		return params;
+	}
     //-----------------------------------------------------------------------
     const String& D3D9HLSLProgram::getLanguage(void) const
     {

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -458,6 +458,8 @@ namespace CamelotEngine
 	{
 		THROW_IF_NOT_RENDER_THREAD;
 
+		params->updateIfDirty();
+
 		const GpuParamDesc& paramDesc = params->getParamDesc();
 
 		for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)

CamelotForwardRenderer/Source/CmForwardRenderer.cpp

@@ -167,14 +167,14 @@ namespace CamelotEngine
 
 		GpuProgramHandle vertProgram = mActivePass->getVertexProgram();
 		if(vertProgram)
-			renderContext->bindGpuProgramParameters(GPT_VERTEX_PROGRAM, params->mVertParams, GPV_ALL);
+			renderContext->bindGpuParams(GPT_VERTEX_PROGRAM, params->mVertParams);
 
 		GpuProgramHandle fragProgram = mActivePass->getFragmentProgram();
 		if(fragProgram)
-			renderContext->bindGpuProgramParameters(GPT_FRAGMENT_PROGRAM, params->mFragParams, GPV_ALL);
+			renderContext->bindGpuParams(GPT_FRAGMENT_PROGRAM, params->mFragParams);
 
 		GpuProgramHandle geomProgram = mActivePass->getGeometryProgram();
 		if(geomProgram)
-			renderContext->bindGpuProgramParameters(GPT_GEOMETRY_PROGRAM, params->mGeomParams, GPV_ALL);
+			renderContext->bindGpuParams(GPT_GEOMETRY_PROGRAM, params->mGeomParams);
 	}
 }

CamelotRenderer.sln

@@ -17,8 +17,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CamelotClient", "CamelotCli
 	ProjectSection(ProjectDependencies) = postProject
 		{9B21D41C-516B-43BF-9B10-E99B599C7589} = {9B21D41C-516B-43BF-9B10-E99B599C7589}
 		{122B7A22-0C62-4B35-B661-EBF3F394EA79} = {122B7A22-0C62-4B35-B661-EBF3F394EA79}
-		{1437BB4E-DDB3-4307-AA41-8C035DA3014B} = {1437BB4E-DDB3-4307-AA41-8C035DA3014B}
-		{F58FF869-2EA6-4FFF-AB84-328C531BA9D9} = {F58FF869-2EA6-4FFF-AB84-328C531BA9D9}
 		{08975177-4A13-4EE7-BB21-3BB92FB3F3CC} = {08975177-4A13-4EE7-BB21-3BB92FB3F3CC}
 		{7F449698-73DF-4203-9F31-0877DBF01695} = {7F449698-73DF-4203-9F31-0877DBF01695}
 		{BFEBBAF8-8A84-4899-8899-D0D7196AF9A1} = {BFEBBAF8-8A84-4899-8899-D0D7196AF9A1}

CamelotRenderer/Include/CmDeferredRenderContext.h

@@ -75,6 +75,8 @@ namespace CamelotEngine
 		void bindGpuProgramParameters(GpuProgramType gptype, GpuProgramParametersSharedPtr params, UINT16 variabilityMask);
 		/** @copydoc RenderSystem::unbindGpuProgram() */
 		void unbindGpuProgram(GpuProgramType gptype);
+		/** @copydoc RenderSystem::bindGpuParams() */
+		void bindGpuParams(GpuProgramType gptype, GpuParamsPtr params);
 
 		/** @copydoc RenderSystem::beginFrame() */
 		void beginFrame(void);

CamelotRenderer/Include/CmGpuParamBlock.h

@@ -16,6 +16,8 @@ namespace CamelotEngine
 		const UINT8* getDataPtr(UINT32 offset) const;
 
 		virtual void updateIfDirty();
+
+		virtual GpuParamBlockPtr clone() const;
 		
 		static GpuParamBlockPtr create(const GpuParamBlockDesc& desc);
 	private:

CamelotRenderer/Include/CmGpuParams.h

@@ -50,6 +50,9 @@ namespace CamelotEngine
 
 		void setTransposeMatrices(bool transpose) { mTransposeMatrices = transpose; }
 
+		GpuParamsPtr clone() const;
+		void updateIfDirty();
+
 	private:
 		GpuParamDesc& mParamDesc;
 		bool mTransposeMatrices;

CamelotRenderer/Include/CmGpuProgram.h

@@ -184,8 +184,7 @@ namespace CamelotEngine {
             populate any implementation-specific extras (like named parameters) where
             they are appropriate.
         */
-		GpuProgramParametersSharedPtr createParameters(void);
-        virtual void createParameters_internal(AsyncOp& op);
+		virtual GpuParamsPtr createParameters();
 
 		/** Returns a string that specifies the language of the gpu programs as specified
         in a material script. ie: asm, cg, hlsl, glsl

CamelotRenderer/Include/CmHighLevelGpuProgram.h

@@ -83,15 +83,6 @@ namespace CamelotEngine {
 		 */
 		virtual void unload_internal();
 
-        /** Creates a new parameters object compatible with this program definition. 
-        @remarks
-            Unlike low-level assembly programs, parameters objects are specific to the
-            program and therefore must be created from it rather than by the 
-            HighLevelGpuProgramManager. This method creates a new instance of a parameters
-            object containing the definition of the parameters this program understands.
-        */
-        void createParameters_internal(AsyncOp& op);
-
         /** @copydoc GpuProgram::getBindingDelegate */
         GpuProgram* getBindingDelegate_internal(void) { return mAssemblerProgram.get(); }
 

CamelotRenderer/Include/CmMaterial.h

@@ -2,15 +2,16 @@
 
 #include "CmPrerequisites.h"
 #include "CmResource.h"
+#include "CmGpuParams.h"
 
 namespace CamelotEngine
 {
 	class CM_EXPORT PassParameters
 	{
 	public:
-		GpuProgramParametersPtr mVertParams;
-		GpuProgramParametersPtr mFragParams;
-		GpuProgramParametersPtr mGeomParams;
+		GpuParamsPtr mVertParams;
+		GpuParamsPtr mFragParams;
+		GpuParamsPtr mGeomParams;
 	};
 
 	class CM_EXPORT Material : public Resource
@@ -36,6 +37,7 @@ 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);
@@ -66,20 +68,20 @@ namespace CamelotEngine
 
 				if(params->mVertParams)
 				{
-					if(params->mVertParams->hasNamedConstant(name))
-						params->mVertParams->setNamedConstant(name, value);
+					if(params->mVertParams->hasParam(name))
+						params->mVertParams->setParam(name, value);
 				}
 
 				if(params->mFragParams)
 				{
-					if(params->mFragParams->hasNamedConstant(name))
-						params->mFragParams->setNamedConstant(name, value);
+					if(params->mFragParams->hasParam(name))
+						params->mFragParams->setParam(name, value);
 				}
 
 				if(params->mGeomParams)
 				{
-					if(params->mGeomParams->hasNamedConstant(name))
-						params->mGeomParams->setNamedConstant(name, value);
+					if(params->mGeomParams->hasParam(name))
+						params->mGeomParams->setParam(name, value);
 				}
 			}
 		}

CamelotRenderer/Include/CmMaterialRTTI.h

@@ -9,6 +9,7 @@
 #include "CmMatrix4.h"
 #include "CmMaterial.h"
 #include "CmGpuProgramParams.h"
+#include "CmGpuParams.h"
 #include "CmShader.h"
 #include "CmDebug.h"
 #include "CmException.h"

CamelotRenderer/Include/CmRenderSystem.h

@@ -246,6 +246,12 @@ namespace CamelotEngine
 		virtual void bindGpuProgramParameters(GpuProgramType gptype, 
 			GpuProgramParametersSharedPtr params, UINT16 variabilityMask) = 0;
 
+		/** Bind Gpu program parameters.
+		@param gptype The type of program to bind the parameters to
+		@param params The parameters to bind
+		*/
+		virtual void bindGpuParams(GpuProgramType gptype, GpuParamsPtr params) = 0;
+
 		/** Unbinds GpuPrograms of a given GpuProgramType.
 		@remarks
 		This returns the pipeline to fixed-function processing for this type.

CamelotRenderer/Source/CmDeferredRenderContext.cpp

@@ -4,6 +4,7 @@
 #include "CmBlendState.h"
 #include "CmRasterizerState.h"
 #include "CmDepthStencilState.h"
+#include "CmGpuParams.h"
 
 namespace CamelotEngine
 {
@@ -123,6 +124,12 @@ namespace CamelotEngine
 		mCommandQueue->queue(boost::bind(&RenderSystem::bindGpuProgramParameters, mRenderSystem, gptype, paramCopy, variabilityMask));
 	}
 
+	void DeferredRenderContext::bindGpuParams(GpuProgramType gptype, GpuParamsPtr params)
+	{
+		GpuParamsPtr paramCopy = params->clone();
+		mCommandQueue->queue(boost::bind(&RenderSystem::bindGpuParams, mRenderSystem, gptype, paramCopy));
+	}
+
 	void DeferredRenderContext::setRenderTarget(RenderTarget* target)
 	{
 		mCommandQueue->queue(boost::bind(&RenderSystem::setRenderTarget, mRenderSystem, target));

CamelotRenderer/Source/CmGpuParamBlock.cpp

@@ -6,7 +6,7 @@
 namespace CamelotEngine
 {
 	GpuParamBlock::GpuParamBlock(const GpuParamBlockDesc& desc)
-		:mSize(desc.blockSize), mDirty(true)
+		:mSize(desc.blockSize * sizeof(UINT32)), mDirty(true)
 	{
 		mData = new UINT8[desc.blockSize];
 		memset(mData, 0, desc.blockSize);
@@ -20,7 +20,7 @@ namespace CamelotEngine
 	void GpuParamBlock::write(UINT32 offset, const void* data, UINT32 size)
 	{
 #if CM_DEBUG_MODE
-		if(offset < 0 || (offset + size) >= mSize)
+		if(offset < 0 || (offset + size) > mSize)
 		{
 			CM_EXCEPT(InvalidParametersException, "Wanted range is out of buffer bounds. " \
 				"Available range: 0 .. " + toString(mSize) + ". " \
@@ -36,7 +36,7 @@ namespace CamelotEngine
 	void GpuParamBlock::zeroOut(UINT32 offset, UINT32 size)
 	{
 #if CM_DEBUG_MODE
-		if(offset < 0 || (offset + size) >= mSize)
+		if(offset < 0 || (offset + size) > mSize)
 		{
 			CM_EXCEPT(InvalidParametersException, "Wanted range is out of buffer bounds. " \
 				"Available range: 0 .. " + toString(mSize) + ". " \
@@ -65,9 +65,20 @@ namespace CamelotEngine
 
 	void GpuParamBlock::updateIfDirty()
 	{
+		mDirty = false;
+
 		// Do nothing
 	}
 
+	GpuParamBlockPtr GpuParamBlock::clone() const
+	{
+		GpuParamBlockPtr clonedParamBlock(new GpuParamBlock(*this));
+		clonedParamBlock->mData = new UINT8[mSize];
+		memcpy(clonedParamBlock->mData, mData, mSize);
+
+		return clonedParamBlock;
+	}
+
 	GpuParamBlockPtr GpuParamBlock::create(const GpuParamBlockDesc& desc)
 	{
 		return HardwareBufferManager::instance().createGpuParamBlock(desc);

CamelotRenderer/Source/CmGpuParams.cpp

@@ -262,6 +262,25 @@ namespace CamelotEngine
 		return mSamplerStates[slot];
 	}
 
+	GpuParamsPtr GpuParams::clone() const
+	{
+		GpuParamsPtr clonedParams(new GpuParams(*this));
+		
+		for(size_t i = 0; i < mParamBlocks.size(); i++)
+		{
+			if(mParamBlocks[i] != nullptr)
+				clonedParams->mParamBlocks[i] = mParamBlocks[i]->clone();
+		}
+
+		return clonedParams;
+	}
+
+	void GpuParams::updateIfDirty()
+	{
+		for(size_t i = 0; i < mParamBlocks.size(); i++)
+			mParamBlocks[i]->updateIfDirty();
+	}
+
 	GpuParamMemberDesc* GpuParams::getParamDesc(const String& name) const
 	{
 		auto paramIter = mParamDesc.params.find(name);

CamelotRenderer/Source/CmGpuProgram.cpp

@@ -33,6 +33,7 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmRenderSystem.h"
 #include "CmAsyncOp.h"
+#include "CmGpuParams.h"
 #include "CmGpuProgramRTTI.h"
 
 #if CM_DEBUG_MODE
@@ -125,30 +126,10 @@ namespace CamelotEngine
 			mConstantDefs = GpuNamedConstantsPtr(new GpuNamedConstants());
 	}
 	//---------------------------------------------------------------------
-	GpuProgramParametersSharedPtr GpuProgram::createParameters(void)
+	GpuParamsPtr GpuProgram::createParameters(void)
 	{
-		AsyncOp op = RenderSystem::instancePtr()->queueReturnCommand(boost::bind(&GpuProgram::createParameters_internal, this, _1), true);
-
-		return op.getReturnValue<GpuProgramParametersSharedPtr>();
+		return GpuParamsPtr(new GpuParams(mParametersDesc));
 	}
-    //-----------------------------------------------------------------------------
-    void GpuProgram::createParameters_internal(AsyncOp& op)
-    {
-		THROW_IF_NOT_RENDER_THREAD
-
-        // Default implementation simply returns standard parameters.
-        GpuProgramParametersSharedPtr ret = GpuProgramParametersSharedPtr(new GpuProgramParameters());	
-		
-		// set up named parameters, if any
-		if ((mConstantDefs != nullptr) && !mConstantDefs->map.empty())
-		{
-			ret->_setNamedConstants(mConstantDefs);
-		}
-		// link shared logical / physical map for low-level use
-		ret->_setLogicalIndexes(mFloatLogicalToPhysical, mIntLogicalToPhysical, mSamplerLogicalToPhysical, mTextureLogicalToPhysical);
-
-		op.completeOperation(ret);
-    }
     //-----------------------------------------------------------------------
     const String& GpuProgram::getLanguage(void) const
     {

CamelotRenderer/Source/CmHighLevelGpuProgram.cpp

@@ -87,21 +87,6 @@ namespace CamelotEngine
     HighLevelGpuProgram::~HighLevelGpuProgram()
     {
         // superclasses will trigger unload
-    }
-    //---------------------------------------------------------------------------
-    void HighLevelGpuProgram::createParameters_internal(AsyncOp& op)
-    {
-		THROW_IF_NOT_RENDER_THREAD
-
-        // Make sure param defs are loaded
-        GpuProgramParametersSharedPtr params = GpuProgramParametersSharedPtr(new GpuProgramParameters());
-		// Only populate named parameters if we can support this program
-		if (this->isSupported())
-		{
-			populateParameterNames(params);
-		}
-
-		op.completeOperation(params);
     }
 	//---------------------------------------------------------------------
 	const GpuNamedConstants& HighLevelGpuProgram::getConstantDefinitions_internal() const

CamelotRenderer/Source/CmMaterial.cpp

@@ -88,7 +88,57 @@ namespace CamelotEngine
 	void Material::setTexture(const String& name, TextureHandle& value)
 	{
 		throwIfNotInitialized();
-		setParam(name, value);
+
+		for(auto iter = mParameters.begin(); iter != mParameters.end(); ++iter)
+		{
+			PassParametersPtr params = *iter;
+
+			if(params->mVertParams)
+			{
+				if(params->mVertParams->hasTexture(name))
+					params->mVertParams->setTexture(name, value);
+			}
+
+			if(params->mFragParams)
+			{
+				if(params->mFragParams->hasTexture(name))
+					params->mFragParams->setTexture(name, value);
+			}
+
+			if(params->mGeomParams)
+			{
+				if(params->mGeomParams->hasTexture(name))
+					params->mGeomParams->setTexture(name, value);
+			}
+		}
+	}
+
+	void Material::setSamplerState(const String& name, SamplerStatePtr samplerState)
+	{
+		throwIfNotInitialized();
+
+		for(auto iter = mParameters.begin(); iter != mParameters.end(); ++iter)
+		{
+			PassParametersPtr params = *iter;
+
+			if(params->mVertParams)
+			{
+				if(params->mVertParams->hasSamplerState(name))
+					params->mVertParams->setSamplerState(name, samplerState);
+			}
+
+			if(params->mFragParams)
+			{
+				if(params->mFragParams->hasSamplerState(name))
+					params->mFragParams->setSamplerState(name, samplerState);
+			}
+
+			if(params->mGeomParams)
+			{
+				if(params->mGeomParams->hasSamplerState(name))
+					params->mGeomParams->setSamplerState(name, samplerState);
+			}
+		}
 	}
 
 	void Material::setFloat(const String& name, float value)

CamelotRenderer/Source/CmMaterialRTTI.cpp

@@ -1,4 +1,5 @@
 #include "CmMaterialRTTI.h"
+#include "CmGpuParamDesc.h"
 
 namespace CamelotEngine
 {
@@ -17,7 +18,7 @@ namespace CamelotEngine
 		Material* material = static_cast<Material*>(obj);
 		std::shared_ptr<MaterialParams> params = std::shared_ptr<MaterialParams>(new MaterialParams());
 
-		vector<GpuProgramParametersPtr>::type allParams;
+		vector<GpuParamsPtr>::type allParams;
 		for(size_t i = 0; i < material->mParameters.size(); i++)
 		{
 			if(material->mParameters[i]->mFragParams != nullptr)
@@ -32,7 +33,24 @@ namespace CamelotEngine
 
 		for(size_t i = 0; i < allParams.size(); i++)
 		{
-			const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
+			const GpuParamDesc& paramDesc = allParams[i]->getParamDesc();
+
+			for(auto iter = paramDesc.textures.begin(); iter != paramDesc.textures.end(); ++iter)
+			{
+				params->mTextureParams[iter->first] = allParams[i]->getTexture(iter->second.slot);
+			}
+
+			for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)
+			{
+				params->mSamplerStateParams[iter->first] = allParams[i]->getSamplerState(iter->second.slot);
+			}
+
+			for(auto iter = paramDesc.params.begin(); iter != paramDesc.params.end(); ++iter)
+			{
+				// TODO - Need to save float/int/bool parameters!
+			}
+
+			/*const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
 
 			float tempValue[16];
 			for(auto iter = namedConstants.map.begin(); iter != namedConstants.map.end(); ++iter)
@@ -42,7 +60,7 @@ namespace CamelotEngine
 				if(def.constType == GCT_SAMPLER2D)
 				{
 					TextureHandle texture;
-					allParams[i]->_readTexture(iter->second.physicalIndex, texture);
+					allParams[i]->getTexture(iter->second.physicalIndex, texture);
 					params->mTextureParams[iter->first] = texture;
 
 					SamplerStatePtr samplerState = allParams[i]->getSamplerState(iter->second.physicalIndex);
@@ -81,7 +99,7 @@ namespace CamelotEngine
 					else
 						gDebug().logWarning("While saving material found multiple parameters with the same name. Only saving the first.");
 				}
-			}
+			}*/
 		}
 
 		material->mRTTIData = params;
@@ -109,7 +127,7 @@ namespace CamelotEngine
 
 		std::shared_ptr<MaterialParams> params = boost::any_cast<std::shared_ptr<MaterialParams>>(material->mRTTIData);
 
-		vector<GpuProgramParametersPtr>::type allParams;
+		vector<GpuParamsPtr>::type allParams;
 		for(size_t i = 0; i < material->mParameters.size(); i++)
 		{
 			if(material->mParameters[i]->mFragParams != nullptr)
@@ -124,7 +142,31 @@ namespace CamelotEngine
 
 		for(size_t i = 0; i < allParams.size(); i++)
 		{
-			const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
+			const GpuParamDesc& paramDesc = allParams[i]->getParamDesc();
+
+			for(auto iter = paramDesc.textures.begin(); iter != paramDesc.textures.end(); ++iter)
+			{
+				auto iterFind = params->mTextureParams.find(iter->first);
+
+				if(iterFind != params->mTextureParams.end())
+					allParams[i]->setTexture(iter->first, iterFind->second);
+			}
+
+			for(auto iter = paramDesc.samplers.begin(); iter != paramDesc.samplers.end(); ++iter)
+			{
+				auto iterFind = params->mSamplerStateParams.find(iter->first);
+
+				if(iterFind != params->mSamplerStateParams.end())
+					allParams[i]->setSamplerState(iter->first, iterFind->second);
+			}
+
+			for(auto iter = paramDesc.params.begin(); iter != paramDesc.params.end(); ++iter)
+			{
+				// TODO - Need to load float/int/bool parameters!
+			}
+
+
+			/*const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
 
 			float tempValue[16];
 			for(auto iter = namedConstants.map.begin(); iter != namedConstants.map.end(); ++iter)
@@ -164,7 +206,7 @@ namespace CamelotEngine
 						allParams[i]->_writeRawConstants(def.physicalIndex, tempValue, fieldSize);
 					}
 				}
-			}
+			}*/
 		}
 
 		material->mRTTIData = nullptr; // This will delete temporary data as it's stored in a unique ptr