FileSystem and Path moved to WString

BansheeEngine.sln

@@ -80,12 +80,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CamelotD3D11RenderSystem",
 		{CC7F9445-71C9-4559-9976-FF0A64DCB582} = {CC7F9445-71C9-4559-9976-FF0A64DCB582}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CamelotEditor", "CamelotEditor\CamelotEditor.vcxproj", "{B12702AD-ABFB-343A-A199-8E24837244A3}"
-	ProjectSection(ProjectDependencies) = postProject
-		{9B21D41C-516B-43BF-9B10-E99B599C7589} = {9B21D41C-516B-43BF-9B10-E99B599C7589}
-		{CC7F9445-71C9-4559-9976-FF0A64DCB582} = {CC7F9445-71C9-4559-9976-FF0A64DCB582}
-	EndProjectSection
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CamelotFontImporter", "CamelotFontImporter\CamelotTTFImporter.vcxproj", "{AB6C9284-D1CB-4AAD-BA4B-8A9E81AD1A73}"
 	ProjectSection(ProjectDependencies) = postProject
 		{9B21D41C-516B-43BF-9B10-E99B599C7589} = {9B21D41C-516B-43BF-9B10-E99B599C7589}
@@ -312,18 +306,6 @@ Global
 		{1437BB4E-DDB3-4307-AA41-8C035DA3014B}.Release|Win32.Build.0 = Release|Win32
 		{1437BB4E-DDB3-4307-AA41-8C035DA3014B}.Release|x64.ActiveCfg = Release|x64
 		{1437BB4E-DDB3-4307-AA41-8C035DA3014B}.Release|x64.Build.0 = Release|x64
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|Mixed Platforms.Build.0 = Debug|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|Win32.ActiveCfg = Debug|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Debug|x64.ActiveCfg = Debug|x64
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.DebugRelease|Mixed Platforms.ActiveCfg = DebugRelease|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.DebugRelease|Mixed Platforms.Build.0 = DebugRelease|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.DebugRelease|Win32.ActiveCfg = DebugRelease|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.DebugRelease|x64.ActiveCfg = DebugRelease|x64
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Release|Mixed Platforms.ActiveCfg = Release|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Release|Mixed Platforms.Build.0 = Release|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Release|Win32.ActiveCfg = Release|Win32
-		{B12702AD-ABFB-343A-A199-8E24837244A3}.Release|x64.ActiveCfg = Release|x64
 		{AB6C9284-D1CB-4AAD-BA4B-8A9E81AD1A73}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
 		{AB6C9284-D1CB-4AAD-BA4B-8A9E81AD1A73}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{AB6C9284-D1CB-4AAD-BA4B-8A9E81AD1A73}.Debug|Win32.ActiveCfg = Debug|Win32

BansheeEngine/Include/BsApplication.h

@@ -15,7 +15,7 @@ namespace BansheeEngine
 			 * @brief	Starts the application using the specified options. 
 			 * 			This is how you start the engine.
 			 */
-			void startUp(CM::RENDER_WINDOW_DESC& primaryWindowDesc, const CM::String& renderSystem, const CM::String& renderer, const CM::String& resourceCacheDir);
+			void startUp(CM::RENDER_WINDOW_DESC& primaryWindowDesc, const CM::String& renderSystem, const CM::String& renderer, const CM::WString& resourceCacheDir);
 
 			/**
 			 * @brief	Executes the main loop. This will cause actually rendering to be performed

BansheeEngine/Include/BsEngineGUI.h

@@ -16,65 +16,65 @@ namespace BansheeEngine
 	private:
 		GUISkin mSkin;
 
-		static const CM::String DefaultFolder;
+		static const CM::WString DefaultFolder;
 
-		static const CM::String DefaultFontPath;
+		static const CM::WString DefaultFontPath;
 		static const CM::UINT32 DefaultFontSize;
 
-		static const CM::String ButtonNormalTex;
-		static const CM::String ButtonHoverTex;
+		static const CM::WString ButtonNormalTex;
+		static const CM::WString ButtonHoverTex;
 
-		static const CM::String InputBoxNormalTex;
-		static const CM::String InputBoxHoverTex;
-		static const CM::String InputBoxFocusedTex;
+		static const CM::WString InputBoxNormalTex;
+		static const CM::WString InputBoxHoverTex;
+		static const CM::WString InputBoxFocusedTex;
 
-		static const CM::String ScrollBarUpNormalTex;
-		static const CM::String ScrollBarUpHoverTex;
-		static const CM::String ScrollBarUpActiveTex;
+		static const CM::WString ScrollBarUpNormalTex;
+		static const CM::WString ScrollBarUpHoverTex;
+		static const CM::WString ScrollBarUpActiveTex;
 
-		static const CM::String ScrollBarDownNormalTex;
-		static const CM::String ScrollBarDownHoverTex;
-		static const CM::String ScrollBarDownActiveTex;
+		static const CM::WString ScrollBarDownNormalTex;
+		static const CM::WString ScrollBarDownHoverTex;
+		static const CM::WString ScrollBarDownActiveTex;
 
-		static const CM::String ScrollBarLeftNormalTex;
-		static const CM::String ScrollBarLeftHoverTex;
-		static const CM::String ScrollBarLeftActiveTex;
+		static const CM::WString ScrollBarLeftNormalTex;
+		static const CM::WString ScrollBarLeftHoverTex;
+		static const CM::WString ScrollBarLeftActiveTex;
 
-		static const CM::String ScrollBarRightNormalTex;
-		static const CM::String ScrollBarRightHoverTex;
-		static const CM::String ScrollBarRightActiveTex;
+		static const CM::WString ScrollBarRightNormalTex;
+		static const CM::WString ScrollBarRightHoverTex;
+		static const CM::WString ScrollBarRightActiveTex;
 
-		static const CM::String ScrollBarHandleHorzNormalTex;
-		static const CM::String ScrollBarHandleHorzHoverTex;
-		static const CM::String ScrollBarHandleHorzActiveTex;
+		static const CM::WString ScrollBarHandleHorzNormalTex;
+		static const CM::WString ScrollBarHandleHorzHoverTex;
+		static const CM::WString ScrollBarHandleHorzActiveTex;
 
-		static const CM::String ScrollBarHandleVertNormalTex;
-		static const CM::String ScrollBarHandleVertHoverTex;
-		static const CM::String ScrollBarHandleVertActiveTex;
+		static const CM::WString ScrollBarHandleVertNormalTex;
+		static const CM::WString ScrollBarHandleVertHoverTex;
+		static const CM::WString ScrollBarHandleVertActiveTex;
 
-		static const CM::String ScrollBarBgTex;
+		static const CM::WString ScrollBarBgTex;
 
-		static const CM::String DropDownBtnNormalTex;
-		static const CM::String DropDownBtnHoverTex;
+		static const CM::WString DropDownBtnNormalTex;
+		static const CM::WString DropDownBtnHoverTex;
 
-		static const CM::String DropDownBoxBgTex;
-		static const CM::String DropDownBoxEntryNormalTex;
-		static const CM::String DropDownBoxEntryHoverTex;
+		static const CM::WString DropDownBoxBgTex;
+		static const CM::WString DropDownBoxEntryNormalTex;
+		static const CM::WString DropDownBoxEntryHoverTex;
 
-		static const CM::String DropDownBoxBtnUpNormalTex;
-		static const CM::String DropDownBoxBtnUpHoverTex;
+		static const CM::WString DropDownBoxBtnUpNormalTex;
+		static const CM::WString DropDownBoxBtnUpHoverTex;
 
-		static const CM::String DropDownBoxBtnDownNormalTex;
-		static const CM::String DropDownBoxBtnDownHoverTex;
+		static const CM::WString DropDownBoxBtnDownNormalTex;
+		static const CM::WString DropDownBoxBtnDownHoverTex;
 
-		static const CM::String DropDownBoxEntryExpNormalTex;
-		static const CM::String DropDownBoxEntryExpHoverTex;
+		static const CM::WString DropDownBoxEntryExpNormalTex;
+		static const CM::WString DropDownBoxEntryExpHoverTex;
 
-		static const CM::String DropDownSeparatorTex;
+		static const CM::WString DropDownSeparatorTex;
 
-		static const CM::String DropDownBoxBtnUpArrowTex;
-		static const CM::String DropDownBoxBtnDownArrowTex;
+		static const CM::WString DropDownBoxBtnUpArrowTex;
+		static const CM::WString DropDownBoxBtnDownArrowTex;
 
-		static HSpriteTexture getTexture(const CM::String& name);
+		static HSpriteTexture getTexture(const CM::WString& name);
 	};
 }

BansheeEngine/Source/BsApplication.cpp

@@ -23,7 +23,7 @@ namespace BansheeEngine
 
 	}
 
-	void Application::startUp(RENDER_WINDOW_DESC& primaryWindowDesc, const String& renderSystem, const String& renderer, const String& resourceCacheDir)
+	void Application::startUp(RENDER_WINDOW_DESC& primaryWindowDesc, const String& renderSystem, const String& renderer, const WString& resourceCacheDir)
 	{
 		CM::START_UP_DESC desc;
 		desc.renderSystem = renderSystem;

BansheeEngine/Source/BsEngineGUI.cpp

@@ -17,64 +17,64 @@ using namespace CamelotFramework;
 
 namespace BansheeEngine
 {
-	const String EngineGUI::DefaultFontPath = "arial.ttf";
+	const WString EngineGUI::DefaultFontPath = L"arial.ttf";
 	const UINT32 EngineGUI::DefaultFontSize = 10;
 
-	const String EngineGUI::DefaultFolder = "..\\..\\..\\..\\Data\\Engine\\Skin\\";
+	const WString EngineGUI::DefaultFolder = L"..\\..\\..\\..\\Data\\Engine\\Skin\\";
 
-	const String EngineGUI::ButtonNormalTex = "ButtonNormal.psd";
-	const String EngineGUI::ButtonHoverTex = "ButtonHover.psd";
+	const WString EngineGUI::ButtonNormalTex = L"ButtonNormal.psd";
+	const WString EngineGUI::ButtonHoverTex = L"ButtonHover.psd";
 
-	const String EngineGUI::InputBoxNormalTex = "InputBoxNormal.psd";
-	const String EngineGUI::InputBoxHoverTex = "InputBoxHover.psd";
-	const String EngineGUI::InputBoxFocusedTex = "InputBoxFocused.psd";
+	const WString EngineGUI::InputBoxNormalTex = L"InputBoxNormal.psd";
+	const WString EngineGUI::InputBoxHoverTex = L"InputBoxHover.psd";
+	const WString EngineGUI::InputBoxFocusedTex = L"InputBoxFocused.psd";
 
-	const String EngineGUI::ScrollBarUpNormalTex = "ScrollBarUpNormal.psd";
-	const String EngineGUI::ScrollBarUpHoverTex = "ScrollBarUpHover.psd";
-	const String EngineGUI::ScrollBarUpActiveTex = "ScrollBarUpActive.psd";
+	const WString EngineGUI::ScrollBarUpNormalTex = L"ScrollBarUpNormal.psd";
+	const WString EngineGUI::ScrollBarUpHoverTex = L"ScrollBarUpHover.psd";
+	const WString EngineGUI::ScrollBarUpActiveTex = L"ScrollBarUpActive.psd";
 
-	const String EngineGUI::ScrollBarDownNormalTex = "ScrollBarDownNormal.psd";
-	const String EngineGUI::ScrollBarDownHoverTex = "ScrollBarDownHover.psd";
-	const String EngineGUI::ScrollBarDownActiveTex = "ScrollBarDownActive.psd";
+	const WString EngineGUI::ScrollBarDownNormalTex = L"ScrollBarDownNormal.psd";
+	const WString EngineGUI::ScrollBarDownHoverTex = L"ScrollBarDownHover.psd";
+	const WString EngineGUI::ScrollBarDownActiveTex = L"ScrollBarDownActive.psd";
 
-	const String EngineGUI::ScrollBarLeftNormalTex = "ScrollBarLeftNormal.psd";
-	const String EngineGUI::ScrollBarLeftHoverTex = "ScrollBarLeftHover.psd";
-	const String EngineGUI::ScrollBarLeftActiveTex = "ScrollBarLeftActive.psd";
+	const WString EngineGUI::ScrollBarLeftNormalTex = L"ScrollBarLeftNormal.psd";
+	const WString EngineGUI::ScrollBarLeftHoverTex = L"ScrollBarLeftHover.psd";
+	const WString EngineGUI::ScrollBarLeftActiveTex = L"ScrollBarLeftActive.psd";
 
-	const String EngineGUI::ScrollBarRightNormalTex = "ScrollBarRightNormal.psd";
-	const String EngineGUI::ScrollBarRightHoverTex = "ScrollBarRightHover.psd";
-	const String EngineGUI::ScrollBarRightActiveTex = "ScrollBarRightActive.psd";
+	const WString EngineGUI::ScrollBarRightNormalTex = L"ScrollBarRightNormal.psd";
+	const WString EngineGUI::ScrollBarRightHoverTex = L"ScrollBarRightHover.psd";
+	const WString EngineGUI::ScrollBarRightActiveTex = L"ScrollBarRightActive.psd";
 
-	const String EngineGUI::ScrollBarHandleHorzNormalTex = "ScrollBarHorzHandleNormal.psd";
-	const String EngineGUI::ScrollBarHandleHorzHoverTex = "ScrollBarHorzHandleHover.psd";
-	const String EngineGUI::ScrollBarHandleHorzActiveTex = "ScrollBarHorzHandleActive.psd";
+	const WString EngineGUI::ScrollBarHandleHorzNormalTex = L"ScrollBarHorzHandleNormal.psd";
+	const WString EngineGUI::ScrollBarHandleHorzHoverTex = L"ScrollBarHorzHandleHover.psd";
+	const WString EngineGUI::ScrollBarHandleHorzActiveTex = L"ScrollBarHorzHandleActive.psd";
 
-	const String EngineGUI::ScrollBarHandleVertNormalTex = "ScrollBarVertHandleNormal.psd";
-	const String EngineGUI::ScrollBarHandleVertHoverTex = "ScrollBarVertHandleHover.psd";
-	const String EngineGUI::ScrollBarHandleVertActiveTex = "ScrollBarVertHandleActive.psd";
+	const WString EngineGUI::ScrollBarHandleVertNormalTex = L"ScrollBarVertHandleNormal.psd";
+	const WString EngineGUI::ScrollBarHandleVertHoverTex = L"ScrollBarVertHandleHover.psd";
+	const WString EngineGUI::ScrollBarHandleVertActiveTex = L"ScrollBarVertHandleActive.psd";
 
-	const String EngineGUI::DropDownBtnNormalTex = "DropDownNormal.psd";
-	const String EngineGUI::DropDownBtnHoverTex = "DropDownHover.psd";
+	const WString EngineGUI::DropDownBtnNormalTex = L"DropDownNormal.psd";
+	const WString EngineGUI::DropDownBtnHoverTex = L"DropDownHover.psd";
 
-	const String EngineGUI::DropDownBoxBgTex = "DropDownBoxBg.psd";
-	const String EngineGUI::DropDownBoxEntryNormalTex = "DropDownButtonNormal.psd";
-	const String EngineGUI::DropDownBoxEntryHoverTex = "DropDownButtonHover.psd";
+	const WString EngineGUI::DropDownBoxBgTex = L"DropDownBoxBg.psd";
+	const WString EngineGUI::DropDownBoxEntryNormalTex = L"DropDownButtonNormal.psd";
+	const WString EngineGUI::DropDownBoxEntryHoverTex = L"DropDownButtonHover.psd";
 
-	const String EngineGUI::DropDownBoxBtnUpNormalTex = "DropDownBoxBtnUpNormal.psd";
-	const String EngineGUI::DropDownBoxBtnUpHoverTex = "DropDownBoxBtnUpHover.psd";
+	const WString EngineGUI::DropDownBoxBtnUpNormalTex = L"DropDownBoxBtnUpNormal.psd";
+	const WString EngineGUI::DropDownBoxBtnUpHoverTex = L"DropDownBoxBtnUpHover.psd";
 
-	const String EngineGUI::DropDownBoxBtnDownNormalTex = "DropDownBoxBtnDownNormal.psd";
-	const String EngineGUI::DropDownBoxBtnDownHoverTex = "DropDownBoxBtnDownHover.psd";
+	const WString EngineGUI::DropDownBoxBtnDownNormalTex = L"DropDownBoxBtnDownNormal.psd";
+	const WString EngineGUI::DropDownBoxBtnDownHoverTex = L"DropDownBoxBtnDownHover.psd";
 
-	const String EngineGUI::DropDownBoxEntryExpNormalTex = "DropDownExpNormal.psd";
-	const String EngineGUI::DropDownBoxEntryExpHoverTex = "DropDownExpHover.psd";
+	const WString EngineGUI::DropDownBoxEntryExpNormalTex = L"DropDownExpNormal.psd";
+	const WString EngineGUI::DropDownBoxEntryExpHoverTex = L"DropDownExpHover.psd";
 
-	const String EngineGUI::DropDownSeparatorTex = "DropDownSeparator.psd";
+	const WString EngineGUI::DropDownSeparatorTex = L"DropDownSeparator.psd";
 
-	const String EngineGUI::DropDownBoxBtnUpArrowTex = "DropDownBoxBtnUpArrow.psd";
-	const String EngineGUI::DropDownBoxBtnDownArrowTex = "DropDownBoxBtnDownArrow.psd";
+	const WString EngineGUI::DropDownBoxBtnUpArrowTex = L"DropDownBoxBtnUpArrow.psd";
+	const WString EngineGUI::DropDownBoxBtnDownArrowTex = L"DropDownBoxBtnDownArrow.psd";
 
-	const String EngineGUI::ScrollBarBgTex = "ScrollBarBg.psd";
+	const WString EngineGUI::ScrollBarBgTex = L"ScrollBarBg.psd";
 
 	EngineGUI::EngineGUI()
 	{
@@ -85,7 +85,7 @@ namespace BansheeEngine
 		HFont font;
 
 		{
-			String fontPath = DefaultFolder + DefaultFontPath;
+			WString fontPath = DefaultFolder + DefaultFontPath;
 			ImportOptionsPtr fontImportOptions = Importer::instance().createImportOptions(fontPath);
 			if(rtti_is_of_type<FontImportOptions>(fontImportOptions))
 			{
@@ -447,8 +447,8 @@ namespace BansheeEngine
 		mSkin.setStyle("ContextMenuSeparator", dropDownSeparatorStyle);
 	}
 
-	HSpriteTexture EngineGUI::getTexture(const CM::String& name)
+	HSpriteTexture EngineGUI::getTexture(const CM::WString& name)
 	{
-		return SpriteTexture::create(static_resource_cast<Texture>(Importer::instance().import(FileSystem::getCurrentPath() + "\\" + DefaultFolder + name)));
+		return SpriteTexture::create(static_resource_cast<Texture>(Importer::instance().import(FileSystem::getWorkingDirectoryPath() + L"\\" + DefaultFolder + name)));
 	}
 }

CamelotClient/Include/BsEditorGUI.h

@@ -16,104 +16,104 @@ namespace BansheeEditor
 	private:
 		BS::GUISkin mSkin;
 
-		static const CM::String DefaultFolder;
+		static const CM::WString DefaultFolder;
 
-		static const CM::String DefaultFontPath;
+		static const CM::WString DefaultFontPath;
 		static const CM::UINT32 DefaultFontSize;
 
-		static const CM::String WindowBackgroundTexture;
+		static const CM::WString WindowBackgroundTexture;
 
-		static const CM::String WindowFrameNormal;
-		static const CM::String WindowFrameFocused;
+		static const CM::WString WindowFrameNormal;
+		static const CM::WString WindowFrameFocused;
 
-		static const CM::String WindowTitleBarBg;
+		static const CM::WString WindowTitleBarBg;
 
-		static const CM::String WindowCloseButtonNormal;
-		static const CM::String WindowCloseButtonHover;
+		static const CM::WString WindowCloseButtonNormal;
+		static const CM::WString WindowCloseButtonHover;
 
-		static const CM::String WindowMinButtonNormal;
-		static const CM::String WindowMinButtonHover;
+		static const CM::WString WindowMinButtonNormal;
+		static const CM::WString WindowMinButtonHover;
 
-		static const CM::String WindowMaxButtonNormal;
-		static const CM::String WindowMaxButtonHover;
+		static const CM::WString WindowMaxButtonNormal;
+		static const CM::WString WindowMaxButtonHover;
 
-		static const CM::String TabbedBarBtnNormal;
-		static const CM::String TabbedBarBtnActive;
+		static const CM::WString TabbedBarBtnNormal;
+		static const CM::WString TabbedBarBtnActive;
 
-		static const CM::String ButtonNormalTex;
-		static const CM::String ButtonHoverTex;
+		static const CM::WString ButtonNormalTex;
+		static const CM::WString ButtonHoverTex;
 
-		static const CM::String InputBoxNormalTex;
-		static const CM::String InputBoxHoverTex;
-		static const CM::String InputBoxFocusedTex;
+		static const CM::WString InputBoxNormalTex;
+		static const CM::WString InputBoxHoverTex;
+		static const CM::WString InputBoxFocusedTex;
 
-		static const CM::String ScrollBarUpNormalTex;
-		static const CM::String ScrollBarUpHoverTex;
-		static const CM::String ScrollBarUpActiveTex;
+		static const CM::WString ScrollBarUpNormalTex;
+		static const CM::WString ScrollBarUpHoverTex;
+		static const CM::WString ScrollBarUpActiveTex;
 
-		static const CM::String ScrollBarDownNormalTex;
-		static const CM::String ScrollBarDownHoverTex;
-		static const CM::String ScrollBarDownActiveTex;
+		static const CM::WString ScrollBarDownNormalTex;
+		static const CM::WString ScrollBarDownHoverTex;
+		static const CM::WString ScrollBarDownActiveTex;
 
-		static const CM::String ScrollBarLeftNormalTex;
-		static const CM::String ScrollBarLeftHoverTex;
-		static const CM::String ScrollBarLeftActiveTex;
+		static const CM::WString ScrollBarLeftNormalTex;
+		static const CM::WString ScrollBarLeftHoverTex;
+		static const CM::WString ScrollBarLeftActiveTex;
 
-		static const CM::String ScrollBarRightNormalTex;
-		static const CM::String ScrollBarRightHoverTex;
-		static const CM::String ScrollBarRightActiveTex;
+		static const CM::WString ScrollBarRightNormalTex;
+		static const CM::WString ScrollBarRightHoverTex;
+		static const CM::WString ScrollBarRightActiveTex;
 
-		static const CM::String ScrollBarHandleHorzNormalTex;
-		static const CM::String ScrollBarHandleHorzHoverTex;
-		static const CM::String ScrollBarHandleHorzActiveTex;
+		static const CM::WString ScrollBarHandleHorzNormalTex;
+		static const CM::WString ScrollBarHandleHorzHoverTex;
+		static const CM::WString ScrollBarHandleHorzActiveTex;
 
-		static const CM::String ScrollBarHandleVertNormalTex;
-		static const CM::String ScrollBarHandleVertHoverTex;
-		static const CM::String ScrollBarHandleVertActiveTex;
+		static const CM::WString ScrollBarHandleVertNormalTex;
+		static const CM::WString ScrollBarHandleVertHoverTex;
+		static const CM::WString ScrollBarHandleVertActiveTex;
 
-		static const CM::String ScrollBarBgTex;
+		static const CM::WString ScrollBarBgTex;
 
-		static const CM::String DropDownBtnNormalTex;
-		static const CM::String DropDownBtnHoverTex;
+		static const CM::WString DropDownBtnNormalTex;
+		static const CM::WString DropDownBtnHoverTex;
 
-		static const CM::String DropDownBoxBgTex;
-		static const CM::String DropDownBoxEntryNormalTex;
-		static const CM::String DropDownBoxEntryHoverTex;
+		static const CM::WString DropDownBoxBgTex;
+		static const CM::WString DropDownBoxEntryNormalTex;
+		static const CM::WString DropDownBoxEntryHoverTex;
 
-		static const CM::String DropDownBoxBtnUpNormalTex;
-		static const CM::String DropDownBoxBtnUpHoverTex;
+		static const CM::WString DropDownBoxBtnUpNormalTex;
+		static const CM::WString DropDownBoxBtnUpHoverTex;
 
-		static const CM::String DropDownBoxBtnDownNormalTex;
-		static const CM::String DropDownBoxBtnDownHoverTex;
+		static const CM::WString DropDownBoxBtnDownNormalTex;
+		static const CM::WString DropDownBoxBtnDownHoverTex;
 
-		static const CM::String DropDownBoxEntryExpNormalTex;
-		static const CM::String DropDownBoxEntryExpHoverTex;
+		static const CM::WString DropDownBoxEntryExpNormalTex;
+		static const CM::WString DropDownBoxEntryExpHoverTex;
 
-		static const CM::String DropDownSeparatorTex;
+		static const CM::WString DropDownSeparatorTex;
 
-		static const CM::String DropDownBoxBtnUpArrowTex;
-		static const CM::String DropDownBoxBtnDownArrowTex;
+		static const CM::WString DropDownBoxBtnUpArrowTex;
+		static const CM::WString DropDownBoxBtnDownArrowTex;
 
-		static const CM::String MenuBarBgTex;
+		static const CM::WString MenuBarBgTex;
 
-		static const CM::String MenuBarBtnNormalTex;
-		static const CM::String MenuBarBtnHoverTex;
+		static const CM::WString MenuBarBtnNormalTex;
+		static const CM::WString MenuBarBtnHoverTex;
 
-		static const CM::String MenuBarBansheeLogoTex;
+		static const CM::WString MenuBarBansheeLogoTex;
 
-		static const CM::String DockSliderNormalTex;
+		static const CM::WString DockSliderNormalTex;
 
-		static const CM::String TreeViewExpandButtonOffNormal;
-		static const CM::String TreeViewExpandButtonOffHover;
-		static const CM::String TreeViewExpandButtonOnNormal;
-		static const CM::String TreeViewExpandButtonOnHover;
+		static const CM::WString TreeViewExpandButtonOffNormal;
+		static const CM::WString TreeViewExpandButtonOffHover;
+		static const CM::WString TreeViewExpandButtonOnNormal;
+		static const CM::WString TreeViewExpandButtonOnHover;
 
-		static const CM::String TreeViewSelectionBackground;
-		static const CM::String TreeViewEditBox;
+		static const CM::WString TreeViewSelectionBackground;
+		static const CM::WString TreeViewEditBox;
 
-		static const CM::String TreeViewElementHighlight;
-		static const CM::String TreeViewElementSepHighlight;
+		static const CM::WString TreeViewElementHighlight;
+		static const CM::WString TreeViewElementSepHighlight;
 
-		static BS::HSpriteTexture getTexture(const CM::String& name);
+		static BS::HSpriteTexture getTexture(const CM::WString& name);
 	};
 }

CamelotClient/Source/BsEditorApplication.cpp

@@ -40,7 +40,7 @@ namespace BansheeEditor
 		renderWindowDesc.border = WindowBorder::None;
 
 		const String& renderSystemLibraryName = getLibraryNameForRenderSystem(renderSystemPlugin);
-		gBansheeApp().startUp(renderWindowDesc, renderSystemLibraryName, "BansheeForwardRenderer", "D:\\CamelotResourceMetas"); // TODO - Make renderer and resource cache dir customizable
+		gBansheeApp().startUp(renderWindowDesc, renderSystemLibraryName, "BansheeForwardRenderer", L"D:\\CamelotResourceMetas"); // TODO - Make renderer and resource cache dir customizable
 		EditorGUI::startUp(cm_new<EditorGUI>());
 
 		{
@@ -66,8 +66,8 @@ namespace BansheeEditor
 		HSceneObject testModelGO = SceneObject::create("TestMesh");
 		HRenderable testRenderable = testModelGO->addComponent<Renderable>();
 
-		String psLoc;
-		String vsLoc;
+		WString psLoc;
+		WString vsLoc;
 
 		GpuProgramProfile psProfile;
 		GpuProgramProfile vsProfile;
@@ -81,8 +81,8 @@ namespace BansheeEditor
 		{
 		case RenderSystemPlugin::DX11:
 			{
-				psLoc = "C:\\Projects\\BansheeEngine\\Data\\hlsl11_ps.gpuprog";
-				vsLoc = "C:\\Projects\\BansheeEngine\\Data\\hlsl11_vs.gpuprog";
+				psLoc = L"C:\\Projects\\BansheeEngine\\Data\\hlsl11_ps.gpuprog";
+				vsLoc = L"C:\\Projects\\BansheeEngine\\Data\\hlsl11_vs.gpuprog";
 				language = "hlsl";
 				psProfile = GPP_PS_4_0;
 				vsProfile = GPP_VS_4_0;
@@ -92,8 +92,8 @@ namespace BansheeEditor
 			}
 		case RenderSystemPlugin::DX9:
 			{
-				psLoc = "C:\\Projects\\BansheeEngine\\Data\\hlsl9_ps.gpuprog";
-				vsLoc = "C:\\Projects\\BansheeEngine\\Data\\hlsl9_vs.gpuprog";
+				psLoc = L"C:\\Projects\\BansheeEngine\\Data\\hlsl9_ps.gpuprog";
+				vsLoc = L"C:\\Projects\\BansheeEngine\\Data\\hlsl9_vs.gpuprog";
 				language = "hlsl";
 				psProfile = GPP_PS_2_0;
 				vsProfile = GPP_VS_2_0;
@@ -103,8 +103,8 @@ namespace BansheeEditor
 			}
 		case RenderSystemPlugin::OpenGL:
 			{
-				psLoc = "C:\\Projects\\BansheeEngine\\Data\\glsl_ps.gpuprog";
-				vsLoc = "C:\\Projects\\BansheeEngine\\Data\\glsl_vs.gpuprog";
+				psLoc = L"C:\\Projects\\BansheeEngine\\Data\\glsl_ps.gpuprog";
+				vsLoc = L"C:\\Projects\\BansheeEngine\\Data\\glsl_vs.gpuprog";
 				language = "glsl";
 				psProfile = GPP_PS_2_0;
 				vsProfile = GPP_VS_2_0;
@@ -140,13 +140,13 @@ namespace BansheeEditor
 
 		HHighLevelGpuProgram vertProgRef = Importer::instance().import(vsLoc, gpuProgImportOptions);
 
-		gResources().create(vertProgRef, "C:\\vertProgCg.vprog", true);
+		gResources().create(vertProgRef, L"C:\\vertProgCg.vprog", true);
 		gResources().unload(vertProgRef);
-		vertProgRef = gResources().load("C:\\vertProgCg.vprog");
+		vertProgRef = gResources().load(L"C:\\vertProgCg.vprog");
 
-		gResources().create(fragProgRef, "C:\\fragProgCg.vprog", true);
+		gResources().create(fragProgRef, L"C:\\fragProgCg.vprog", true);
 		gResources().unload(fragProgRef);
-		fragProgRef = gResources().load("C:\\fragProgCg.vprog");
+		fragProgRef = gResources().load(L"C:\\fragProgCg.vprog");
 
 		ShaderPtr testShader = Shader::create("TestShader");
 
@@ -194,27 +194,27 @@ namespace BansheeEditor
 			testMaterial->setStructData("input", dbgMultipliers2, sizeof(dbgMultipliers2), 1);
 		}
 
-		HTexture testTexRef = static_resource_cast<Texture>(Importer::instance().import("C:\\ArenaTowerDFS.psd"));
-		HMesh dbgMeshRef = static_resource_cast<Mesh>(Importer::instance().import("C:\\X_Arena_Tower.FBX"));
+		HTexture testTexRef = static_resource_cast<Texture>(Importer::instance().import(L"C:\\ArenaTowerDFS.psd"));
+		HMesh dbgMeshRef = static_resource_cast<Mesh>(Importer::instance().import(L"C:\\X_Arena_Tower.FBX"));
 
-		gResources().create(testTexRef, "C:\\ExportTest.tex", true);
-		gResources().create(dbgMeshRef, "C:\\ExportMesh.mesh", true);
+		gResources().create(testTexRef, L"C:\\ExportTest.tex", true);
+		gResources().create(dbgMeshRef, L"C:\\ExportMesh.mesh", true);
 
 		gResources().unload(testTexRef);
 		gResources().unload(dbgMeshRef);
 
-		testTexRef = static_resource_cast<Texture>(gResources().loadAsync("C:\\ExportTest.tex"));
-		dbgMeshRef = static_resource_cast<Mesh>(gResources().loadAsync("C:\\ExportMesh.mesh"));
+		testTexRef = static_resource_cast<Texture>(gResources().loadAsync(L"C:\\ExportTest.tex"));
+		dbgMeshRef = static_resource_cast<Mesh>(gResources().loadAsync(L"C:\\ExportMesh.mesh"));
 
 		dbgMeshRef.synchronize();
 		testTexRef.synchronize();
 
 		testMaterial->setTexture("tex", testTexRef);
-		gResources().create(testMaterial, "C:\\ExportMaterial.mat", true);
+		gResources().create(testMaterial, L"C:\\ExportMaterial.mat", true);
 
 		gResources().unload(testMaterial);
 
-		testMaterial = gResources().load("C:\\ExportMaterial.mat");
+		testMaterial = gResources().load(L"C:\\ExportMaterial.mat");
 
 		testRenderable->setMesh(dbgMeshRef);
 		testRenderable->setMaterial(0, testMaterial);
@@ -228,7 +228,7 @@ namespace BansheeEditor
 		testModelGO->destroy();
 
 
-		HTexture dbgCursor = static_resource_cast<Texture>(Importer::instance().import("C:\\CursorDbg.psd"));
+		HTexture dbgCursor = static_resource_cast<Texture>(Importer::instance().import(L"C:\\CursorDbg.psd"));
 		PixelDataPtr cursorPixelData = dbgCursor->allocateSubresourceBuffer(0);
 
 		gMainSyncedCA().readSubresource(dbgCursor.getInternalPtr(), 0, cursorPixelData);

CamelotClient/Source/BsEditorGUI.cpp

@@ -19,102 +19,102 @@ using namespace BansheeEngine;
 
 namespace BansheeEditor
 {
-	const String EditorGUI::DefaultFontPath = "arial.ttf";
+	const WString EditorGUI::DefaultFontPath = L"arial.ttf";
 	const UINT32 EditorGUI::DefaultFontSize = 10;
 
-	const String EditorGUI::DefaultFolder = "..\\..\\..\\..\\Data\\Editor\\Skin\\";
+	const WString EditorGUI::DefaultFolder = L"..\\..\\..\\..\\Data\\Editor\\Skin\\";
 
-	const String EditorGUI::WindowBackgroundTexture = "WindowBgTile.psd";
+	const WString EditorGUI::WindowBackgroundTexture = L"WindowBgTile.psd";
 
-	const String EditorGUI::ButtonNormalTex = "ButtonNormal.psd";
-	const String EditorGUI::ButtonHoverTex = "ButtonHover.psd";
+	const WString EditorGUI::ButtonNormalTex = L"ButtonNormal.psd";
+	const WString EditorGUI::ButtonHoverTex = L"ButtonHover.psd";
 
-	const String EditorGUI::WindowFrameNormal = "WindowFrameNormal.psd";
-	const String EditorGUI::WindowFrameFocused = "WindowFrameFocused.psd";
+	const WString EditorGUI::WindowFrameNormal = L"WindowFrameNormal.psd";
+	const WString EditorGUI::WindowFrameFocused = L"WindowFrameFocused.psd";
 
-	const String EditorGUI::WindowTitleBarBg = "WindowTitleBarBg.psd";
+	const WString EditorGUI::WindowTitleBarBg = L"WindowTitleBarBg.psd";
 
-	const String EditorGUI::WindowCloseButtonNormal = "WindowCloseBtnNormal.psd";
-	const String EditorGUI::WindowCloseButtonHover = "WindowCloseBtnHover.psd";
+	const WString EditorGUI::WindowCloseButtonNormal = L"WindowCloseBtnNormal.psd";
+	const WString EditorGUI::WindowCloseButtonHover = L"WindowCloseBtnHover.psd";
 
-	const String EditorGUI::WindowMinButtonNormal = "WindowMaxBtnNormal.psd";
-	const String EditorGUI::WindowMinButtonHover = "WindowMaxBtnHover.psd";
+	const WString EditorGUI::WindowMinButtonNormal = L"WindowMaxBtnNormal.psd";
+	const WString EditorGUI::WindowMinButtonHover = L"WindowMaxBtnHover.psd";
 
-	const String EditorGUI::WindowMaxButtonNormal = "WindowMinBtnNormal.psd";
-	const String EditorGUI::WindowMaxButtonHover = "WindowMinBtnHover.psd";
+	const WString EditorGUI::WindowMaxButtonNormal = L"WindowMinBtnNormal.psd";
+	const WString EditorGUI::WindowMaxButtonHover = L"WindowMinBtnHover.psd";
 
-	const String EditorGUI::TabbedBarBtnNormal = "TabbedButtonNormal.psd";
-	const String EditorGUI::TabbedBarBtnActive = "TabbedButtonActive.psd";
+	const WString EditorGUI::TabbedBarBtnNormal = L"TabbedButtonNormal.psd";
+	const WString EditorGUI::TabbedBarBtnActive = L"TabbedButtonActive.psd";
 
-	const String EditorGUI::InputBoxNormalTex = "InputBoxNormal.psd";
-	const String EditorGUI::InputBoxHoverTex = "InputBoxHover.psd";
-	const String EditorGUI::InputBoxFocusedTex = "InputBoxFocused.psd";
+	const WString EditorGUI::InputBoxNormalTex = L"InputBoxNormal.psd";
+	const WString EditorGUI::InputBoxHoverTex = L"InputBoxHover.psd";
+	const WString EditorGUI::InputBoxFocusedTex = L"InputBoxFocused.psd";
 
-	const String EditorGUI::ScrollBarUpNormalTex = "ScrollBarUpNormal.psd";
-	const String EditorGUI::ScrollBarUpHoverTex = "ScrollBarUpHover.psd";
-	const String EditorGUI::ScrollBarUpActiveTex = "ScrollBarUpActive.psd";
+	const WString EditorGUI::ScrollBarUpNormalTex = L"ScrollBarUpNormal.psd";
+	const WString EditorGUI::ScrollBarUpHoverTex = L"ScrollBarUpHover.psd";
+	const WString EditorGUI::ScrollBarUpActiveTex = L"ScrollBarUpActive.psd";
 
-	const String EditorGUI::ScrollBarDownNormalTex = "ScrollBarDownNormal.psd";
-	const String EditorGUI::ScrollBarDownHoverTex = "ScrollBarDownHover.psd";
-	const String EditorGUI::ScrollBarDownActiveTex = "ScrollBarDownActive.psd";
+	const WString EditorGUI::ScrollBarDownNormalTex = L"ScrollBarDownNormal.psd";
+	const WString EditorGUI::ScrollBarDownHoverTex = L"ScrollBarDownHover.psd";
+	const WString EditorGUI::ScrollBarDownActiveTex = L"ScrollBarDownActive.psd";
 
-	const String EditorGUI::ScrollBarLeftNormalTex = "ScrollBarLeftNormal.psd";
-	const String EditorGUI::ScrollBarLeftHoverTex = "ScrollBarLeftHover.psd";
-	const String EditorGUI::ScrollBarLeftActiveTex = "ScrollBarLeftActive.psd";
+	const WString EditorGUI::ScrollBarLeftNormalTex = L"ScrollBarLeftNormal.psd";
+	const WString EditorGUI::ScrollBarLeftHoverTex = L"ScrollBarLeftHover.psd";
+	const WString EditorGUI::ScrollBarLeftActiveTex = L"ScrollBarLeftActive.psd";
 
-	const String EditorGUI::ScrollBarRightNormalTex = "ScrollBarRightNormal.psd";
-	const String EditorGUI::ScrollBarRightHoverTex = "ScrollBarRightHover.psd";
-	const String EditorGUI::ScrollBarRightActiveTex = "ScrollBarRightActive.psd";
+	const WString EditorGUI::ScrollBarRightNormalTex = L"ScrollBarRightNormal.psd";
+	const WString EditorGUI::ScrollBarRightHoverTex = L"ScrollBarRightHover.psd";
+	const WString EditorGUI::ScrollBarRightActiveTex = L"ScrollBarRightActive.psd";
 
-	const String EditorGUI::ScrollBarHandleHorzNormalTex = "ScrollBarHorzHandleNormal.psd";
-	const String EditorGUI::ScrollBarHandleHorzHoverTex = "ScrollBarHorzHandleHover.psd";
-	const String EditorGUI::ScrollBarHandleHorzActiveTex = "ScrollBarHorzHandleActive.psd";
+	const WString EditorGUI::ScrollBarHandleHorzNormalTex = L"ScrollBarHorzHandleNormal.psd";
+	const WString EditorGUI::ScrollBarHandleHorzHoverTex = L"ScrollBarHorzHandleHover.psd";
+	const WString EditorGUI::ScrollBarHandleHorzActiveTex = L"ScrollBarHorzHandleActive.psd";
 
-	const String EditorGUI::ScrollBarHandleVertNormalTex = "ScrollBarVertHandleNormal.psd";
-	const String EditorGUI::ScrollBarHandleVertHoverTex = "ScrollBarVertHandleHover.psd";
-	const String EditorGUI::ScrollBarHandleVertActiveTex = "ScrollBarVertHandleActive.psd";
+	const WString EditorGUI::ScrollBarHandleVertNormalTex = L"ScrollBarVertHandleNormal.psd";
+	const WString EditorGUI::ScrollBarHandleVertHoverTex = L"ScrollBarVertHandleHover.psd";
+	const WString EditorGUI::ScrollBarHandleVertActiveTex = L"ScrollBarVertHandleActive.psd";
 
-	const String EditorGUI::DropDownBtnNormalTex = "DropDownNormal.psd";
-	const String EditorGUI::DropDownBtnHoverTex = "DropDownHover.psd";
+	const WString EditorGUI::DropDownBtnNormalTex = L"DropDownNormal.psd";
+	const WString EditorGUI::DropDownBtnHoverTex = L"DropDownHover.psd";
 
-	const String EditorGUI::DropDownBoxBgTex = "DropDownBoxBg.psd";
-	const String EditorGUI::DropDownBoxEntryNormalTex = "DropDownButtonNormal.psd";
-	const String EditorGUI::DropDownBoxEntryHoverTex = "DropDownButtonHover.psd";
+	const WString EditorGUI::DropDownBoxBgTex = L"DropDownBoxBg.psd";
+	const WString EditorGUI::DropDownBoxEntryNormalTex = L"DropDownButtonNormal.psd";
+	const WString EditorGUI::DropDownBoxEntryHoverTex = L"DropDownButtonHover.psd";
 
-	const String EditorGUI::DropDownBoxBtnUpNormalTex = "DropDownBoxBtnUpNormal.psd";
-	const String EditorGUI::DropDownBoxBtnUpHoverTex = "DropDownBoxBtnUpHover.psd";
+	const WString EditorGUI::DropDownBoxBtnUpNormalTex = L"DropDownBoxBtnUpNormal.psd";
+	const WString EditorGUI::DropDownBoxBtnUpHoverTex = L"DropDownBoxBtnUpHover.psd";
 
-	const String EditorGUI::DropDownBoxBtnDownNormalTex = "DropDownBoxBtnDownNormal.psd";
-	const String EditorGUI::DropDownBoxBtnDownHoverTex = "DropDownBoxBtnDownHover.psd";
+	const WString EditorGUI::DropDownBoxBtnDownNormalTex = L"DropDownBoxBtnDownNormal.psd";
+	const WString EditorGUI::DropDownBoxBtnDownHoverTex = L"DropDownBoxBtnDownHover.psd";
 
-	const String EditorGUI::DropDownBoxEntryExpNormalTex = "DropDownExpNormal.psd";
-	const String EditorGUI::DropDownBoxEntryExpHoverTex = "DropDownExpHover.psd";
+	const WString EditorGUI::DropDownBoxEntryExpNormalTex = L"DropDownExpNormal.psd";
+	const WString EditorGUI::DropDownBoxEntryExpHoverTex = L"DropDownExpHover.psd";
 
-	const String EditorGUI::DropDownSeparatorTex = "DropDownSeparator.psd";
+	const WString EditorGUI::DropDownSeparatorTex = L"DropDownSeparator.psd";
 
-	const String EditorGUI::DropDownBoxBtnUpArrowTex = "DropDownBoxBtnUpArrow.psd";
-	const String EditorGUI::DropDownBoxBtnDownArrowTex = "DropDownBoxBtnDownArrow.psd";
+	const WString EditorGUI::DropDownBoxBtnUpArrowTex = L"DropDownBoxBtnUpArrow.psd";
+	const WString EditorGUI::DropDownBoxBtnDownArrowTex = L"DropDownBoxBtnDownArrow.psd";
 
-	const String EditorGUI::ScrollBarBgTex = "ScrollBarBg.psd";
+	const WString EditorGUI::ScrollBarBgTex = L"ScrollBarBg.psd";
 
-	const String EditorGUI::MenuBarBgTex = "MenuBarBg.psd";
+	const WString EditorGUI::MenuBarBgTex = L"MenuBarBg.psd";
 
-	const String EditorGUI::MenuBarBtnNormalTex = "MenuBarButtonNormal.psd";
-	const String EditorGUI::MenuBarBtnHoverTex = "MenuBarButtonHover.psd";
+	const WString EditorGUI::MenuBarBtnNormalTex = L"MenuBarButtonNormal.psd";
+	const WString EditorGUI::MenuBarBtnHoverTex = L"MenuBarButtonHover.psd";
 
-	const String EditorGUI::MenuBarBansheeLogoTex = "MenuBarBansheeLogo.psd";
+	const WString EditorGUI::MenuBarBansheeLogoTex = L"MenuBarBansheeLogo.psd";
 
-	const String EditorGUI::DockSliderNormalTex = "DockSliderBtn.psd";
+	const WString EditorGUI::DockSliderNormalTex = L"DockSliderBtn.psd";
 
-	const String EditorGUI::TreeViewExpandButtonOffNormal = "TreeViewExpandButtonOffNormal.psd";
-	const String EditorGUI::TreeViewExpandButtonOffHover = "TreeViewExpandButtonOffHover.psd";
-	const String EditorGUI::TreeViewExpandButtonOnNormal = "TreeViewExpandButtonOnNormal.psd";
-	const String EditorGUI::TreeViewExpandButtonOnHover = "TreeViewExpandButtonOnHover.psd";
+	const WString EditorGUI::TreeViewExpandButtonOffNormal = L"TreeViewExpandButtonOffNormal.psd";
+	const WString EditorGUI::TreeViewExpandButtonOffHover = L"TreeViewExpandButtonOffHover.psd";
+	const WString EditorGUI::TreeViewExpandButtonOnNormal = L"TreeViewExpandButtonOnNormal.psd";
+	const WString EditorGUI::TreeViewExpandButtonOnHover = L"TreeViewExpandButtonOnHover.psd";
 
-	const String EditorGUI::TreeViewSelectionBackground = "TreeViewSelectionBackground.psd";
-	const String EditorGUI::TreeViewEditBox = "TreeViewEditBox.psd";
-	const String EditorGUI::TreeViewElementHighlight = "TreeViewElementHighlight.psd";
-	const String EditorGUI::TreeViewElementSepHighlight = "TreeViewElementSepHighlight.psd";
+	const WString EditorGUI::TreeViewSelectionBackground = L"TreeViewSelectionBackground.psd";
+	const WString EditorGUI::TreeViewEditBox = L"TreeViewEditBox.psd";
+	const WString EditorGUI::TreeViewElementHighlight = L"TreeViewElementHighlight.psd";
+	const WString EditorGUI::TreeViewElementSepHighlight = L"TreeViewElementSepHighlight.psd";
 
 	EditorGUI::EditorGUI()
 	{
@@ -125,7 +125,7 @@ namespace BansheeEditor
 		HFont font;
 
 		{
-			String fontPath = DefaultFolder + DefaultFontPath;
+			WString fontPath = DefaultFolder + DefaultFontPath;
 			ImportOptionsPtr fontImportOptions = Importer::instance().createImportOptions(fontPath);
 			if(rtti_is_of_type<FontImportOptions>(fontImportOptions))
 			{
@@ -424,7 +424,7 @@ namespace BansheeEditor
 		mSkin.setStyle("ListBox", dropDownListStyle);
 
 		// DropDown scroll up button arrow
-		HTexture dropDownBtnScrollUpArrow = static_resource_cast<Texture>(Importer::instance().import(FileSystem::getCurrentPath() + "\\" + DropDownBoxBtnUpArrowTex));
+		HTexture dropDownBtnScrollUpArrow = getTexture(DropDownBoxBtnUpArrowTex);
 
 		GUIElementStyle dropDownScrollUpBtnArrowStyle;
 		dropDownScrollUpBtnArrowStyle.normal.texture = getTexture(DropDownBoxBtnUpArrowTex);
@@ -726,8 +726,8 @@ namespace BansheeEditor
 		mSkin.setStyle("TreeViewElementSepHighlight", treeViewElementSepHighlight);
 	}
 
-	HSpriteTexture EditorGUI::getTexture(const CM::String& name)
+	HSpriteTexture EditorGUI::getTexture(const CM::WString& name)
 	{
-		return SpriteTexture::create(static_resource_cast<Texture>(Importer::instance().import(FileSystem::getCurrentPath() + "\\" + DefaultFolder + name)));
+		return SpriteTexture::create(static_resource_cast<Texture>(Importer::instance().import(FileSystem::getWorkingDirectoryPath() + L"\\" + DefaultFolder + name)));
 	}
 }

CamelotCore/Include/CmApplication.h

@@ -28,7 +28,7 @@ namespace CamelotFramework
 
 		Vector<String>::type importers;
 
-		String resourceCacheDirectory;
+		WString resourceCacheDirectory;
 	};
 
 	class CM_EXPORT Application

CamelotCore/Include/CmGpuProgIncludeImporter.h

@@ -12,13 +12,13 @@ namespace CamelotFramework
 		virtual ~GpuProgIncludeImporter();
 
 		/** Inherited from SpecificImporter */
-		virtual bool isExtensionSupported(const String& ext) const;
+		virtual bool isExtensionSupported(const WString& ext) const;
 
 		/** Inherited from SpecificImporter */
 		virtual bool isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const; 
 
 		/** Inherited from SpecificImporter */
-		virtual HResource import(const String& filePath, ConstImportOptionsPtr importOptions);
+		virtual HResource import(const WString& filePath, ConstImportOptionsPtr importOptions);
 	private:
 	};
 }

CamelotCore/Include/CmGpuProgramImporter.h

@@ -11,7 +11,7 @@ namespace CamelotFramework
 		/**
 		 * @copydoc SpecificImporter::isExtensionSupported().
 		 */
-		virtual bool isExtensionSupported(const String& ext) const;
+		virtual bool isExtensionSupported(const WString& ext) const;
 
 		/**
 		 * @copydoc SpecificImporter::isMagicNumberSupported().
@@ -21,7 +21,7 @@ namespace CamelotFramework
 		/**
 		 * @copydoc SpecificImporter::import().
 		 */
-		virtual HResource import(const String& filePath, ConstImportOptionsPtr importOptions);
+		virtual HResource import(const WString& filePath, ConstImportOptionsPtr importOptions);
 
 		/**
 		 * @copydoc SpecificImporter::createImportOptions().

CamelotCore/Include/CmImporter.h

@@ -24,7 +24,7 @@ namespace CamelotFramework
 		 * @param	inputFilePath	Pathname of the input file.
 		 * @param	importOptions	(optional) Options for controlling the import.
 		 */
-		HResource import(const String& inputFilePath, ConstImportOptionsPtr importOptions = nullptr);
+		HResource import(const WString& inputFilePath, ConstImportOptionsPtr importOptions = nullptr);
 
 		/**
 		 * @brief	Automatically detects the importer needed for the provided file and returns valid type of
@@ -41,14 +41,14 @@ namespace CamelotFramework
 		 *			nullptr is returned if the file path is not valid, or if a valid importer cannot be found for
 		 *			the specified file.
 		 */
-		ImportOptionsPtr createImportOptions(const String& inputFilePath);
+		ImportOptionsPtr createImportOptions(const WString& inputFilePath);
 
 		/**
 		 * @brief	Checks if we can import a file with the specified extension.
 		 *
 		 * @param	extension	The extension without leading dot.
 		 */
-		bool supportsFileType(const String& extension) const;
+		bool supportsFileType(const WString& extension) const;
 
 		/**
 		 * @brief	Checks if we can import a file with the specified magic number.
@@ -71,6 +71,6 @@ namespace CamelotFramework
 	private:
 		Vector<SpecificImporter*>::type mAssetImporters;
 
-		SpecificImporter* getImporterForFile(const String& inputFilePath) const;
+		SpecificImporter* getImporterForFile(const WString& inputFilePath) const;
 	};
 }

CamelotCore/Include/CmResources.h

@@ -23,7 +23,7 @@ namespace CamelotFramework
 
 		struct CM_EXPORT ResourceLoadRequest
 		{
-			String filePath;
+			WString filePath;
 			HResource resource;
 		};
 
@@ -48,7 +48,7 @@ namespace CamelotFramework
 		 * @param	resMetaPath		Folder where the resource meta-data will be stored. If the folder doesn't exist
 		 * 							it will be created.
 		 */
-		Resources(const String& metaDataFolder);
+		Resources(const WString& metaDataFolder);
 		~Resources();
 
 		/**
@@ -63,7 +63,7 @@ namespace CamelotFramework
 		 *
 		 * @return	Loaded resource, or null if it cannot be found.
 		 */
-		HResource load(const String& filePath);
+		HResource load(const WString& filePath);
 
 		/**
 		 * @brief	Loads the resource asynchronously. Initially returned resource should not be used
@@ -73,7 +73,7 @@ namespace CamelotFramework
 		 * 						
 		 * @return	Resource where the data will eventually be loaded, or null if the file cannot be found.
 		 */
-		HResource loadAsync(const String& filePath);
+		HResource loadAsync(const WString& filePath);
 
 		/**
 		 * @brief	Loads the resource with the given uuid.
@@ -125,13 +125,13 @@ namespace CamelotFramework
 		 * @param	overwrite	(optional) If true, any existing resource at the specified location will
 		 * 						be overwritten.
 		 */
-		void create(HResource resource, const String& filePath, bool overwrite = false);
+		void create(HResource resource, const WString& filePath, bool overwrite = false);
 
 	public:
 		struct ResourceMetaData : public IReflectable
 		{
 			String mUUID;
-			String mPath;
+			WString mPath;
 
 			/************************************************************************/
 			/* 								SERIALIZATION                      		*/
@@ -145,7 +145,7 @@ namespace CamelotFramework
 	private:
 		typedef std::shared_ptr<ResourceMetaData> ResourceMetaDataPtr;
 		Map<String, ResourceMetaDataPtr>::type mResourceMetaData;
-		Map<String, ResourceMetaDataPtr>::type mResourceMetaData_FilePath;
+		Map<WString, ResourceMetaDataPtr>::type mResourceMetaData_FilePath;
 
 		CM_MUTEX(mInProgressResourcesMutex);
 		CM_MUTEX(mLoadedResourceMutex);
@@ -159,27 +159,27 @@ namespace CamelotFramework
 		UnorderedMap<String, HResource>::type mLoadedResources; 
 		UnorderedMap<String, ResourceAsyncOp>::type mInProgressResources; // Resources that are being asynchronously loaded
 
-		HResource loadInternal(const String& filePath, bool synchronous); 
-		ResourcePtr loadFromDiskAndDeserialize(const String& filePath);
+		HResource loadInternal(const WString& filePath, bool synchronous); 
+		ResourcePtr loadFromDiskAndDeserialize(const WString& filePath);
 
 		void loadMetaData();
 		void saveMetaData(const ResourceMetaDataPtr metaData);
 
-		void createMetaData(const String& uuid, const String& filePath);
-		void addMetaData(const String& uuid, const String& filePath);
-		void updateMetaData(const String& uuid, const String& newFilePath);
+		void createMetaData(const String& uuid, const WString& filePath);
+		void addMetaData(const String& uuid, const WString& filePath);
+		void updateMetaData(const String& uuid, const WString& newFilePath);
 		void removeMetaData(const String& uuid);
 
 		bool metaExists_UUID(const String& uuid) const;
-		bool metaExists_Path(const String& path) const;
+		bool metaExists_Path(const WString& path) const;
 
-		const String& getPathFromUUID(const String& uuid) const;
-		const String& getUUIDFromPath(const String& path) const;
+		const WString& getPathFromUUID(const String& uuid) const;
+		const String& getUUIDFromPath(const WString& path) const;
 
 		void notifyResourceLoadingFinished(HResource& handle);
 		void notifyNewResourceLoaded(HResource& handle);
 
-		String mMetaDataFolderPath;
+		WString mMetaDataFolderPath;
 	};
 
 	CM_EXPORT Resources& gResources();

CamelotCore/Include/CmResourcesRTTI.h

@@ -11,8 +11,8 @@ namespace CamelotFramework
 		String& getUUID(Resources::ResourceMetaData* obj) { return obj->mUUID; }
 		void setUUID(Resources::ResourceMetaData* obj, String& val) { obj->mUUID = val; }
 
-		String& getPath(Resources::ResourceMetaData* obj) { return obj->mPath; }
-		void setPath(Resources::ResourceMetaData* obj, String& val) { obj->mPath = val; }
+		WString& getPath(Resources::ResourceMetaData* obj) { return obj->mPath; }
+		void setPath(Resources::ResourceMetaData* obj, WString& val) { obj->mPath = val; }
 
 	public:
 		ResourceMetaDataRTTI()

CamelotCore/Include/CmSpecificImporter.h

@@ -18,7 +18,7 @@ namespace CamelotFramework
 		SpecificImporter() {}
 		virtual ~SpecificImporter() {}
 
-		virtual bool isExtensionSupported(const String& ext) const = 0;
+		virtual bool isExtensionSupported(const WString& ext) const = 0;
 		virtual bool isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const = 0; 
 
 		/**
@@ -28,7 +28,7 @@ namespace CamelotFramework
 		 *
 		 * @return	null if it fails, otherwise the loaded object.
 		 */
-		virtual HResource import(const String& filePath, ConstImportOptionsPtr importOptions) = 0;
+		virtual HResource import(const WString& filePath, ConstImportOptionsPtr importOptions) = 0;
 
 		/**
 		 * @brief	Creates import options specific for this importer. Import

CamelotCore/Source/CmGpuProgIncludeImporter.cpp

@@ -16,12 +16,12 @@ namespace CamelotFramework
 
 	}
 
-	bool GpuProgIncludeImporter::isExtensionSupported(const String& ext) const
+	bool GpuProgIncludeImporter::isExtensionSupported(const WString& ext) const
 	{
-		String lowerCaseExt = ext;
+		WString lowerCaseExt = ext;
 		StringUtil::toLowerCase(lowerCaseExt);
 
-		return lowerCaseExt == "gpuproginc";
+		return lowerCaseExt == L"gpuproginc";
 	}
 
 	bool GpuProgIncludeImporter::isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const
@@ -29,9 +29,9 @@ namespace CamelotFramework
 		return true; // Plain-text so I don't even check for magic number
 	}
 
-	HResource GpuProgIncludeImporter::import(const String& filePath, ConstImportOptionsPtr importOptions)
+	HResource GpuProgIncludeImporter::import(const WString& filePath, ConstImportOptionsPtr importOptions)
 	{
-		DataStreamPtr stream = FileSystem::open(filePath);
+		DataStreamPtr stream = FileSystem::openFile(filePath);
 		String includeString = stream->getAsString();
 
 		HGpuProgInclude gpuProgInclude = GpuProgInclude::create(includeString);

CamelotCore/Source/CmGpuProgramImporter.cpp

@@ -7,9 +7,9 @@
 
 namespace CamelotFramework
 {
-	bool GpuProgramImporter::isExtensionSupported(const String& ext) const
+	bool GpuProgramImporter::isExtensionSupported(const WString& ext) const
 	{
-		if(ext == "gpuprog")
+		if(ext == L"gpuprog")
 			return true;
 
 		return false;
@@ -21,12 +21,12 @@ namespace CamelotFramework
 		return true;
 	}
 
-	HResource GpuProgramImporter::import(const String& filePath, ConstImportOptionsPtr importOptions)
+	HResource GpuProgramImporter::import(const WString& filePath, ConstImportOptionsPtr importOptions)
 	{
-		String ext = Path::getExtension(filePath);
+		WString ext = Path::getExtension(filePath);
 		ext = ext.substr(1, ext.size() - 1); // Remove the .
 
-		DataStreamPtr stream = FileSystem::open(filePath);
+		DataStreamPtr stream = FileSystem::openFile(filePath);
 		String shaderSource = stream->getAsString();
 
 		const GpuProgramImportOptions* gpuProgImportOptions = static_cast<const GpuProgramImportOptions*>(importOptions.get());

CamelotCore/Source/CmImporter.cpp

@@ -29,7 +29,7 @@ namespace CamelotFramework
 		mAssetImporters.clear();
 	}
 
-	bool Importer::supportsFileType(const String& extension) const
+	bool Importer::supportsFileType(const WString& extension) const
 	{
 		for(auto iter = mAssetImporters.begin(); iter != mAssetImporters.end(); ++iter)
 		{
@@ -51,11 +51,11 @@ namespace CamelotFramework
 		return false;
 	}
 
-	HResource Importer::import(const String& inputFilePath, ConstImportOptionsPtr importOptions)
+	HResource Importer::import(const WString& inputFilePath, ConstImportOptionsPtr importOptions)
 	{
 		if(!FileSystem::fileExists(inputFilePath))
 		{
-			LOGWRN("Trying to import asset that doesn't exists. Asset path: " + inputFilePath);
+			LOGWRN("Trying to import asset that doesn't exists. Asset path: " + toString(inputFilePath));
 			return HResource();
 		}
 
@@ -80,11 +80,11 @@ namespace CamelotFramework
 		return importedResource;
 	}
 
-	ImportOptionsPtr Importer::createImportOptions(const String& inputFilePath)
+	ImportOptionsPtr Importer::createImportOptions(const WString& inputFilePath)
 	{
 		if(!FileSystem::fileExists(inputFilePath))
 		{
-			LOGWRN("Trying to import asset that doesn't exists. Asset path: " + inputFilePath);
+			LOGWRN("Trying to import asset that doesn't exists. Asset path: " + toString(inputFilePath));
 			return nullptr;
 		}
 
@@ -106,13 +106,13 @@ namespace CamelotFramework
 		mAssetImporters.push_back(importer);
 	}
 
-	SpecificImporter* Importer::getImporterForFile(const String& inputFilePath) const
+	SpecificImporter* Importer::getImporterForFile(const WString& inputFilePath) const
 	{
-		String ext = Path::getExtension(inputFilePath);
+		WString ext = Path::getExtension(inputFilePath);
 		ext = ext.substr(1, ext.size() - 1); // Remove the .
 		if(!supportsFileType(ext))
 		{
-			LOGWRN("There is no importer for the provided file type. (" + inputFilePath + ")");
+			LOGWRN("There is no importer for the provided file type. (" + toString(inputFilePath) + ")");
 			return nullptr;
 		}
 

CamelotCore/Source/CmResources.cpp

@@ -49,7 +49,7 @@ namespace CamelotFramework
 
 			if(!gResources().metaExists_UUID(resResponse->rawResource->getUUID()))
 			{
-				gDebug().logWarning("Loading a resource that doesn't have meta-data. Creating meta-data automatically. Resource path: " + resRequest->filePath);
+				gDebug().logWarning("Loading a resource that doesn't have meta-data. Creating meta-data automatically. Resource path: " + toString(resRequest->filePath));
 				gResources().addMetaData(resResponse->rawResource->getUUID(), resRequest->filePath);
 			}
 
@@ -61,7 +61,7 @@ namespace CamelotFramework
 		}
 	}
 
-	Resources::Resources(const String& metaDataFolder)
+	Resources::Resources(const WString& metaDataFolder)
 		:mRequestHandler(nullptr), mResponseHandler(nullptr), mWorkQueue(nullptr)
 	{
 		mMetaDataFolderPath = metaDataFolder;
@@ -110,12 +110,12 @@ namespace CamelotFramework
 			cm_delete(mResponseHandler);
 	}
 
-	HResource Resources::load(const String& filePath)
+	HResource Resources::load(const WString& filePath)
 	{
 		return loadInternal(filePath, true);
 	}
 
-	HResource Resources::loadAsync(const String& filePath)
+	HResource Resources::loadAsync(const WString& filePath)
 	{
 		return loadInternal(filePath, false);
 	}
@@ -146,7 +146,7 @@ namespace CamelotFramework
 		return loadAsync(metaEntry->mPath);
 	}
 
-	HResource Resources::loadInternal(const String& filePath, bool synchronous)
+	HResource Resources::loadInternal(const WString& filePath, bool synchronous)
 	{
 		// TODO Low priority - Right now I don't allow loading of resources that don't have meta-data, because I need to know resources UUID
 		// at this point. And I can't do that without having meta-data. Other option is to partially load the resource to read the UUID but due to the
@@ -197,7 +197,7 @@ namespace CamelotFramework
 
 		if(!FileSystem::fileExists(filePath))
 		{
-			gDebug().logWarning("Specified file: " + filePath + " doesn't exist.");
+			gDebug().logWarning("Specified file: " + toString(filePath) + " doesn't exist.");
 			return HResource();
 		}
 
@@ -221,7 +221,7 @@ namespace CamelotFramework
 		return newResource;
 	}
 
-	ResourcePtr Resources::loadFromDiskAndDeserialize(const String& filePath)
+	ResourcePtr Resources::loadFromDiskAndDeserialize(const WString& filePath)
 	{
 		FileSerializer fs;
 		std::shared_ptr<IReflectable> loadedData = fs.decode(filePath);
@@ -268,7 +268,7 @@ namespace CamelotFramework
 		}
 	}
 
-	void Resources::create(HResource resource, const String& filePath, bool overwrite)
+	void Resources::create(HResource resource, const WString& filePath, bool overwrite)
 	{
 		if(resource == nullptr)
 			CM_EXCEPT(InvalidParametersException, "Trying to save an uninitialized resource.");
@@ -312,7 +312,7 @@ namespace CamelotFramework
 		if(!metaExists_UUID(resource->getUUID()))
 			CM_EXCEPT(InvalidParametersException, "Cannot find resource meta-data. Please call Resources::create before trying to save the resource.");
 
-		const String& filePath = getPathFromUUID(resource->getUUID());
+		const WString& filePath = getPathFromUUID(resource->getUUID());
 
 		FileSerializer fs;
 		fs.encode(resource.get(), filePath);
@@ -320,12 +320,12 @@ namespace CamelotFramework
 
 	void Resources::loadMetaData()
 	{
-		Vector<String>::type allFiles = FileSystem::getFiles(mMetaDataFolderPath);
+		Vector<WString>::type allFiles = FileSystem::getFiles(mMetaDataFolderPath);
 
 		for(auto iter = allFiles.begin(); iter != allFiles.end(); ++iter)
 		{
-			String& path = *iter;
-			if(Path::hasExtension(path, "resmeta"))
+			WString& path = *iter;
+			if(Path::hasExtension(path, L"resmeta"))
 			{
 				FileSerializer fs;
 				std::shared_ptr<IReflectable> loadedData = fs.decode(path);
@@ -339,7 +339,7 @@ namespace CamelotFramework
 
 	void Resources::saveMetaData(const ResourceMetaDataPtr metaData)
 	{
-		String fullPath = Path::combine(mMetaDataFolderPath, metaData->mUUID + ".resmeta");
+		WString fullPath = Path::combine(mMetaDataFolderPath, toWString(metaData->mUUID + ".resmeta"));
 
 		FileSerializer fs;
 		fs.encode(metaData.get(), fullPath);
@@ -347,7 +347,7 @@ namespace CamelotFramework
 
 	void Resources::removeMetaData(const String& uuid)
 	{
-		String fullPath = Path::combine(mMetaDataFolderPath, uuid + ".resmeta");
+		WString fullPath = Path::combine(mMetaDataFolderPath, toWString(uuid + ".resmeta"));
 		FileSystem::remove(fullPath);
 
 		auto iter = mResourceMetaData.find(uuid);
@@ -361,10 +361,10 @@ namespace CamelotFramework
 			gDebug().logWarning("Trying to remove meta data that doesn't exist.");
 	}
 
-	void Resources::addMetaData(const String& uuid, const String& filePath)
+	void Resources::addMetaData(const String& uuid, const WString& filePath)
 	{
 		if(metaExists_Path(filePath))
-			CM_EXCEPT(InvalidParametersException, "Resource with the path '" + filePath + "' already exists.");
+			CM_EXCEPT(InvalidParametersException, "Resource with the path '" + toString(filePath) + "' already exists.");
 
 		if(metaExists_UUID(uuid))
 			CM_EXCEPT(InternalErrorException, "Resource with the same UUID already exists. UUID: " + uuid);
@@ -379,11 +379,11 @@ namespace CamelotFramework
 		saveMetaData(dbEntry);
 	}
 
-	void Resources::updateMetaData(const String& uuid, const String& newFilePath)
+	void Resources::updateMetaData(const String& uuid, const WString& newFilePath)
 	{
 		if(!metaExists_UUID(uuid))
 		{
-			CM_EXCEPT(InvalidParametersException, "Cannot update a resource that doesn't exist. UUID: " + uuid + ". File path: " + newFilePath);
+			CM_EXCEPT(InvalidParametersException, "Cannot update a resource that doesn't exist. UUID: " + uuid + ". File path: " + toString(newFilePath));
 		}
 
 		ResourceMetaDataPtr dbEntry = mResourceMetaData[uuid];
@@ -392,17 +392,17 @@ namespace CamelotFramework
 		saveMetaData(dbEntry);
 	}
 
-	const String& Resources::getPathFromUUID(const String& uuid) const
+	const WString& Resources::getPathFromUUID(const String& uuid) const
 	{
 		auto findIter = mResourceMetaData.find(uuid);
 
 		if(findIter != mResourceMetaData.end())
 			return findIter->second->mPath;
 		else
-			return StringUtil::BLANK;
+			return StringUtil::WBLANK;
 	}
 
-	const String& Resources::getUUIDFromPath(const String& path) const
+	const String& Resources::getUUIDFromPath(const WString& path) const
 	{
 		auto findIter = mResourceMetaData_FilePath.find(path);
 
@@ -419,7 +419,7 @@ namespace CamelotFramework
 		return findIter != mResourceMetaData.end();
 	}
 
-	bool Resources::metaExists_Path(const String& path) const
+	bool Resources::metaExists_Path(const WString& path) const
 	{
 		auto findIter = mResourceMetaData_FilePath.find(path);
 

CamelotFBXImporter/Include/CmFBXImporter.h

@@ -30,20 +30,20 @@ namespace CamelotFramework
 		}
 
 		/** Inherited from SpecificImporter */
-		virtual bool isExtensionSupported(const String& ext) const;
+		virtual bool isExtensionSupported(const WString& ext) const;
 
 		/** Inherited from SpecificImporter */
 		virtual bool isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const; 
 
 		/** Inherited from SpecificImporter */
-		virtual HResource import(const String& filePath, ConstImportOptionsPtr importOptions);
+		virtual HResource import(const WString& filePath, ConstImportOptionsPtr importOptions);
 	private:
-		Vector<String>::type mExtensions;
+		Vector<WString>::type mExtensions;
 
 		void startUpSdk(FbxManager*& manager, FbxScene*& scene);
 		void shutDownSdk(FbxManager* manager);
 
-		void loadScene(FbxManager* manager, FbxScene* scene, const String& filePath);
+		void loadScene(FbxManager* manager, FbxScene* scene, const WString& filePath);
 		MeshDataPtr parseScene(FbxManager* manager, FbxScene* scene, Vector<SubMesh>::type& subMeshes);
 
 		MeshDataPtr parseMesh(FbxMesh* mesh, Vector<SubMesh>::type& subMeshes, bool createTangentsIfMissing = true);

CamelotFBXImporter/Source/CmFBXImporter.cpp

@@ -16,7 +16,7 @@ namespace CamelotFramework
 	FBXImporter::FBXImporter()
 		:SpecificImporter() 
 	{
-		mExtensions.push_back("fbx");
+		mExtensions.push_back(L"fbx");
 	}
 
 	FBXImporter::~FBXImporter() 
@@ -24,9 +24,9 @@ namespace CamelotFramework
 
 	}
 
-	bool FBXImporter::isExtensionSupported(const String& ext) const
+	bool FBXImporter::isExtensionSupported(const WString& ext) const
 	{
-		String lowerCaseExt = ext;
+		WString lowerCaseExt = ext;
 		StringUtil::toLowerCase(lowerCaseExt);
 
 		return find(mExtensions.begin(), mExtensions.end(), lowerCaseExt) != mExtensions.end();
@@ -37,7 +37,7 @@ namespace CamelotFramework
 		return true; // FBX files can be plain-text so I don't even check for magic number
 	}
 
-	HResource FBXImporter::import(const String& filePath, ConstImportOptionsPtr importOptions)
+	HResource FBXImporter::import(const WString& filePath, ConstImportOptionsPtr importOptions)
 	{
 		FbxManager* fbxManager = nullptr;
 		FbxScene* fbxScene = nullptr;
@@ -79,14 +79,14 @@ namespace CamelotFramework
 
 	}
 
-	void FBXImporter::loadScene(FbxManager* manager, FbxScene* scene, const String& filePath)
+	void FBXImporter::loadScene(FbxManager* manager, FbxScene* scene, const WString& filePath)
 	{
 		int lFileMajor, lFileMinor, lFileRevision;
 		int lSDKMajor,  lSDKMinor,  lSDKRevision;
 		FbxManager::GetFileFormatVersion(lSDKMajor, lSDKMinor, lSDKRevision);
 
 		FbxImporter* importer = FbxImporter::Create(manager, "");
-		bool importStatus = importer->Initialize(filePath.c_str(), -1, manager->GetIOSettings());
+		bool importStatus = importer->Initialize(toString(filePath).c_str(), -1, manager->GetIOSettings());
 		
 		importer->GetFileVersion(lFileMajor, lFileMinor, lFileRevision);
 

CamelotFontImporter/Include/CmFontImporter.h

@@ -26,20 +26,20 @@ namespace CamelotFramework
 		}
 
 		/** Inherited from SpecificImporter */
-		virtual bool isExtensionSupported(const String& ext) const;
+		virtual bool isExtensionSupported(const WString& ext) const;
 
 		/** Inherited from SpecificImporter */
 		virtual bool isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const; 
 
 		/** Inherited from SpecificImporter */
-		virtual HResource import(const String& filePath, ConstImportOptionsPtr importOptions);
+		virtual HResource import(const WString& filePath, ConstImportOptionsPtr importOptions);
 
 		/**
 		 * @copydoc SpecificImporter::createImportOptions().
 		 */
 		virtual ImportOptionsPtr createImportOptions() const;
 	private:
-		Vector<String>::type mExtensions;
+		Vector<WString>::type mExtensions;
 
 		const static int MAXIMUM_TEXTURE_SIZE = 2048;
 	};

CamelotFontImporter/Source/CmFontImporter.cpp

@@ -17,8 +17,8 @@ namespace CamelotFramework
 	FontImporter::FontImporter()
 		:SpecificImporter() 
 	{
-		mExtensions.push_back("ttf");
-		mExtensions.push_back("otf");
+		mExtensions.push_back(L"ttf");
+		mExtensions.push_back(L"otf");
 	}
 
 	FontImporter::~FontImporter() 
@@ -26,9 +26,9 @@ namespace CamelotFramework
 
 	}
 
-	bool FontImporter::isExtensionSupported(const String& ext) const
+	bool FontImporter::isExtensionSupported(const WString& ext) const
 	{
-		String lowerCaseExt = ext;
+		WString lowerCaseExt = ext;
 		StringUtil::toLowerCase(lowerCaseExt);
 
 		return find(mExtensions.begin(), mExtensions.end(), lowerCaseExt) != mExtensions.end();
@@ -45,7 +45,7 @@ namespace CamelotFramework
 		return cm_shared_ptr<FontImportOptions, ScratchAlloc>();
 	}
 
-	HResource FontImporter::import(const String& filePath, ConstImportOptionsPtr importOptions)
+	HResource FontImporter::import(const WString& filePath, ConstImportOptionsPtr importOptions)
 	{
 		const FontImportOptions* fontImportOptions = static_cast<const FontImportOptions*>(importOptions.get());
 
@@ -56,15 +56,15 @@ namespace CamelotFramework
 			CM_EXCEPT(InternalErrorException, "Error occurred during FreeType library initialization.");
 
 		FT_Face face;
-		error = FT_New_Face(library, filePath.c_str(), 0, &face);
+		error = FT_New_Face(library, toString(filePath).c_str(), 0, &face);
 
 		if (error == FT_Err_Unknown_File_Format)
 		{
-			CM_EXCEPT(InternalErrorException, "Failed to load font file: " + filePath + ". Unsupported file format.");
+			CM_EXCEPT(InternalErrorException, "Failed to load font file: " + toString(filePath) + ". Unsupported file format.");
 		}
 		else if (error)
 		{
-			CM_EXCEPT(InternalErrorException, "Failed to load font file: " + filePath + ". Unknown error.");
+			CM_EXCEPT(InternalErrorException, "Failed to load font file: " + toString(filePath) + ". Unknown error.");
 		}
 
 		Vector<std::pair<UINT32, UINT32>>::type charIndexRanges = fontImportOptions->getCharIndexRanges();

CamelotFreeImgImporter/Include/CmFreeImgImporter.h

@@ -28,18 +28,18 @@ namespace CamelotFramework
 		}
 
 		/** Inherited from SpecificImporter */
-		virtual bool isExtensionSupported(const String& ext) const;
+		virtual bool isExtensionSupported(const WString& ext) const;
 
 		/** Inherited from SpecificImporter */
 		virtual bool isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const; 
 
 		/** Inherited from SpecificImporter */
-		virtual HResource import(const String& filePath, ConstImportOptionsPtr importOptions);
+		virtual HResource import(const WString& filePath, ConstImportOptionsPtr importOptions);
 	private:
-		Vector<String>::type mExtensions;
-		UnorderedMap<String, int>::type mExtensionToFID;
+		Vector<WString>::type mExtensions;
+		UnorderedMap<WString, int>::type mExtensionToFID;
 
-		String magicNumToExtension(const UINT8* magic, UINT32 maxBytes) const;
+		WString magicNumToExtension(const UINT8* magic, UINT32 maxBytes) const;
 		TextureDataPtr importRawImage(DataStreamPtr fileData);
 	};
 }

CamelotFreeImgImporter/Source/CmFreeImgImporter.cpp

@@ -34,7 +34,7 @@ namespace CamelotFramework
 		FreeImage_Initialise(false);
 
 		// Register codecs
-		StringStream strExt;
+		WStringStream strExt;
 		strExt << "Supported formats: ";
 		bool first = true;
 		for (int i = 0; i < FreeImage_GetFIFCount(); ++i)
@@ -45,7 +45,7 @@ namespace CamelotFramework
 			if ((FREE_IMAGE_FORMAT)i == FIF_DDS)
 				continue;
 
-			String exts(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i));
+			WString exts = toWString(String(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i)));
 			if (!first)
 			{
 				strExt << ",";
@@ -54,14 +54,14 @@ namespace CamelotFramework
 			strExt << exts;
 
 			// Pull off individual formats (separated by comma by FI)
-			Vector<String>::type extsVector = StringUtil::split(exts, ",");
+			Vector<WString>::type extsVector = StringUtil::split(exts, L",");
 			for (auto v = extsVector.begin(); v != extsVector.end(); ++v)
 			{
 				auto findIter = std::find(mExtensions.begin(), mExtensions.end(), *v);
 
 				if(findIter == mExtensions.end())
 				{
-					String ext = *v;
+					WString ext = *v;
 					StringUtil::toLowerCase(ext);
 
 					mExtensionToFID.insert(std::make_pair(ext, i));
@@ -79,9 +79,9 @@ namespace CamelotFramework
 		FreeImage_DeInitialise();
 	}
 
-	bool FreeImgImporter::isExtensionSupported(const String& ext) const
+	bool FreeImgImporter::isExtensionSupported(const WString& ext) const
 	{
-		String lowerCaseExt = ext;
+		WString lowerCaseExt = ext;
 		StringUtil::toLowerCase(lowerCaseExt);
 
 		return find(mExtensions.begin(), mExtensions.end(), lowerCaseExt) != mExtensions.end();
@@ -89,12 +89,12 @@ namespace CamelotFramework
 
 	bool FreeImgImporter::isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const
 	{
-		String ext = magicNumToExtension(magicNumPtr, numBytes);
+		WString ext = magicNumToExtension(magicNumPtr, numBytes);
 
 		return isExtensionSupported(ext);
 	}
 
-	String FreeImgImporter::magicNumToExtension(const UINT8* magic, UINT32 maxBytes) const
+	WString FreeImgImporter::magicNumToExtension(const UINT8* magic, UINT32 maxBytes) const
 	{
 		// Set error handler
 		FreeImage_SetOutputMessage(FreeImageLoadErrorHandler);
@@ -107,19 +107,19 @@ namespace CamelotFramework
 
 		if (fif != FIF_UNKNOWN)
 		{
-			String ext(FreeImage_GetFormatFromFIF(fif));
+			WString ext = toWString(String(FreeImage_GetFormatFromFIF(fif)));
 			StringUtil::toLowerCase(ext);
 			return ext;
 		}
 		else
 		{
-			return StringUtil::BLANK;
+			return StringUtil::WBLANK;
 		}
 	}
 
-	HResource FreeImgImporter::import(const String& filePath, ConstImportOptionsPtr importOptions)
+	HResource FreeImgImporter::import(const WString& filePath, ConstImportOptionsPtr importOptions)
 	{
-		DataStreamPtr fileData = FileSystem::open(filePath, true);
+		DataStreamPtr fileData = FileSystem::openFile(filePath, true);
 
 		TextureDataPtr imgData = importRawImage(fileData);
 		if(imgData == nullptr || imgData->getData() == nullptr)
@@ -158,11 +158,11 @@ namespace CamelotFramework
 		// return to start
 		fileData->seek(0);
 
-		String fileExtension = magicNumToExtension(magicBuf, magicLen);
+		WString fileExtension = magicNumToExtension(magicBuf, magicLen);
 		auto findFormat = mExtensionToFID.find(fileExtension);
 		if(findFormat == mExtensionToFID.end())
 		{
-			CM_EXCEPT(InvalidParametersException, "Type of the file provided is not supported by this importer. File type: " + fileExtension);
+			CM_EXCEPT(InvalidParametersException, "Type of the file provided is not supported by this importer. File type: " + toString(fileExtension));
 		}
 
 		FREE_IMAGE_FORMAT imageFormat = (FREE_IMAGE_FORMAT)findFormat->second;

CamelotUtility/Include/CmDebug.h

@@ -18,7 +18,7 @@ namespace CamelotFramework
 
 		Log& getLog() { return mLog; }
 
-		void writeAsBMP(UINT8* rawPixels, UINT32 bytesPerPixel, UINT32 width, UINT32 height, const String& filePath, bool overwrite = true) const;
+		void writeAsBMP(UINT8* rawPixels, UINT32 bytesPerPixel, UINT32 width, UINT32 height, const WString& filePath, bool overwrite = true) const;
 
 	private:
 		Log mLog;

CamelotUtility/Include/CmFileSerializer.h

@@ -12,8 +12,8 @@ namespace CamelotFramework
 		FileSerializer();
 		~FileSerializer();
 
-		void encode(IReflectable* object, String fileLocation);
-		std::shared_ptr<IReflectable> decode(String fileLocation);
+		void encode(IReflectable* object, WString fileLocation);
+		std::shared_ptr<IReflectable> decode(WString fileLocation);
 
 	private:
 		std::ofstream mOutputStream;

CamelotUtility/Include/CmFileSystem.h

@@ -7,24 +7,20 @@ namespace CamelotFramework
 	class CM_UTILITY_EXPORT FileSystem
 	{
 	public:
-		static DataStreamPtr open(const String& fullPath, bool readOnly = true);
+		static DataStreamPtr openFile(const WString& fullPath, bool readOnly = true);
+		static DataStreamPtr createAndOpenFile(const WString& fullPath);
 
-		static DataStreamPtr create(const String& fullPath);
+		static UINT64 getFileSize(const WString& fullPath);
 
-		static void remove(const String& fullPath);
+		static void remove(const WString& fullPath, bool recursively = true);
+		static void createDir(const WString& fullPath);
 
-		static bool fileExists(const String& fullPath);
-		static bool dirExists(const String& fullPath);
+		static bool fileExists(const WString& fullPath);
+		static bool dirExists(const WString& fullPath);
 
-		static void createDir(const String& fullPath);
-		static void deleteDir(const String& fullPath);
+		static Vector<WString>::type getFiles(const WString& dirPath);
 
-		static Vector<String>::type getFiles(const String& dirPath);
-
-		static String getCurrentPath();
-
-		static bool isValidFileName(const String& name);
-
-		static String getDirectoryPath(const String& path);
+		static WString getWorkingDirectoryPath();
+		static WString getParentDirectory(const WString& path);
 	};
 }

CamelotUtility/Include/CmPath.h

@@ -11,34 +11,35 @@ namespace CamelotFramework
 	class Path
 	{
 	public:
-		static String getExtension(const String& path)
+		static WString getExtension(const WString& path)
 		{
-			return boost::filesystem::extension(boost::filesystem::path(path.c_str())).c_str();
+			boost::filesystem3::wpath ext = boost::filesystem3::extension(boost::filesystem3::wpath(path.c_str()));
+			return ext.wstring().c_str();
 		}
 
-		static bool hasExtension(const String& path, const String& extension)
+		static bool hasExtension(const WString& path, const WString& extension)
 		{
 			return getExtension(path) == extension;
 		}
 
-		static String combine(const String& base, const String& name)
+		static WString combine(const WString& base, const WString& name)
 		{
 			if (base.empty())
 				return name;
 			else
-				return base + '/' + name;
+				return base + L'/' + name;
 		}
 
 		/**
 		 * @brief	Method for standardizing paths - use forward slashes only, end with slash.
 		 */
-		String standardisePath(const String& inPath)
+		static WString standardisePath(const WString& inPath)
 		{
-			String path = inPath;
+			WString path = inPath;
 
-			std::replace(path.begin(), path.end(), '\\', '/');
-			if(path[path.length() - 1] != '/')
-				path += '/';
+			std::replace(path.begin(), path.end(), L'\\', L'/');
+			if(path[path.length() - 1] != L'/')
+				path += L'/';
 
 			return path;
 		}
@@ -46,13 +47,13 @@ namespace CamelotFramework
 		/**
 		 * @brief	Method for splitting a fully qualified filename into the base name and path.
 		 */
-		void splitFilename(const String& qualifiedName, String& outBasename, String& outPath)
+		static void splitFilename(const WString& qualifiedName, WString& outBasename, WString& outPath)
 		{
-			String path = qualifiedName;
+			WString path = qualifiedName;
 			// Replace \ with / first
-			std::replace( path.begin(), path.end(), '\\', '/' );
+			std::replace( path.begin(), path.end(), L'\\', L'/' );
 			// split based on final /
-			size_t i = path.find_last_of('/');
+			size_t i = path.find_last_of(L'/');
 
 			if (i == String::npos)
 			{
@@ -69,10 +70,10 @@ namespace CamelotFramework
 		/**
 		 * @brief	Method for splitting a filename into the base name and extension.
 		 */
-		void splitBaseFilename(const String& fullName, String& outBasename, String& outExtension)
+		static void splitBaseFilename(const WString& fullName, WString& outBasename, WString& outExtension)
 		{
-			size_t i = fullName.find_last_of(".");
-			if (i == CamelotFramework::String::npos)
+			size_t i = fullName.find_last_of(L".");
+			if (i == CamelotFramework::WString::npos)
 			{
 				outExtension.clear();
 				outBasename = fullName;
@@ -87,9 +88,9 @@ namespace CamelotFramework
 		/**
 		 * @brief	Method for splitting a fully qualified filename into the base name, extension and path.
 		 */
-		void splitFullFilename(const String& qualifiedName, String& outBasename, String& outExtention, String& outPath)
+		static void splitFullFilename(const WString& qualifiedName, WString& outBasename, WString& outExtention, WString& outPath)
 		{
-			String fullName;
+			WString fullName;
 			splitFilename(qualifiedName, fullName, outPath);
 			splitBaseFilename(fullName, outBasename, outExtention);
 		}

CamelotUtility/Source/CmDebug.cpp

@@ -32,17 +32,17 @@ namespace CamelotFramework
 		mLog.logMsg(msg, channel);
 	}
 
-	void Debug::writeAsBMP(UINT8* rawPixels, UINT32 bytesPerPixel, UINT32 width, UINT32 height, const String& filePath, bool overwrite) const
+	void Debug::writeAsBMP(UINT8* rawPixels, UINT32 bytesPerPixel, UINT32 width, UINT32 height, const WString& filePath, bool overwrite) const
 	{
 		if(FileSystem::fileExists(filePath))
 		{
 			if(overwrite)
 				FileSystem::remove(filePath);
 			else
-				CM_EXCEPT(FileNotFoundException, "File already exists at specified location: " + filePath);
+				CM_EXCEPT(FileNotFoundException, "File already exists at specified location: " + toString(filePath));
 		}
 
-		DataStreamPtr ds = FileSystem::create(filePath);
+		DataStreamPtr ds = FileSystem::createAndOpenFile(filePath);
 
 		UINT32 bmpDataSize = BitmapWriter::getBMPSize(width, height, bytesPerPixel);
 		UINT8* bmpBuffer = cm_newN<UINT8, ScratchAlloc>(bmpDataSize);

CamelotUtility/Source/CmFileSerializer.cpp

@@ -19,7 +19,7 @@ namespace CamelotFramework
 		cm_free<ScratchAlloc>(mWriteBuffer);
 	}
 
-	void FileSerializer::encode(IReflectable* object, String fileLocation)
+	void FileSerializer::encode(IReflectable* object, WString fileLocation)
 	{
 		mOutputStream.open(fileLocation.c_str(), std::ios::out | std::ios::binary);
 
@@ -31,7 +31,7 @@ namespace CamelotFramework
 		mOutputStream.clear();
 	}
 
-	std::shared_ptr<IReflectable> FileSerializer::decode(String fileLocation)
+	std::shared_ptr<IReflectable> FileSerializer::decode(WString fileLocation)
 	{
 		mInputStream.open(fileLocation.c_str(), std::ios::in | std::ios::ate | std::ios::binary);
 		

CamelotUtility/Source/CmFileSystem.cpp

@@ -5,35 +5,13 @@
 
 #include <boost/filesystem.hpp>
 
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#if CM_PLATFORM == CM_PLATFORM_LINUX || CM_PLATFORM == CM_PLATFORM_APPLE || \
-	CM_PLATFORM == CM_PLATFORM_SYMBIAN || CM_PLATFORM == CM_PLATFORM_IPHONE
-#   include <sys/param.h>
-#   define MAX_PATH MAXPATHLEN
-#endif
-
-#if CM_PLATFORM == CM_PLATFORM_WIN32
-#  define WIN32_LEAN_AND_MEAN
-#  if !defined(NOMINMAX) && defined(_MSC_VER)
-#	define NOMINMAX // required to stop windows.h messing up std::min
-#  endif
-#  include <windows.h>
-#  include <direct.h>
-#  include <io.h>
-#endif
+using namespace boost::filesystem3;
 
 namespace CamelotFramework
 {
-	DataStreamPtr FileSystem::open(const String& fullPath, bool readOnly)
+	DataStreamPtr FileSystem::openFile(const WString& fullPath, bool readOnly)
 	{
-		// Use filesystem to determine size 
-		// (quicker than streaming to the end and back)
-		struct stat tagStat;
-		int ret = stat(fullPath.c_str(), &tagStat);
-		assert(ret == 0 && "Problem getting file size" );
-		(void)ret;  // Silence warning
+		UINT64 fileSize = getFileSize(fullPath);
 
 		// Always open in binary mode
 		// Also, always include reading
@@ -58,24 +36,24 @@ namespace CamelotFramework
 
 		// Should check ensure open succeeded, in case fail for some reason.
 		if (baseStream->fail())
-			CM_EXCEPT(FileNotFoundException, "Cannot open file: " + fullPath);
+			CM_EXCEPT(FileNotFoundException, "Cannot open file: " + toString(fullPath));
 
 		/// Construct return stream, tell it to delete on destroy
 		FileDataStream* stream = 0;
 		if (rwStream)
 		{
 			// use the writeable stream 
-			stream = cm_new<FileDataStream, ScratchAlloc>(fullPath, rwStream, (size_t)tagStat.st_size, true);
+			stream = cm_new<FileDataStream, ScratchAlloc>(toString(fullPath), rwStream, (size_t)fileSize, true);
 		}
 		else
 		{
 			// read-only stream
-			stream = cm_new<FileDataStream, ScratchAlloc>(fullPath, roStream, (size_t)tagStat.st_size, true);
+			stream = cm_new<FileDataStream, ScratchAlloc>(toString(fullPath), roStream, (size_t)fileSize, true);
 		}
 		return cm_shared_ptr<FileDataStream, ScratchAlloc>(stream);
 	}
 
-	DataStreamPtr FileSystem::create(const String& fullPath)
+	DataStreamPtr FileSystem::createAndOpenFile(const WString& fullPath)
 	{
 		// Always open in binary mode
 		// Also, always include reading
@@ -85,53 +63,55 @@ namespace CamelotFramework
 
 		// Should check ensure open succeeded, in case fail for some reason.
 		if (rwStream->fail())
-			CM_EXCEPT(FileNotFoundException, "Cannot open file: " + fullPath);
+			CM_EXCEPT(FileNotFoundException, "Cannot open file: " + toString(fullPath));
 
 		/// Construct return stream, tell it to delete on destroy
-		return cm_shared_ptr<FileDataStream, ScratchAlloc>(fullPath, rwStream, 0, true);
+		return cm_shared_ptr<FileDataStream, ScratchAlloc>(toString(fullPath), rwStream, 0, true);
 	}
 
-	void FileSystem::remove(const String& fullPath)
+	UINT64 FileSystem::getFileSize(const WString& fullPath)
 	{
-		::remove(fullPath.c_str());
+		return file_size(fullPath.c_str());
 	}
 
-	bool FileSystem::fileExists(const String& fullPath)
+	void FileSystem::remove(const WString& fullPath, bool recursively)
 	{
-		if(boost::filesystem::exists(fullPath.c_str()) && !boost::filesystem::is_directory(fullPath.c_str()))
-			return true;
-
-		return false;
+		if(recursively)
+			remove_all(fullPath.c_str());
+		else
+			boost::filesystem3::remove(fullPath.c_str());
 	}
 
-	bool FileSystem::dirExists(const String& fullPath)
+	bool FileSystem::fileExists(const WString& fullPath)
 	{
-		if(boost::filesystem::exists(fullPath.c_str()) && boost::filesystem::is_directory(fullPath.c_str()))
+		if(exists(fullPath.c_str()) && !is_directory(fullPath.c_str()))
 			return true;
 
 		return false;
 	}
 
-	void FileSystem::createDir(const String& fullPath)
+	bool FileSystem::dirExists(const WString& fullPath)
 	{
-		boost::filesystem::create_directory(fullPath.c_str());
+		if(exists(fullPath.c_str()) && is_directory(fullPath.c_str()))
+			return true;
+
+		return false;
 	}
 
-	void FileSystem::deleteDir(const String& fullPath)
+	void FileSystem::createDir(const WString& fullPath)
 	{
-		boost::filesystem::remove_all(fullPath.c_str());
+		create_directory(fullPath.c_str());
 	}
 
-	Vector<String>::type FileSystem::getFiles(const String& dirPath)
+	Vector<WString>::type FileSystem::getFiles(const WString& dirPath)
 	{
-		boost::filesystem::directory_iterator dirIter(dirPath.c_str());
+		directory_iterator dirIter(dirPath.c_str());
 
-		Vector<String>::type foundFiles;
-		
-		while(dirIter != boost::filesystem::directory_iterator())
+		Vector<WString>::type foundFiles;
+		while(dirIter != directory_iterator())
 		{
-			if(boost::filesystem::is_regular_file(dirIter->path()))
-				foundFiles.push_back(dirIter->path().string().c_str());
+			if(is_regular_file(dirIter->path()))
+				foundFiles.push_back(dirIter->path().wstring().c_str());
 
 			dirIter++;
 		}
@@ -139,24 +119,19 @@ namespace CamelotFramework
 		return foundFiles;
 	}
 
-	String FileSystem::getCurrentPath()
-	{
-		return boost::filesystem::current_path().string().c_str();
-	}
-
-	bool FileSystem::isValidFileName(const String& name)
+	WString FileSystem::getWorkingDirectoryPath()
 	{
-		return boost::filesystem::portable_file_name(name.c_str());
+		return current_path().wstring().c_str();
 	}
 
-	String FileSystem::getDirectoryPath(const String& path)
+	WString FileSystem::getParentDirectory(const WString& path)
 	{
-		boost::filesystem::path p(path.c_str());
-
+		boost::filesystem3::path p(path.c_str());
+		
 		if(!is_directory(p))
 		{
-			boost::filesystem::path dir = p.parent_path();
-			return dir.string().c_str();
+			boost::filesystem3::path dir = p.parent_path();
+			return dir.wstring().c_str();
 		}
 
 		return path;