port from perforce

aiwaz/Aiwaz/Resources/ShaderParameterCollection/BasisParameterCollection.cpp

@@ -0,0 +1,79 @@
+#include "stdafx.h"
+#include "IShader.h"
+#include "BasisParameterCollection.h"
+
+
+BasisShaderParameterCollection::BasisShaderParameterCollection()
+{
+}
+
+
+BasisShaderParameterCollection::~BasisShaderParameterCollection()
+{
+	this->RemoveAllShaderParameters();
+}
+
+
+void BasisShaderParameterCollection::UseParametersOnShader(IShader& argShader)
+{
+	if (m_ParameterMap.empty())
+		return;
+
+	tk_ShaderToShaderParameter::iterator shaderPos = m_ShaderToParameterMap.find(argShader.get_InternalShader());
+	if (shaderPos == m_ShaderToParameterMap.end())
+	{
+		tk_ShaderParameterPairs newSet;
+
+		// (re)create shader entries
+		tk_StringToShaderParameter::iterator iter = m_ParameterMap.begin();
+		for (; iter != m_ParameterMap.end(); ++iter)
+		{
+			if (iter->second != NULL)
+			{
+				ID3D10EffectVariable* var = NULL;
+				if (iter->second->get_ParameterNameType() == ParameterBindType::BindByVariable)
+					var = argShader.get_InternalShader()->get_DX10Effect()->GetVariableByName(iter->first.c_str());
+				else if (iter->second->get_ParameterNameType() == ParameterBindType::BindBySemantic)
+					var = argShader.get_InternalShader()->get_DX10Effect()->GetVariableBySemantic(iter->first.c_str());
+				
+				if (var != NULL)
+					newSet.push_back(ShaderParameterPair(*iter->second, var));
+			}
+		}
+
+		if (newSet.empty())
+			return;
+
+		m_ShaderToParameterMap[argShader.get_InternalShader()] = newSet;
+	}
+
+	tk_ShaderParameterPairs& set = m_ShaderToParameterMap[argShader.get_InternalShader()];
+	for (uint32 i = 0; i < set.size(); ++i)
+		set[i].Parameter->ApplyValue(*set[i].TargetVariable);
+}
+
+
+void BasisShaderParameterCollection::SetShaderParameter(const string8& argParameterName, IShaderParameter& argParameter)
+{
+	this->RemoveShaderParameter(argParameterName);
+	m_ParameterMap[argParameterName] = &argParameter;
+}
+
+
+void BasisShaderParameterCollection::RemoveShaderParameter(const string8& argParameterName)
+{
+	m_ShaderToParameterMap.clear();
+	tk_StringToShaderParameter::iterator found = m_ParameterMap.find(argParameterName);
+	if (found != m_ParameterMap.end())
+		m_ParameterMap.erase(found);
+}
+
+
+void BasisShaderParameterCollection::RemoveAllShaderParameters()
+{
+	while (!m_ParameterMap.empty())
+	{
+		delete m_ParameterMap.begin()->second;
+		m_ParameterMap.erase(m_ParameterMap.begin());
+	}
+}

aiwaz/Aiwaz/Resources/ShaderParameterCollection/BasisParameterCollection.h

@@ -0,0 +1,38 @@
+#include "IShaderParameterCollection.h"
+
+
+struct ID3D10EffectVariable;
+struct IShader;
+struct IInternalShader;
+struct IShaderParameter;
+class BasisShaderParameterCollection
+{
+public:
+	BasisShaderParameterCollection();
+	~BasisShaderParameterCollection();
+
+	void UseParametersOnShader(IShader& argShader);
+	void SetShaderParameter(const string8& argParameterName, IShaderParameter& argParameter);
+	void RemoveShaderParameter(const string8& argParameterName);
+	void RemoveAllShaderParameters();
+
+protected:
+
+	struct ShaderParameterPair
+	{
+		ShaderParameterPair(IShaderParameter& argShaderParameter, ID3D10EffectVariable* ar_EffectVariable_)
+			: Parameter(&argShaderParameter)
+			, TargetVariable(ar_EffectVariable_)
+		{}
+
+		IShaderParameter* Parameter;
+		ID3D10EffectVariable* TargetVariable;
+	};
+
+	typedef std::map<string8, IShaderParameter*> tk_StringToShaderParameter;
+	typedef std::vector<ShaderParameterPair> tk_ShaderParameterPairs;
+	typedef std::map<IInternalShader*, tk_ShaderParameterPairs> tk_ShaderToShaderParameter;
+
+	tk_ShaderToShaderParameter m_ShaderToParameterMap;
+	tk_StringToShaderParameter m_ParameterMap;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/ShaderParameterCollection.cpp

@@ -0,0 +1,162 @@
+#include "stdafx.h"
+#include "ShaderParameterCollection.h"
+#include "IEngine.h"
+#include "IResourceFactory.h"
+
+#include "Types/Types.h"
+
+
+ShaderParameterCollection::ShaderParameterCollection(IEngine& argEngine, unsigned char argBasePriority)
+	: m_Engine(argEngine)
+	, m_BasePriority(argBasePriority)
+{
+	this->set_IsPreconditionForFollowingShaders(false);
+}
+
+
+ShaderParameterCollection::~ShaderParameterCollection()
+{
+	this->Uninitialize();
+	m_Engine.get_ResourceFactory().DeleteShaderParameterCollection(*const_cast<ShaderParameterCollection*>(this), true);
+}
+
+
+void ShaderParameterCollection::Uninitialize()
+{
+	m_BasisShaderParameterCollection.RemoveAllShaderParameters();
+}
+
+
+bool ShaderParameterCollection::get_IsPreconditionForFollowingShaders() const
+{
+	return m_IsPreconditionForFollowingShaders;
+}
+
+
+void ShaderParameterCollection::set_IsPreconditionForFollowingShaders(bool argValue)
+{
+	if (!m_Commands.empty() && argValue == m_IsPreconditionForFollowingShaders)
+		return;
+
+	m_IsPreconditionForFollowingShaders = argValue;
+
+	while (!m_Commands.empty())
+	{
+		delete m_Commands[0];
+		m_Commands.erase(m_Commands.begin());
+	}
+
+	if (m_IsPreconditionForFollowingShaders)
+		m_Commands.push_back(new Command(this, CommandFlags::EndChain | CommandFlags::FlushChain, SetFollowingShaderParameterCollectionCommandType, 0));
+	else
+		m_Commands.push_back(new Command(this, CommandFlags::None, SetShaderParameterCollectionCommandType, m_BasePriority));
+
+	this->MarkCommandsAsDirty();
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, IShaderParameter* ar_Parameter_)
+{
+	m_BasisShaderParameterCollection.SetShaderParameter(argParameterName, *ar_Parameter_);
+	//this->MarkCommandsAsDirty();
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, ITexture& argParameter, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new TextureShaderParameter(argParameter, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, float* af_Parameter_, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new FloatShaderParameter(af_Parameter_, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, float argParameter, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new FloatShaderParameter(argParameter, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, D3DXVECTOR4* ar_Parameter_, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new Float4ShaderParameter(ar_Parameter_, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, const D3DXVECTOR4& argParameter, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new Float4ShaderParameter(argParameter, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, D3DXVECTOR3* ar_Parameter_, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new Float3ShaderParameter(ar_Parameter_, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, const D3DXVECTOR3& argParameter, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new Float3ShaderParameter(argParameter, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, D3DXMATRIX* argParameter, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new Matrix4x4ShaderParameter(argParameter, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, const D3DXMATRIX& argParameter, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new Matrix4x4ShaderParameter(argParameter, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, bool* ab_Parameter_, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new BoolShaderParameter(ab_Parameter_, argParamNameType));
+}
+
+
+void ShaderParameterCollection::SetParameter(const string8& argParameterName, bool argParameter, ParameterBindType::Enumeration argParamNameType)
+{
+	this->SetParameter(argParameterName, new BoolShaderParameter(argParameter, argParamNameType));
+}
+
+
+void ShaderParameterCollection::RemoveParameter(const string8& argParameterName)
+{
+	m_BasisShaderParameterCollection.RemoveShaderParameter(argParameterName);
+}
+
+
+CommandExecuteResult::Enumeration ShaderParameterCollection::ExecuteCommand(unsigned char argCommandType, ICommandBuffer& argCurrentBuffer, uint32 argCurrentPositon)
+{
+	if (argCommandType == SetShaderParameterCollectionCommandType)
+	{
+		if (m_Engine.get_EngineStates().LastShader == NULL)
+			std::wcout << std::red << "ShaderParameterCollection could not been used without a valid shader." << std::white << std::endl;
+		this->UseOnShader(*m_Engine.get_EngineStates().LastShader);
+	}
+	else if (argCommandType == SetFollowingShaderParameterCollectionCommandType)
+	{
+		const std::vector<Command*>& commands = argCurrentBuffer.get_BufferedCommands();
+		for (uint32 i = argCurrentPositon + 1; i < commands.size(); ++i)
+		{
+			IShader* shader = dynamic_cast<IShader*>(commands[i]->Owner);
+			if (shader != NULL && commands[i]->Type == 0)
+				this->UseOnShader(*shader);
+		}
+	}
+	return CommandExecuteResult::None;
+}
+
+
+void ShaderParameterCollection::UseOnShader(IShader& argShader)
+{
+	m_BasisShaderParameterCollection.UseParametersOnShader(argShader);
+}

aiwaz/Aiwaz/Resources/ShaderParameterCollection/ShaderParameterCollection.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "BasisParameterCollection.h"
+#include "IShaderParameterCollection.h"
+#include "../Commands/CommandUserBase.h"
+
+
+struct IEngine;
+class ShaderParameterCollection
+	: public IShaderParameterCollection
+	, public CommandUserBase
+{
+	static const unsigned char SetShaderParameterCollectionCommandType = 0;
+	static const unsigned char SetFollowingShaderParameterCollectionCommandType = 1;
+public:
+	ShaderParameterCollection(IEngine& argEngine, unsigned char argBasePriority = 4);
+	virtual ~ShaderParameterCollection();
+
+	virtual void Uninitialize();	
+
+	// IShaderParameterCollection
+	virtual bool get_IsPreconditionForFollowingShaders() const;
+	virtual void set_IsPreconditionForFollowingShaders(bool argValue);
+
+	virtual void SetParameter(const string8& argParameterName,IShaderParameter* ar_Parameter_);
+	virtual void SetParameter(const string8& argParameterName, ITexture& argParameter, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, float* af_Parameter_, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, float argParameter, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, D3DXVECTOR4* ar_Parameter_, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, const D3DXVECTOR4& argParameter, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, D3DXVECTOR3* ar_Parameter_, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, const D3DXVECTOR3& argParameter, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, D3DXMATRIX* argParameter, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, const D3DXMATRIX& argParameter, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, bool* ab_Parameter_, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void SetParameter(const string8& argParameterName, bool argParameter, ParameterBindType::Enumeration argParamNameType = ParameterBindType::BindBySemantic);
+	virtual void RemoveParameter(const string8& argParameterName);
+
+protected:
+	// ICommandUser
+	virtual CommandExecuteResult::Enumeration ExecuteCommand(unsigned char argCommandType, ICommandBuffer& argCurrentBuffer, uint32 argCurrentPositon);
+	virtual bool get_IsPreconditionForNextCommands() const { return m_IsPreconditionForFollowingShaders; }
+	virtual string8 get_UserName() const { return "ShaderParameterCollection"; }
+
+	void UseOnShader(IShader& argShader);
+
+protected:
+	IEngine& m_Engine;
+
+	BasisShaderParameterCollection m_BasisShaderParameterCollection;
+	bool m_IsPreconditionForFollowingShaders;
+	unsigned char m_BasePriority;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/Types/BaseType.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "IShader.h"
+#include "IShaderParameterCollection.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+struct ParameterMetaType
+{
+	enum Enumeration
+	{
+		Fixed,
+		FixedArray,
+		Dynamic,
+		DynamicArray
+	};
+};
+
+
+class BaseShaderParameter
+	: public IShaderParameter
+{
+public:
+	BaseShaderParameter(ParameterBindType::Enumeration argType, ParameterMetaType::Enumeration argMetaType = ParameterMetaType::Fixed)
+		: m_NameType(argType)
+		, m_Type(argMetaType)
+	{
+	}
+
+	virtual ParameterBindType::Enumeration get_ParameterNameType() const { return m_NameType; }
+	virtual void set_ParameterNameType(ParameterBindType::Enumeration argBindType) { m_NameType = argBindType; }
+
+protected:
+	ParameterBindType::Enumeration m_NameType;
+	ParameterMetaType::Enumeration m_Type;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/Types/Boolean.h

@@ -0,0 +1,60 @@
+#pragma once
+#include "BaseType.h"
+
+class BoolShaderParameter
+	: public BaseShaderParameter
+{
+public:
+	BoolShaderParameter(bool argValue, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Fixed)
+	{
+		m_Value = new bool(argValue);
+	}
+
+	BoolShaderParameter(const bool* af_Value_, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::FixedArray)
+		, m_Count(argCount)
+	{
+		m_Value = new bool[m_Count];
+		::CopyMemory(m_Value, af_Value_, sizeof(bool) * m_Count);
+	}
+	BoolShaderParameter(bool* af_Value_, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Dynamic)
+		, m_Value(af_Value_)
+	{
+	}
+	BoolShaderParameter(bool** af_Value__, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::DynamicArray)
+		, m_Value(*af_Value__) 
+		, m_Count(argCount)
+	{}
+
+	virtual ~BoolShaderParameter()
+	{
+		if (m_Type == ParameterMetaType::FixedArray)
+			delete [] m_Value;
+		if (m_Type == ParameterMetaType::Fixed)
+			delete m_Value;
+	}
+
+	virtual void ApplyValue(ID3D10EffectVariable& argTargetVariable)
+	{
+		ID3D10EffectScalarVariable* scalar = argTargetVariable.AsScalar();
+		if (scalar != NULL)
+		{
+			switch (m_Type)
+			{
+			case ParameterMetaType::Fixed:
+			case ParameterMetaType::Dynamic:
+				scalar->SetBool((BOOL)*m_Value);
+				break;
+			default:
+				scalar->SetBoolArray((BOOL*)m_Value, 0, m_Count);
+			}
+		}
+	}
+
+private:
+	bool* m_Value;
+	uint32 m_Count;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/Types/Float.h

@@ -0,0 +1,178 @@
+#pragma once
+#include "baseType.h"
+
+class FloatShaderParameter
+	: public BaseShaderParameter
+{
+public:
+	FloatShaderParameter(float argValue, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Fixed)
+	{
+		m_Value = new float(argValue);
+	}
+
+	FloatShaderParameter(const float* af_Value_, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::FixedArray)
+		, m_Count(argCount)
+	{
+		m_Value = new float[m_Count];
+		::CopyMemory(m_Value, af_Value_, sizeof(float) * m_Count);
+	}
+	FloatShaderParameter(float* af_Value_, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Dynamic)
+		, m_Value(af_Value_)
+	{
+	}
+	FloatShaderParameter(float** af_Value__, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::DynamicArray)
+		, m_Value(*af_Value__) 
+		, m_Count(argCount)
+	{}
+
+	virtual ~FloatShaderParameter()
+	{
+		if (m_Type == ParameterMetaType::FixedArray)
+			delete [] m_Value;
+		if (m_Type == ParameterMetaType::Fixed)
+			delete m_Value;
+	}
+
+	virtual void ApplyValue(ID3D10EffectVariable& argTargetVariable)
+	{
+		ID3D10EffectScalarVariable* scalar = argTargetVariable.AsScalar();
+		if (scalar != NULL)
+		{
+			switch (m_Type)
+			{
+			case ParameterMetaType::Fixed:
+			case ParameterMetaType::Dynamic:
+				scalar->SetFloat(*m_Value);
+				break;
+			default:
+				scalar->SetFloatArray(m_Value, 0, m_Count);
+			}
+		}
+	}
+
+private:
+	float* m_Value;
+	uint32 m_Count;
+};
+
+
+class Float3ShaderParameter
+	: public BaseShaderParameter
+{
+public:
+	Float3ShaderParameter(const D3DXVECTOR3& argValue, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Fixed)
+	{
+		m_Value = new D3DXVECTOR3(argValue);
+	}
+
+	Float3ShaderParameter(const D3DXVECTOR3* ar_Value_, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::FixedArray)
+		, m_Count(argCount)
+	{
+		m_Value = new D3DXVECTOR3[m_Count];
+		::CopyMemory(m_Value, ar_Value_, sizeof(D3DXVECTOR3) * m_Count);
+	}
+	Float3ShaderParameter(D3DXVECTOR3* ar_Value_, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Dynamic)
+		, m_Value(ar_Value_)
+	{
+	}
+	Float3ShaderParameter(D3DXVECTOR3** ar_Value__, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::DynamicArray)
+		, m_Value(*ar_Value__) 
+		, m_Count(argCount)
+	{}
+
+	virtual ~Float3ShaderParameter()
+	{
+		if (m_Type == ParameterMetaType::FixedArray)
+			delete [] m_Value;
+		if (m_Type == ParameterMetaType::Fixed)
+			delete m_Value;
+	}
+
+	virtual void ApplyValue(ID3D10EffectVariable& argTargetVariable)
+	{
+		ID3D10EffectVectorVariable* vector = argTargetVariable.AsVector();
+		if (vector != NULL)
+		{
+			switch (m_Type)
+			{
+				case ParameterMetaType::Fixed:
+				case ParameterMetaType::Dynamic:
+					vector->SetRawValue((void*)m_Value, 0, sizeof(D3DXVECTOR3));
+					break;
+				default:
+					vector->SetRawValue((void*)m_Value, 0, sizeof(D3DXVECTOR3) * m_Count);
+			}
+		}
+	}
+
+private:
+	D3DXVECTOR3* m_Value;
+	uint32 m_Count;
+};
+
+
+class Float4ShaderParameter
+	: public BaseShaderParameter
+{
+public:
+	Float4ShaderParameter(const D3DXVECTOR4& argValue, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Fixed)
+	{
+		m_Value = new D3DXVECTOR4(argValue);
+	}
+
+	Float4ShaderParameter(const D3DXVECTOR4* ar_Value_, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::FixedArray)
+		, m_Count(argCount)
+	{
+		m_Value = new D3DXVECTOR4[m_Count];
+		::CopyMemory(m_Value, ar_Value_, sizeof(D3DXVECTOR4) * m_Count);
+	}
+	Float4ShaderParameter(D3DXVECTOR4* ar_Value_, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Dynamic)
+		, m_Value(ar_Value_)
+	{
+	}
+	Float4ShaderParameter(D3DXVECTOR4** ar_Value__, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::DynamicArray)
+		, m_Value(*ar_Value__) 
+		, m_Count(argCount)
+	{}
+
+	virtual ~Float4ShaderParameter()
+	{
+		if (m_Type == ParameterMetaType::FixedArray)
+			delete [] m_Value;
+		if (m_Type == ParameterMetaType::Fixed)
+			delete m_Value;
+	}
+
+	virtual void ApplyValue(ID3D10EffectVariable& argTargetVariable)
+	{
+		ID3D10EffectVectorVariable* vector = argTargetVariable.AsVector();
+		if (vector != NULL)
+		{
+			switch (m_Type)
+			{
+			case ParameterMetaType::Fixed:
+			case ParameterMetaType::Dynamic:
+				vector->SetFloatVector((float*)m_Value);
+				break;
+			default:
+				vector->SetFloatVectorArray((float*)m_Value, 0, m_Count);
+			}
+		}
+	}
+
+private:
+	D3DXVECTOR4* m_Value;
+	uint32 m_Count;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/Types/Integer.h

@@ -0,0 +1,61 @@
+#pragma once
+#include "BaseType.h"
+
+
+class IntShaderParameter
+	: public BaseShaderParameter
+{
+public:
+	IntShaderParameter(int argValue, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Fixed)
+	{
+		m_Value = new int(argValue);
+	}
+
+	IntShaderParameter(const int* af_Value_, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::FixedArray)
+		, m_Count(argCount)
+	{
+		m_Value = new int[m_Count];
+		::CopyMemory(m_Value, af_Value_, sizeof(int) * m_Count);
+	}
+	IntShaderParameter(int* af_Value_, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Dynamic)
+		, m_Value(af_Value_)
+	{
+	}
+	IntShaderParameter(int** af_Value__, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::DynamicArray)
+		, m_Value(*af_Value__) 
+		, m_Count(argCount)
+	{}
+
+	virtual ~IntShaderParameter()
+	{
+		if (m_Type == ParameterMetaType::FixedArray)
+			delete [] m_Value;
+		if (m_Type == ParameterMetaType::Fixed)
+			delete m_Value;
+	}
+
+	virtual void ApplyValue(ID3D10EffectVariable& argTargetVariable)
+	{
+		ID3D10EffectScalarVariable* scalar = argTargetVariable.AsScalar();
+		if (scalar != NULL)
+		{
+			switch (m_Type)
+			{
+			case ParameterMetaType::Fixed:
+			case ParameterMetaType::Dynamic:
+				scalar->SetInt(*m_Value);
+				break;
+			default:
+				scalar->SetIntArray(m_Value, 0, m_Count);
+			}
+		}
+	}
+
+private:
+	int* m_Value;
+	uint32 m_Count;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/Types/Matrix.h

@@ -0,0 +1,61 @@
+#pragma once
+#include "BaseType.h"
+
+
+class Matrix4x4ShaderParameter
+	: public BaseShaderParameter
+{
+public:
+	Matrix4x4ShaderParameter(const D3DXMATRIX& argValue, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Fixed)
+	{
+		m_Value = new D3DXMATRIX(argValue);
+	}
+
+	Matrix4x4ShaderParameter(const D3DXMATRIX* ar_Value_, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::FixedArray)
+		, m_Count(argCount)
+	{
+		m_Value = new D3DXMATRIX[m_Count];
+		::CopyMemory(m_Value, ar_Value_, sizeof(D3DXMATRIX) * m_Count);
+	}
+	Matrix4x4ShaderParameter(D3DXMATRIX* ar_Value_, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::Dynamic)
+		, m_Value(ar_Value_)
+	{
+	}
+	Matrix4x4ShaderParameter(D3DXMATRIX** ar_Value_, uint32 argCount, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType, ParameterMetaType::DynamicArray)
+		, m_Value(*ar_Value_) 
+		, m_Count(argCount)
+	{}
+
+	virtual ~Matrix4x4ShaderParameter()
+	{
+		if (m_Type == ParameterMetaType::FixedArray)
+			delete [] m_Value;
+		if (m_Type == ParameterMetaType::Fixed)
+			delete m_Value;
+	}
+
+	virtual void ApplyValue(ID3D10EffectVariable& argTargetVariable)
+	{
+		ID3D10EffectMatrixVariable* matrix = argTargetVariable.AsMatrix();
+		if (matrix != NULL)
+		{
+			switch (m_Type)
+			{
+			case ParameterMetaType::Fixed:
+			case ParameterMetaType::Dynamic:
+				matrix->SetMatrix((float*)m_Value);
+				break;
+			default:
+				matrix->SetMatrixArray((float*)m_Value, 0, m_Count);
+			}
+		}
+	}
+
+private:
+	D3DXMATRIX* m_Value;
+	uint32 m_Count;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/Types/Texture.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "BaseType.h"
+#include "ITexture.h"
+
+class TextureShaderParameter
+	: public BaseShaderParameter
+{
+public:
+	TextureShaderParameter(ITexture& argValue, ParameterBindType::Enumeration argType = ParameterBindType::BindByVariable)
+		: BaseShaderParameter(argType)
+		, m_Value(&argValue)
+	{
+	}
+
+	virtual ~TextureShaderParameter()
+	{
+	}
+
+	virtual void ApplyValue(ID3D10EffectVariable& argTargetVariable)
+	{
+		ID3D10EffectShaderResourceVariable* var = argTargetVariable.AsShaderResource();
+		if (var != NULL)
+			var->SetResource(m_Value->get_ResourceViewFromTexture());
+	}
+
+private:
+	ITexture* m_Value;
+};

aiwaz/Aiwaz/Resources/ShaderParameterCollection/Types/Types.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "Integer.h"
+#include "Boolean.h"
+#include "Matrix.h"
+#include "Float.h"
+#include "Texture.h"