Bugfix: Strip imported subresources from invalid characters in their name to avoid exceptions when parsing paths

Source/BansheeEditor/Library/BsProjectLibrary.cpp

@@ -439,6 +439,7 @@ namespace bs
 					SPtr<ResourceMetaData> subMeta = entry.value->getMetaData();
 					UINT32 typeId = entry.value->getTypeId();
 					const UUID& UUID = entry.value.getUUID();
+					Path::stripInvalid(entry.name);
 
 					SPtr<ProjectResourceMeta> resMeta = ProjectResourceMeta::create(entry.name, UUID, typeId, subMeta);
 					fileEntry->meta->add(resMeta);
@@ -473,6 +474,8 @@ namespace bs
 
 					for(auto& resEntry : importedResourcesRaw)
 					{
+						Path::stripInvalid(resEntry.name);
+
 						bool foundMeta = false;
 						for (auto iter = existingResourceMetas.begin(); iter != existingResourceMetas.end(); ++iter)
 						{

Source/BansheeUtility/FileSystem/BsPath.cpp

@@ -634,6 +634,28 @@ namespace bs
 		return output.append(right);
 	}
 
+	void Path::stripInvalid(String& path)
+	{
+		String illegalChars = "\\/:?\"<>|";
+
+		for(auto& entry : path)
+		{
+			if(illegalChars.find(entry) != String::npos)
+				entry = ' ';
+		}
+	}
+
+	void Path::stripInvalid(WString& path)
+	{
+		WString illegalChars = L"\\/:?\"<>|";
+
+		for(auto& entry : path)
+		{
+			if(illegalChars.find(entry) != WString::npos)
+				entry = ' ';
+		}
+	}
+
 	void Path::pushDirectory(const WString& dir)
 	{
 		pushDirectory(UTF8::fromWide(dir));

Source/BansheeUtility/FileSystem/BsPath.h

@@ -362,6 +362,12 @@ namespace bs
 		/** Combines two paths and returns the result. Right path should be relative. */
 		static Path combine(const Path& left, const Path& right);
 
+		/** Strips invalid characters from the provided string and replaces them with empty spaces. */
+		static void stripInvalid(String& path);
+
+		/** Strips invalid characters from the provided string and replaces them with empty spaces. */
+		static void stripInvalid(WString& path);
+
 		static const Path BLANK;
 	private:
 		/**

Source/BansheeUtility/String/BsString.cpp

@@ -16,11 +16,11 @@ namespace bs
 	const String StringUtil::BLANK;
 	const WString StringUtil::WBLANK;
 
-    void StringUtil::trim(String& str, bool left, bool right)
-    {
-        static const String delims = " \t\r";
-        trim(str, delims, left, right);
-    }
+	void StringUtil::trim(String& str, bool left, bool right)
+	{
+		static const String delims = " \t\r";
+		trim(str, delims, left, right);
+	}
 
 	void StringUtil::trim(WString& str, bool left, bool right)
 	{
@@ -44,10 +44,10 @@ namespace bs
 			str.erase(0, str.find_first_not_of(delims)); // trim left
 	}
 
-    Vector<String> StringUtil::split(const String& str, const String& delims, unsigned int maxSplits)
-    {
-        return splitInternal<char>(str, delims, maxSplits);
-    }
+	Vector<String> StringUtil::split(const String& str, const String& delims, unsigned int maxSplits)
+	{
+		return splitInternal<char>(str, delims, maxSplits);
+	}
 
 	Vector<WString> StringUtil::split(const WString& str, const WString& delims, unsigned int maxSplits)
 	{
@@ -56,58 +56,58 @@ namespace bs
 
 	Vector<String> StringUtil::tokenise(const String& str, const String& singleDelims, const String& doubleDelims, unsigned int maxSplits)
 	{
-        return tokeniseInternal<char>(str, singleDelims, doubleDelims, maxSplits);
-    }
+		return tokeniseInternal<char>(str, singleDelims, doubleDelims, maxSplits);
+	}
 
 	Vector<WString> StringUtil::tokenise(const WString& str, const WString& singleDelims, const WString& doubleDelims, unsigned int maxSplits)
 	{
 		return tokeniseInternal<wchar_t>(str, singleDelims, doubleDelims, maxSplits);
 	}
 
-    void StringUtil::toLowerCase(String& str)
-    {
-        std::transform(str.begin(), str.end(), str.begin(), tolower);
-    }
+	void StringUtil::toLowerCase(String& str)
+	{
+		std::transform(str.begin(), str.end(), str.begin(), tolower);
+	}
 
 	void StringUtil::toLowerCase(WString& str)
 	{
 		std::transform(str.begin(), str.end(), str.begin(), tolower);
 	}
 
-    void StringUtil::toUpperCase(String& str) 
-    {
-        std::transform(str.begin(), str.end(), str.begin(), toupper);
-    }
+	void StringUtil::toUpperCase(String& str) 
+	{
+		std::transform(str.begin(), str.end(), str.begin(), toupper);
+	}
 
 	void StringUtil::toUpperCase(WString& str) 
 	{
 		std::transform(str.begin(), str.end(), str.begin(), toupper);
 	}
 
-    bool StringUtil::startsWith(const String& str, const String& pattern, bool lowerCase)
-    {
-        return startsWithInternal<char>(str, pattern, lowerCase);
-    }
+	bool StringUtil::startsWith(const String& str, const String& pattern, bool lowerCase)
+	{
+		return startsWithInternal<char>(str, pattern, lowerCase);
+	}
 
 	bool StringUtil::startsWith(const WString& str, const WString& pattern, bool lowerCase)
 	{
 		return startsWithInternal<wchar_t>(str, pattern, lowerCase);
 	}
 
-    bool StringUtil::endsWith(const String& str, const String& pattern, bool lowerCase)
-    {
-        return endsWithInternal<char>(str, pattern, lowerCase);
-    }
+	bool StringUtil::endsWith(const String& str, const String& pattern, bool lowerCase)
+	{
+		return endsWithInternal<char>(str, pattern, lowerCase);
+	}
 
 	bool StringUtil::endsWith(const WString& str, const WString& pattern, bool lowerCase)
 	{
 		return endsWithInternal<wchar_t>(str, pattern, lowerCase);
 	}
 
-    bool StringUtil::match(const String& str, const String& pattern, bool caseSensitive)
-    {
-        return matchInternal<char>(str, pattern, caseSensitive);
-    }
+	bool StringUtil::match(const String& str, const String& pattern, bool caseSensitive)
+	{
+		return matchInternal<char>(str, pattern, caseSensitive);
+	}
 
 	bool StringUtil::match(const WString& str, const WString& pattern, bool caseSensitive)
 	{