Added proper Color parameter type to Shader

BansheeCore/Include/BsCommonTypes.h

@@ -249,6 +249,7 @@ namespace BansheeEngine
 		GPDT_INT4 = 23,
 		GPDT_BOOL = 24,
 		GPDT_STRUCT = 25,
+		GPDT_COLOR = 26, // Same as GPDT_FLOAT4, but can be used to better deduce usage
 		GPDT_UNKNOWN = 0xffff
 	};
 

BansheeCore/Include/BsCorePrerequisites.h

@@ -348,7 +348,8 @@ namespace BansheeEngine
 		TID_ProfilerOverlay = 1082,
 		TID_StringTable = 1083,
 		TID_LanguageData = 1084,
-		TID_LocalizedStringData = 1085
+		TID_LocalizedStringData = 1085,
+		TID_MaterialParamColor = 1086
 	};
 }
 

BansheeCore/Include/BsMaterial.h

@@ -200,10 +200,7 @@ namespace BansheeEngine
 		 *
 		 *			Optionally if the parameter is an array you may provide an array index to assign the value to.
 		 */
-		void setColor(const String& name, const Color& value, UINT32 arrayIdx = 0)
-		{
-			return getParamVec4(name).set(Vector4(value.r, value.g, value.b, value.a), arrayIdx);
-		}
+		void setColor(const String& name, const Color& value, UINT32 arrayIdx = 0) { return getParamColor(name).set(value, arrayIdx); }
 
 		/**   
 		 *  @brief	Assigns a 2D vector to the shader parameter with the specified name. 

BansheeCore/Include/BsMaterialRTTI.h

@@ -68,6 +68,19 @@ namespace BansheeEngine
 		virtual RTTITypeBase* getRTTI() const;	
 	};
 
+	class BS_CORE_EXPORT MaterialColorParam : public IReflectable
+	{
+	public:
+		String name;
+		Color value;
+		UINT32 arrayIdx;
+
+		friend class MaterialColorParamRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+
 	class BS_CORE_EXPORT MaterialMat3Param : public IReflectable
 	{
 	public:
@@ -136,6 +149,7 @@ namespace BansheeEngine
 		Vector<MaterialVec4Param> vec4Params;
 		Vector<MaterialMat3Param> mat3Params;
 		Vector<MaterialMat4Param> mat4Params;
+		Vector<MaterialColorParam> colorParams;
 		Vector<MaterialStructParam> structParams;
 		Vector<MaterialTextureParam> textureParams;
 		Vector<MaterialSamplerStateParam> samplerStateParams;
@@ -277,6 +291,38 @@ namespace BansheeEngine
 		}
 	};
 
+	class BS_CORE_EXPORT MaterialColorParamRTTI : public RTTIType <MaterialColorParam, IReflectable, MaterialColorParamRTTI>
+	{
+	public:
+		String& getName(MaterialColorParam* obj) { return obj->name; }
+		void setName(MaterialColorParam* obj, String& name) { obj->name = name; }
+
+		Color& getValue(MaterialColorParam* obj) { return obj->value; }
+		void setValue(MaterialColorParam* obj, Color& value) { obj->value = value; }
+
+		UINT32& getArrayIdx(MaterialColorParam* obj) { return obj->arrayIdx; }
+		void setArrayIdx(MaterialColorParam* obj, UINT32& value) { obj->arrayIdx = value; }
+
+		MaterialColorParamRTTI()
+		{
+			addPlainField("name", 0, &MaterialColorParamRTTI::getName, &MaterialColorParamRTTI::setName);
+			addPlainField("value", 1, &MaterialColorParamRTTI::getValue, &MaterialColorParamRTTI::setValue);
+			addPlainField("arrayIdx", 2, &MaterialColorParamRTTI::getArrayIdx, &MaterialColorParamRTTI::setArrayIdx);
+		}
+
+		virtual const String& getRTTIName()
+		{
+			static String name = "MaterialColorParam";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId() { return TID_MaterialParamColor; }
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return bs_shared_ptr<MaterialColorParam, ScratchAlloc>();
+		}
+	};
+
 	class BS_CORE_EXPORT MaterialMat3ParamRTTI : public RTTIType<MaterialMat3Param, IReflectable, MaterialMat3ParamRTTI>
 	{
 	public:
@@ -470,6 +516,11 @@ namespace BansheeEngine
 		UINT32 getVec4ArraySize(MaterialParams* obj) { return (UINT32)obj->vec4Params.size(); }
 		void setVec4ArraySize(MaterialParams* obj, UINT32 size) { obj->vec4Params.resize(size); }
 
+		MaterialColorParam& getColorParam(MaterialParams* obj, UINT32 idx) { return obj->colorParams[idx]; }
+		void setColorParam(MaterialParams* obj, UINT32 idx, MaterialColorParam& param) { obj->colorParams[idx] = param; }
+		UINT32 getColorArraySize(MaterialParams* obj) { return (UINT32)obj->colorParams.size(); }
+		void setColorArraySize(MaterialParams* obj, UINT32 size) { obj->colorParams.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(); }
@@ -523,6 +574,9 @@ namespace BansheeEngine
 
 			addReflectableArrayField("samplerStateParams", 8, &MaterialParamsRTTI::getSamplerStateParam, 
 				&MaterialParamsRTTI::getSamplerStateArraySize, &MaterialParamsRTTI::setSamplerStateParam, &MaterialParamsRTTI::setSamplerStateArraySize);
+
+			addReflectableArrayField("colorParams", 9, &MaterialParamsRTTI::getColorParam,
+				&MaterialParamsRTTI::getColorArraySize, &MaterialParamsRTTI::setColorParam, &MaterialParamsRTTI::setColorArraySize);
 		}
 
 		virtual const String& getRTTIName()

BansheeCore/Source/BsMaterial.cpp

@@ -276,7 +276,7 @@ namespace BansheeEngine
 			if (findIter == validDataParameters.end())
 				continue;
 
-			if (findIter->second->type != iter->second.type)
+			if (findIter->second->type != iter->second.type && !(iter->second.type == GPDT_COLOR && findIter->second->type == GPDT_FLOAT4))
 			{
 				LOGWRN("Ignoring shader parameter \"" + iter->first + "\". Type doesn't match the one defined in the gpu program. "
 					+ "Shader defined type: " + toString(iter->second.type) + " - Gpu program defined type: " + toString(findIter->second->type));
@@ -295,7 +295,6 @@ namespace BansheeEngine
 			if (findBlockIter == paramToParamBlockMap.end())
 				BS_EXCEPT(InternalErrorException, "Parameter doesn't exist in param to param block map but exists in valid param map.");
 
-			String& paramBlockName = findBlockIter->second;
 			validParams[iter->first] = iter->second.gpuVariableName;
 		}
 
@@ -837,6 +836,9 @@ namespace BansheeEngine
 			case GPDT_BOOL:
 				setParamValue<int>(iterFind->first, buffer, paramData.second.arraySize);
 				break;
+			case GPDT_COLOR:
+				setParamValue<Color>(iterFind->first, buffer, paramData.second.arraySize);
+				break;
 			case GPDT_STRUCT:
 			{
 				TMaterialParamStruct<Core> param = getParamStruct(paramData.first);

BansheeCore/Source/BsMaterialRTTI.cpp

@@ -16,6 +16,9 @@ namespace BansheeEngine
 	RTTITypeBase* MaterialVec4Param::getRTTIStatic() { return MaterialVec4ParamRTTI::instance(); }
 	RTTITypeBase* MaterialVec4Param::getRTTI() const { return MaterialVec4Param::getRTTIStatic(); }
 
+	RTTITypeBase* MaterialColorParam::getRTTIStatic() { return MaterialColorParamRTTI::instance(); }
+	RTTITypeBase* MaterialColorParam::getRTTI() const { return MaterialColorParam::getRTTIStatic(); }
+
 	RTTITypeBase* MaterialMat3Param::getRTTIStatic() { return MaterialMat3ParamRTTI::instance(); }
 	RTTITypeBase* MaterialMat3Param::getRTTI() const { return MaterialMat3Param::getRTTIStatic(); }
 
@@ -106,6 +109,19 @@ namespace BansheeEngine
 							}
 						}
 						break;
+					case GPDT_COLOR:
+						{
+							for (UINT32 i = 0; i < paramDesc.arraySize; i++)
+							{
+								MaterialColorParam param;
+								param.name = iter->first;
+								param.value = material->getColor(iter->first, i);
+								param.arrayIdx = i;
+
+								params->colorParams.push_back(param);
+							}
+						}
+						break;
 					case GPDT_MATRIX_3X3:
 						{
 							for(UINT32 i = 0; i < paramDesc.arraySize; i++)
@@ -262,6 +278,19 @@ namespace BansheeEngine
 				material->setVec4(iter->name, iter->value, iter->arrayIdx);
 			}
 
+			for (auto iter = params->colorParams.begin(); iter != params->colorParams.end(); ++iter)
+			{
+				if (!shader->hasDataParam(iter->name))
+					continue;
+
+				const SHADER_DATA_PARAM_DESC& paramDesc = shader->getDataParamDesc(iter->name);
+
+				if (paramDesc.type != GPDT_COLOR || iter->arrayIdx < 0 || iter->arrayIdx >= paramDesc.arraySize)
+					continue;
+
+				material->setColor(iter->name, iter->value, iter->arrayIdx);
+			}
+
 			for(auto iter = params->mat3Params.begin(); iter != params->mat3Params.end(); ++iter)
 			{
 				if(!shader->hasDataParam(iter->name))

BansheeSL/BsLexerFX.h

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

BansheeSL/BsLexerFX.l

@@ -33,6 +33,7 @@ float			{ yylval->intValue = PT_Float; return TOKEN_FLOATTYPE; }
 float2			{ yylval->intValue = PT_Float2; return TOKEN_FLOAT2TYPE; } 
 float3			{ yylval->intValue = PT_Float3; return TOKEN_FLOAT3TYPE; } 
 float4			{ yylval->intValue = PT_Float4; return TOKEN_FLOAT4TYPE; }
+color			{ yylval->intValue = PT_Color; return TOKEN_COLORTYPE; }
 
 mat2x2			{ yylval->intValue = PT_Mat2x2; return TOKEN_MAT2x2TYPE; } 
 mat2x3			{ yylval->intValue = PT_Mat2x3; return TOKEN_MAT2x3TYPE; } 

BansheeSL/BsParserFX.h

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

BansheeSL/BsParserFX.y

@@ -72,6 +72,7 @@ void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const cha
 %token <intValue> TOKEN_FLOAT2TYPE 
 %token <intValue> TOKEN_FLOAT3TYPE 
 %token <intValue> TOKEN_FLOAT4TYPE
+%token <intValue> TOKEN_COLORTYPE
 
 %token <intValue> TOKEN_MAT2x2TYPE 
 %token <intValue> TOKEN_MAT2x3TYPE 
@@ -197,6 +198,7 @@ void yyerror(YYLTYPE *locp, ParseState* parse_state, yyscan_t scanner, const cha
 %type <nodePtr> param_header_float2
 %type <nodePtr> param_header_float3
 %type <nodePtr> param_header_float4
+%type <nodePtr> param_header_color
 %type <nodePtr> param_header_mat2x2
 %type <nodePtr> param_header_mat2x3
 %type <nodePtr> param_header_mat2x4
@@ -646,6 +648,7 @@ parameter
 	| param_header_float2	qualifier_list param_body_float2	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
 	| param_header_float3	qualifier_list param_body_float3	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
 	| param_header_float4	qualifier_list param_body_float4	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
+	| param_header_color	qualifier_list param_body_float4	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
 	| param_header_mat2x2	qualifier_list param_body_float4	';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
 	| param_header_mat2x3	qualifier_list param_body_mat6		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
 	| param_header_mat2x4	qualifier_list param_body_mat8		';' { nodeOptionsAdd(parse_state->memContext, parse_state->topNode->options, &$3); nodePop(parse_state); $$.type = OT_Parameter; $$.value.nodePtr = $1; }
@@ -687,6 +690,10 @@ param_header_float4
 	: TOKEN_FLOAT4TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
 	;
 
+param_header_color
+	: TOKEN_COLORTYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
+	;
+
 param_header_mat2x2
 	: TOKEN_MAT2x2TYPE TOKEN_IDENTIFIER { ADD_PARAMETER($$, $1, $2); }
 	;

BansheeSL/Include/BsASTFX.h

@@ -122,7 +122,7 @@ enum tagOptionDataType
 
 enum tagParamType
 {
-	PT_Float, PT_Float2, PT_Float3, PT_Float4,
+	PT_Float, PT_Float2, PT_Float3, PT_Float4, PT_Color,
 	PT_Mat2x2, PT_Mat2x3, PT_Mat2x4,
 	PT_Mat3x2, PT_Mat3x3, PT_Mat3x4,
 	PT_Mat4x2, PT_Mat4x3, PT_Mat4x4,

SBansheeEngine/Source/BsScriptShader.cpp

@@ -49,8 +49,6 @@ namespace BansheeEngine
 		// TODO - Ignoring buffers and load/store textures
 		for (auto& param : dataParams)
 		{
-			// TODO - No way to identify color types
-
 			ShaderParameterType type;
 			bool isValidType = false;
 			switch (param.second.type) 
@@ -79,6 +77,10 @@ namespace BansheeEngine
 				type = ShaderParameterType::Matrix4;
 				isValidType = true;
 				break;
+			case GPDT_COLOR:
+				type = ShaderParameterType::Color;
+				isValidType = true;
+				break;
 			}
 
 			if (isValidType)