Added a better way of merging shader techniques, and support for merging based on tags

Updated builtin editor resources so icon assets aren't recreated on any data folder modification

Source/BansheeEditor/Source/BsBuiltinEditorResources.cpp

@@ -461,6 +461,25 @@ namespace BansheeEngine
 
 		gCoreAccessor().submitToCoreThread(true);
 
+		auto saveTexture = [&](auto& pixelData, auto& path)
+		{
+			if (FileSystem::exists(path))
+			{
+				HResource resource = gResources().load(path);
+
+				SPtr<Texture> texture = Texture::_createPtr(pixelData);
+				gResources().update(resource, texture);
+				Resources::instance().save(resource, path, true);
+				manifest->registerResource(resource.getUUID(), path);
+			}
+			else
+			{
+				HTexture texture = Texture::create(pixelData);
+				Resources::instance().save(texture, path, true);
+				manifest->registerResource(texture.getUUID(), path);
+			}
+		};
+
 		idx = 0;
 		for (auto& iconName : iconsToProcess)
 		{
@@ -475,22 +494,14 @@ namespace BansheeEngine
 			SPtr<PixelData> scaled16 = PixelData::create(16, 16, 1, src->getFormat());
 			PixelUtil::scale(*scaled32, *scaled16);
 
-			HTexture tex48 = Texture::create(scaled48);
-			HTexture tex32 = Texture::create(scaled32);
-			HTexture tex16 = Texture::create(scaled16);
-
 			Path outputPath48 = inputFolder + (iconName + L"48.asset");
-			Resources::instance().save(tex48, outputPath48, true);
-			manifest->registerResource(tex48.getUUID(), outputPath48);
-
 			Path outputPath32 = inputFolder + (iconName + L"32.asset");
-			Resources::instance().save(tex32, outputPath32, true);
-			manifest->registerResource(tex32.getUUID(), outputPath32);
-
 			Path outputPath16 = inputFolder + (iconName + L"16.asset");
-			Resources::instance().save(tex16, outputPath16, true);
-			manifest->registerResource(tex16.getUUID(), outputPath16);
 
+			saveTexture(scaled48, outputPath48);
+			saveTexture(scaled32, outputPath32);
+			saveTexture(scaled16, outputPath16);
+					
 			idx++;
 		}
 	}

Source/BansheeSL/Include/BsSLFXCompiler.h

@@ -67,6 +67,7 @@ namespace BansheeEngine
 			StringID renderAPI = RenderAPIAny;
 			Vector<StringID> tags;
 			String language;
+			bool include = false;
 
 			PassData commonPassData;
 			Vector<PassData> passes;
@@ -87,8 +88,18 @@ namespace BansheeEngine
 		static void getTechniqueIdentifier(ASTFXNode* technique, StringID& renderer, String& language, 
 			Vector<StringID>& tags);
 
-		/** Checks if two techniques can be matched based on the options specified in their child nodes. */
-		static bool doTechniquesMatch(ASTFXNode* into, ASTFXNode* from);
+		/** 
+		 * Checks if two techniques can be matched based on the options specified in their child nodes. Used for deciding
+		 * if two techniques should be merged.
+		 * 
+		 * @param[in]	into			Parent technique the merge should be performed into.
+		 * @param[in]	from			Child technique the merge should be performed from.
+		 * @param[out]	isMoreSpecific	Returns true if the @p from technique is more specific than @p into technique.
+		 *								(e.g. @p into technique accepts any language, while @p from only accepts HLSL).
+		 *								Only relevant if techniques match.
+		 * @return						True if the techniques match.
+		 */
+		static bool doTechniquesMatch(ASTFXNode* into, ASTFXNode* from, bool& isMoreSpecific);
 
 		/**	Converts FX renderer name into an in-engine renderer identifier. */
 		static StringID parseRenderer(const String& name);

Source/BansheeSL/Source/BsSLFXCompiler.cpp

@@ -226,8 +226,10 @@ namespace BansheeEngine
 		}
 	}
 
-	bool BSLFXCompiler::doTechniquesMatch(ASTFXNode* into, ASTFXNode* from)
+	bool BSLFXCompiler::doTechniquesMatch(ASTFXNode* into, ASTFXNode* from, bool& isMoreSpecific)
 	{
+		isMoreSpecific = false;
+
 		StringID intoRenderer = RendererAny;
 		String intoLanguage = "Any";
 		Vector<StringID> intoTags;
@@ -239,31 +241,74 @@ namespace BansheeEngine
 		getTechniqueIdentifier(into, intoRenderer, intoLanguage, intoTags);
 		getTechniqueIdentifier(from, fromRenderer, fromLanguage, fromTags);
 
-		bool matches = (intoRenderer == fromRenderer || fromRenderer == RendererAny) && (intoLanguage == fromLanguage || fromLanguage == "Any");
-		if(matches)
+		bool matches = true;
+		if (intoRenderer != fromRenderer)
+		{
+			if (intoRenderer == RendererAny)
+				isMoreSpecific = true;
+			else if(fromRenderer != RendererAny)
+				matches = false;
+		}
+
+		if(intoLanguage != fromLanguage)
+		{
+			if(intoLanguage == "Any")
+				isMoreSpecific = true;
+			else if (intoLanguage != "Any")
+				matches = false;
+		}
+
+		static StringID AnyTag("Any");
+		if (matches)
 		{
+			bool tagsMatch = true;
 			for (auto& intoTag : intoTags)
 			{
 				auto iterFind = std::find(fromTags.begin(), fromTags.end(), intoTag);
-				if(iterFind == fromTags.end())
+				if (iterFind == fromTags.end())
 				{
-					matches = false;
+					tagsMatch = false;
 					break;
 				}
 			}
+
+			if (!tagsMatch)
+			{
+				bool fromMatchAnyTags = false;
+				auto iterFind = std::find(fromTags.begin(), fromTags.end(), AnyTag);
+				if (iterFind != fromTags.end())
+					fromMatchAnyTags = true;
+
+				if (!fromMatchAnyTags)
+					matches = false;
+			}
 		}
 
 		if (matches)
 		{
+			bool tagsMatch = true;
 			for (auto& fromTag : fromTags)
 			{
 				auto iterFind = std::find(intoTags.begin(), intoTags.end(), fromTag);
 				if (iterFind == intoTags.end())
 				{
-					matches = false;
+					tagsMatch = false;
 					break;
 				}
 			}
+
+			if(!tagsMatch)
+			{
+				bool intoMatchAnyTags = false;
+				auto iterFind = std::find(intoTags.begin(), intoTags.end(), AnyTag);
+				if (iterFind != intoTags.end())
+					intoMatchAnyTags = true;
+
+				if (intoMatchAnyTags)
+					isMoreSpecific = true;
+				else
+					matches = false;
+			}
 		}
 
 		return matches;
@@ -1300,20 +1345,47 @@ namespace BansheeEngine
 				break;
 			case OT_Technique:
 			{
-				auto iterFind = std::find_if(techniqueData.begin(), techniqueData.end(), 
-					[&] (auto x)
+				TechniqueData* data = nullptr;
+
+				// Look for matching techniques, prefer those that aren't includes (i.e. look for more specific ones first)
+				bool isInclude = true;
+				bool isMoreSpecific = false;
+				for(auto& entry : techniqueData)
 				{
-					return doTechniquesMatch(x.first, option->value.nodePtr);
-				});
+					if (!isInclude && entry.second.include)
+						continue;
 
-				TechniqueData* data = nullptr;
-				if (iterFind != techniqueData.end())
-					data = &iterFind->second;
-				else
+					bool moreSpecific;
+					if(doTechniquesMatch(entry.first, option->value.nodePtr, moreSpecific))
+					{
+						isInclude = entry.second.include;
+						data = &entry.second;
+						isMoreSpecific = moreSpecific;
+					}
+				}
+
+				// Technique to merge with not found, create new technique
+				if(data == nullptr)
 				{
 					techniqueData.push_back(std::make_pair(option->value.nodePtr, TechniqueData()));
 					data = &techniqueData.back().second;
 				}
+				else
+				{
+					// Found technique that's identical or more general to this one, so just append the data to the existing
+					// technique
+					if(!isMoreSpecific)
+					{
+						// Do nothing
+					}
+					else // Found technique that's more specific, clone the technique data and append to the clone
+					{
+						data->include = true;
+
+						techniqueData.push_back(std::make_pair(option->value.nodePtr, *data));
+						data = &techniqueData.back().second;
+					}
+				}
 
 				parseTechnique(option->value.nodePtr, codeBlocks, *data);
 				break;
@@ -1333,6 +1405,8 @@ namespace BansheeEngine
 		for(auto& entry : techniqueData)
 		{
 			const TechniqueData& techniqueData = entry.second;
+			if (techniqueData.include)
+				continue;
 
 			Map<UINT32, SPtr<Pass>, std::greater<UINT32>> passes;
 			for (auto& passData : entry.second.passes)