Fixed an issue with GPU parameter mapping (shader and GPU variables can now have different names)

Fixed a few issues in editor-only GLSL shaders

Data/Raw/Editor/Includes/PickingAlphaCull.bslinc

@@ -118,7 +118,7 @@ Technique : base("PickingAlphaCull") =
 			in vec3 bs_position;
 			in vec2 bs_texcoord0;
 			in vec3 bs_normal;
-			out vec4 normal
+			out vec4 normal;
 			out vec2 texcoord0;
 
 			out gl_PerVertex

Data/Raw/Editor/Includes/PickingCull.bslinc

@@ -91,6 +91,7 @@ Technique : base("PickingCull") =
 			in vec3 bs_position;
 			in vec3 bs_normal;
 			out vec4 normal;
+			
 			out gl_PerVertex
 			{
 				vec4 gl_Position;

Data/Raw/Editor/Includes/SelectionBase.bslinc

@@ -163,7 +163,7 @@ Technique
 		in vec3 bs_position;
 	
 		#ifdef USE_SKELETON
-			in uvec4 bs_blendindices;
+			in ivec4 bs_blendindices;
 			in vec4 bs_blendweights;
 		#endif
 			
@@ -180,7 +180,7 @@ Technique
 #ifdef USE_SKELETON
 		uniform samplerBuffer boneMatrices;
 		
-		void getBoneMatrix(uint idx, out mat4x3 result)
+		void getBoneMatrix(int idx, out mat4x3 result)
 		{
 			mat3x4 temp;
 		
@@ -195,16 +195,16 @@ Technique
 		{
 			mat4x3 boneMatrix;
 			
-			getBoneMatrix(bs_blendindices.x, out boneMatrix);
+			getBoneMatrix(bs_blendindices.x, boneMatrix);
 			result = bs_blendweights.x * boneMatrix;
 			
-			getBoneMatrix(bs_blendindices.y, out boneMatrix);
+			getBoneMatrix(bs_blendindices.y, boneMatrix);
 			result += bs_blendweights.y * boneMatrix;
 			
-			getBoneMatrix(bs_blendindices.z, out boneMatrix);
+			getBoneMatrix(bs_blendindices.z, boneMatrix);
 			result += bs_blendweights.z * boneMatrix;
 			
-			getBoneMatrix(bs_blendindices.w, out boneMatrix);
+			getBoneMatrix(bs_blendindices.w, boneMatrix);
 			result += bs_blendweights.w * boneMatrix;
 		}
 #endif
@@ -218,7 +218,7 @@ Technique
 #endif		
 		
 #ifdef USE_SKELETON
-			mat3x4 blendMatrix;
+			mat4x3 blendMatrix;
 			getBlendMatrix(blendMatrix);
 			
 			position = vec4(blendMatrix * position, 1.0f);

Source/BansheeCore/Source/BsGpuParamsSet.cpp

@@ -10,6 +10,51 @@
 #include "BsRenderAPI.h"
 #include "BsGpuParamBlockBuffer.h"
 
+namespace BansheeEngine
+{
+	/** Uniquely identifies a GPU parameter. */
+	struct ValidParamKey
+	{
+		ValidParamKey(const String& name, const MaterialParams::ParamType& type)
+			:name(name), type(type)
+		{ }
+
+		bool operator== (const ValidParamKey& rhs) const
+		{
+			return name == rhs.name && type == rhs.type;
+		}
+
+		bool operator!= (const ValidParamKey& rhs) const
+		{
+			return !(*this == rhs);
+		}
+
+		String name;
+		MaterialParams::ParamType type;
+	};
+}
+
+/** @cond STDLIB */
+
+namespace std
+{
+	/** Hash value generator for ValidParamKey. */
+	template<>
+	struct hash<BansheeEngine::ValidParamKey>
+	{
+		size_t operator()(const BansheeEngine::ValidParamKey& key) const
+		{
+			size_t hash = 0;
+			BansheeEngine::hash_combine(hash, key.name);
+			BansheeEngine::hash_combine(hash, key.type);
+
+			return hash;
+		}
+	};
+}
+
+/** @endcond */
+
 namespace BansheeEngine
 {
 	struct ShaderBlockDesc
@@ -341,13 +386,13 @@ namespace BansheeEngine
 		return paramToParamBlock;
 	}
 
-	UnorderedSet<String> determineValidParameters(const Vector<SPtr<GpuParamDesc>>& paramDescs,
+	UnorderedMap<ValidParamKey, String> determineValidParameters(const Vector<SPtr<GpuParamDesc>>& paramDescs,
 		const Map<String, SHADER_DATA_PARAM_DESC>& dataParams,
 		const Map<String, SHADER_OBJECT_PARAM_DESC>& textureParams,
 		const Map<String, SHADER_OBJECT_PARAM_DESC>& bufferParams,
 		const Map<String, SHADER_OBJECT_PARAM_DESC>& samplerParams)
 	{
-		UnorderedSet<String> validParams;
+		UnorderedMap<ValidParamKey, String> validParams;
 
 		Map<String, const GpuParamDataDesc*> validDataParameters = determineValidDataParameters(paramDescs);
 		Vector<const GpuParamObjectDesc*> validObjectParameters = determineValidObjectParameters(paramDescs);
@@ -381,11 +426,12 @@ 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.");
 
-			validParams.insert(iter->first);
+			ValidParamKey key(iter->second.gpuVariableName, MaterialParams::ParamType::Data);
+			validParams.insert(std::make_pair(key, iter->first));
 		}
 
 		// Create object param mappings
-		auto determineObjectMappings = [&](const Map<String, SHADER_OBJECT_PARAM_DESC>& params)
+		auto determineObjectMappings = [&](const Map<String, SHADER_OBJECT_PARAM_DESC>& params, MaterialParams::ParamType paramType)
 		{
 			for (auto iter = params.begin(); iter != params.end(); ++iter)
 			{
@@ -396,7 +442,9 @@ namespace BansheeEngine
 					{
 						if ((*iter3)->name == (*iter2) && (*iter3)->type == iter->second.type)
 						{
-							validParams.insert(iter->first);
+							ValidParamKey key(*iter2, paramType);
+							validParams.insert(std::make_pair(key, iter->first));
+
 							break;
 						}
 					}
@@ -404,9 +452,9 @@ namespace BansheeEngine
 			}
 		};
 
-		determineObjectMappings(textureParams);
-		determineObjectMappings(samplerParams);
-		determineObjectMappings(bufferParams);
+		determineObjectMappings(textureParams, MaterialParams::ParamType::Texture);
+		determineObjectMappings(samplerParams, MaterialParams::ParamType::Sampler);
+		determineObjectMappings(bufferParams, MaterialParams::ParamType::Buffer);
 
 		return validParams;
 	}
@@ -456,7 +504,7 @@ namespace BansheeEngine
 
 		//// Fill out various helper structures
 		Vector<ShaderBlockDesc> paramBlockData = determineValidShareableParamBlocks(allParamDescs, shader->getParamBlocks());
-		UnorderedSet<String> validParams = determineValidParameters(
+		UnorderedMap<ValidParamKey, String> validParams = determineValidParameters(
 			allParamDescs, 
 			shader->getDataParams(), 
 			shader->getTextureParams(), 
@@ -537,10 +585,13 @@ namespace BansheeEngine
 							if (dataParam.second.paramBlockSlot != blockDesc.slot)
 								continue;
 
-							if (validParams.count(dataParam.first) == 0)
+							ValidParamKey key(dataParam.first, MaterialParams::ParamType::Data);
+
+							auto iterFind = validParams.find(key);
+							if (iterFind == validParams.end())
 								continue;
 
-							UINT32 paramIdx = params->getParamIndex(dataParam.first);
+							UINT32 paramIdx = params->getParamIndex(iterFind->second);
 
 							// Parameter shouldn't be in the valid parameter list if it cannot be found
 							assert(paramIdx != -1);
@@ -602,11 +653,14 @@ namespace BansheeEngine
 					{
 						for (auto& param : gpuParams)
 						{
-							if (validParams.count(param.first) == 0)
+							ValidParamKey key(param.first, paramType);
+
+							auto iterFind = validParams.find(key);
+							if (iterFind == validParams.end())
 								continue;
 
 							UINT32 paramIdx;
-							auto result = params->getParamIndex(param.first, paramType, GPDT_UNKNOWN, 0, paramIdx);
+							auto result = params->getParamIndex(iterFind->second, paramType, GPDT_UNKNOWN, 0, paramIdx);
 
 							// Parameter shouldn't be in the valid parameter list if it cannot be found
 							assert(result == MaterialParams::GetParamResult::Success);