Code clean up + replace some wstring instances with utf8 (#640)

Author: Exzap

src/Cafe/Account/Account.cpp

@@ -1,8 +1,6 @@
 #include "Account.h"
 #include "util/helpers/helpers.h"
-#include "gui/CemuApp.h"
 #include "util/helpers/SystemException.h"
-
 #include "config/ActiveSettings.h"
 #include "Cafe/IOSU/legacy/iosu_crypto.h"
 #include "Common/FileStream.h"
@@ -175,7 +173,7 @@ std::error_code Account::Load()
 
 std::error_code Account::Save()
 {
-	fs::path path = CemuApp::GetMLCPath(fmt::format(L"usr/save/system/act/{:08x}", m_persistent_id)).ToStdWstring();
+	fs::path path = ActiveSettings::GetMlcPath(fmt::format(L"usr/save/system/act/{:08x}", m_persistent_id));
 	if (!fs::exists(path))
 	{
 		std::error_code ec;
@@ -184,7 +182,7 @@ std::error_code Account::Save()
 			return ec;
 	}
 
-	path /= L"account.dat";
+	path /= "account.dat";
 
 	try
 	{
@@ -302,7 +300,7 @@ void Account::SetMiiName(std::wstring_view name)
 const std::vector<Account>& Account::RefreshAccounts()
 {
 	std::vector<Account> result;
-	const fs::path path = CemuApp::GetMLCPath(L"usr/save/system/act").ToStdWstring();
+	const fs::path path = ActiveSettings::GetMlcPath("usr/save/system/act");
 	if (fs::exists(path))
 	{
 		for (const auto& it : fs::directory_iterator(path))
@@ -417,7 +415,7 @@ fs::path Account::GetFileName(uint32 persistent_id)
 	if (persistent_id < kMinPersistendId)
 		throw std::invalid_argument(fmt::format("persistent id {:#x} is invalid", persistent_id));
 
-	return CemuApp::GetMLCPath(fmt::format(L"usr/save/system/act/{:08x}/account.dat", persistent_id)).ToStdWstring();
+	return ActiveSettings::GetMlcPath(fmt::format("usr/save/system/act/{:08x}/account.dat", persistent_id));
 }
 
 OnlineValidator Account::ValidateOnlineFiles() const

src/Cafe/CMakeLists.txt

@@ -454,8 +454,6 @@ add_library(CemuCafe
   TitleList/BaseInfo.cpp
   TitleList/BaseInfo.h
   TitleList/GameInfo.h
-  TitleList/MetaInfo.cpp
-  TitleList/MetaInfo.h
   TitleList/ParsedMetaXml.h
   TitleList/SaveInfo.cpp
   TitleList/SaveInfo.h

src/Cafe/CafeSystem.cpp

@@ -337,7 +337,7 @@ uint32 loadSharedData()
 			// advance write offset and pad to 16 byte alignment
 			dataWritePtr += ((fileSize + 15) & ~15);
 		}
-		forceLog_printfW(L"COS: System fonts found. Generated shareddata (%dKB)", (uint32)(dataWritePtr - (uint8*)shareddataTable) / 1024);
+		cemuLog_log(LogType::Force, "COS: System fonts found. Generated shareddata ({}KB)", (uint32)(dataWritePtr - (uint8*)shareddataTable) / 1024);
 		return memory_getVirtualOffsetFromPointer(dataWritePtr);
 	}
 	// alternative method: load RAM dump

src/Cafe/GamePatch.cpp

@@ -139,7 +139,7 @@ void hle_scan(uint8* data, sint32 dataLength, char* hleFunctionName)
 			uint32 offset = (uint32)(scanCurrent - scanStart) + 0x01000000;
 			debug_printf("HLE signature for '%s' found at 0x%08x\n", hleFunctionName, offset);
 			uint32 opcode = (1<<26)|(functionIndex+0x1000); // opcode for HLE: 0x1000 + FunctionIndex
-			memory_writeU32Direct(offset, opcode);
+			memory_write<uint32>(offset, opcode);
 			break;
 		}
 		scanCurrent += 4;
@@ -330,7 +330,7 @@ void GamePatch_scan()
 #endif
 		sint32 functionIndex = hleIndex_h000000001;
 		uint32 opcode = (1 << 26) | (functionIndex); // opcode for HLE: 0x1000 + FunctionIndex
-		memory_writeU32Direct(hleAddr - 4, opcode);
+		memory_write<uint32>(hleAddr - 4, opcode);
 	}
 	hleIndex_h000000002 = osLib_getFunctionIndex("hle", "h000000002");
 	hleAddr = hle_locate(botw_busyLoopSignature2, botw_busyLoopMask2, sizeof(botw_busyLoopSignature2));
@@ -341,7 +341,7 @@ void GamePatch_scan()
 #endif
 		sint32 functionIndex = hleIndex_h000000002;
 		uint32 opcode = (1 << 26) | (functionIndex); // opcode for HLE: 0x1000 + FunctionIndex
-		memory_writeU32Direct(hleAddr - 4, opcode);
+		memory_write<uint32>(hleAddr - 4, opcode);
 	}
 
 	// FFL library float array endian conversion
@@ -353,7 +353,7 @@ void GamePatch_scan()
 		forceLogDebug_printf("HLE: Hook FFL float array endian swap function at 0x%08x", hleAddr);
 		sint32 functionIndex = hleIndex_h000000003;
 		uint32 opcode = (1 << 26) | (functionIndex); // opcode for HLE: 0x1000 + FunctionIndex
-		memory_writeU32Direct(hleAddr, opcode);
+		memory_write<uint32>(hleAddr, opcode);
 	}
 
 	// XCX freeze workaround

src/Cafe/GraphicPack/GraphicPack2.cpp

@@ -500,6 +500,14 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 	}
 }
 
+// returns true if enabling, disabling (changeEnableState) or changing presets (changePreset) for the graphic pack requires restarting if the game is already running
+bool GraphicPack2::RequiresRestart(bool changeEnableState, bool changePreset)
+{
+	if (!GetTextureRules().empty())
+		return true;
+	return false;
+}
+
 bool GraphicPack2::Reload()
 {
 	Deactivate();

src/Cafe/GraphicPack/GraphicPack2.h

@@ -105,6 +105,7 @@ class GraphicPack2
 	sint32 GetVersion() const { return m_version; }
 	const std::wstring& GetFilename() const { return m_filename; }
 	const fs::path GetFilename2() const { return fs::path(m_filename); }
+	bool RequiresRestart(bool changeEnableState, bool changePreset);
 	bool Reload();
 
 	bool HasName() const { return !m_name.empty();  }
@@ -172,6 +173,7 @@ class GraphicPack2
 
 	static void ActivateForCurrentTitle();
 	static void Reset();
+
 private:
 	bool Activate();
 	bool Deactivate();

src/Cafe/GraphicPack/GraphicPack2Patches.cpp

@@ -102,14 +102,14 @@ bool GraphicPack2::LoadCemuPatches()
 					// load Cemu style patch file
 					if (!ParseCemuPatchesTxtInternal(patchesStream))
 					{
-						forceLog_printfW(L"Error while processing \"%s\". No patches for this graphic pack will be applied.", path.c_str());
+						cemuLog_log(LogType::Force, "Error while processing \"{}\". No patches for this graphic pack will be applied.", _pathToUtf8(path));
 						cemu_assert_debug(list_patchGroups.empty());
 						return true; // return true since a .asm patch was found even if we could not parse it
 					}
 				}
 				else
 				{
-					forceLog_printfW(L"Unable to load patch file \"%s\"", path.c_str());
+					cemuLog_log(LogType::Force, "Unable to load patch file \"{}\"", _pathToUtf8(path));
 				}
 				foundPatches = true;
 			}

src/Cafe/HW/Latte/Core/LatteCommandProcessor.cpp

@@ -559,19 +559,19 @@ LatteCMDPtr LatteCP_itLoadReg(LatteCMDPtr cmd, uint32 nWords, uint32 regBase)
 	MPTR physAddressRegArea = LatteReadCMD();
 	uint32 waitForIdle = LatteReadCMD();
 	uint32 loadEntries = (nWords - 2) / 2;
-	uint32 regIndex = 0;
+	uint32 regShadowMemAddr = physAddressRegArea;
 	for (uint32 i = 0; i < loadEntries; i++)
 	{
 		uint32 regOffset = LatteReadCMD();
 		uint32 regCount = LatteReadCMD();
 		cemu_assert_debug(regCount != 0);
+		uint32 regAddr = regBase + regOffset;
 		for (uint32 f = 0; f < regCount; f++)
 		{
-			uint32 regAddr = regBase + regOffset + f;
-			uint32 regShadowMemAddr = physAddressRegArea + regIndex * 4;
 			LatteGPUState.contextRegisterShadowAddr[regAddr] = regShadowMemAddr;
-			LatteGPUState.contextRegister[regAddr] = memory_readU32Direct(regShadowMemAddr);
-			regIndex++;
+			LatteGPUState.contextRegister[regAddr] = memory_read<uint32>(regShadowMemAddr);
+			regAddr++;
+			regShadowMemAddr += 4;
 		}
 	}
 	return cmd;
@@ -716,7 +716,7 @@ LatteCMDPtr LatteCP_itHLESampleTimer(LatteCMDPtr cmd, uint32 nWords)
 {
 	cemu_assert_debug(nWords == 1);
 	MPTR timerMPTR = (MPTR)LatteReadCMD();
-	memory_writeU64Slow(timerMPTR, coreinit::coreinit_getTimerTick());
+	memory_writeU64(timerMPTR, coreinit::coreinit_getTimerTick());
 	return cmd;
 }
 

src/Cafe/HW/Latte/Core/LatteShaderCache.cpp

@@ -219,7 +219,7 @@ void LatteShaderCache_load()
 	if(!fc_shaderCacheGeneric)
 	{
 		// no shader cache available yet
-		forceLog_printfW(L"Unable to open or create shader cache file \"%s\"", pathGeneric.c_str());		
+		cemuLog_log(LogType::Force, "Unable to open or create shader cache file \"{}\"", _pathToUtf8(pathGeneric));
 		LatteShaderCache_finish();
 		return;
 	}

src/Cafe/HW/Latte/Core/LatteTextureLoader.cpp

@@ -695,7 +695,7 @@ void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, sint32 texture
 	if (textureLoader.dump)
 	{
 		wchar_t path[1024];
-		swprintf(path, 1024, L"dump\\textures\\%08x_fmt%04x_slice%d_mip%02d_%dx%d_tm%02d.tga", physImagePtr, (uint32)tex->format, sliceIndex, mipIndex, tex->width, tex->height, tileMode);
+		swprintf(path, 1024, L"dump/textures/%08x_fmt%04x_slice%d_mip%02d_%dx%d_tm%02d.tga", physImagePtr, (uint32)tex->format, sliceIndex, mipIndex, tex->width, tex->height, tileMode);
 		tga_write_rgba(path, textureLoader.width, textureLoader.height, textureLoader.dumpRGBA);
 		free(textureLoader.dumpRGBA);
 	}

src/Cafe/HW/MMU/MMU.cpp

@@ -293,11 +293,6 @@ uint8* memory_getPointerFromVirtualOffsetAllowNull(uint32 virtualOffset)
 	return memory_getPointerFromVirtualOffset(virtualOffset);
 }
 
-void memory_writeU32Direct(uint32 address, uint32 v)
-{
-	*(uint32*)(memory_getPointerFromVirtualOffset(address)) = CPU_swapEndianU32(v);
-}
-
 // write access
 void memory_writeDouble(uint32 address, double vf)
 {
@@ -320,12 +315,6 @@ void memory_writeU32(uint32 address, uint32 v)
 	*(uint32*)(memory_getPointerFromVirtualOffset(address)) = CPU_swapEndianU32(v);
 }
 
-void memory_writeU64Slow(uint32 address, uint64 v)
-{
-	memory_writeU32(address+0, (v>>32)&0xFFFFFFFF);
-	memory_writeU32(address+4, (v)&0xFFFFFFFF);
-}
-
 void memory_writeU64(uint32 address, uint64 v)
 {
 	*(uint64*)(memory_getPointerFromVirtualOffset(address)) = CPU_swapEndianU64(v);
@@ -372,12 +361,6 @@ uint32 memory_readU32(uint32 address)
 	return CPU_swapEndianU32(v);
 }
 
-uint32 memory_readU32Direct(uint32 address)
-{
-	uint32 v = *(uint32*)(memory_getPointerFromVirtualOffset(address));
-	return CPU_swapEndianU32(v);
-}
-
 uint16 memory_readU16(uint32 address)
 {
 	uint16 v = *(uint16*)(memory_getPointerFromVirtualOffset(address));

src/Cafe/HW/MMU/MMU.h

@@ -15,7 +15,7 @@ uint8* memory_getPointerFromPhysicalOffset(uint32 physicalOffset);
 uint32 memory_virtualToPhysical(uint32 virtualOffset);
 uint32 memory_physicalToVirtual(uint32 physicalOffset);
 
-extern uint8* memory_base; // points to 0x00000000
+extern uint8* memory_base; // points to base of PowerPC address space
 
 enum class MMU_MEM_AREA_ID
 {
@@ -171,33 +171,26 @@ bool memory_isAddressRangeAccessible(MPTR virtualAddress, uint32 size);
 #define MEMORY_SHAREDDATA_AREA_ADDR			(0xF8000000)
 #define MEMORY_SHAREDDATA_AREA_SIZE			(0x02000000) // 32MB
 
-static uint16 CPU_swapEndianU16(uint16 v)
-{
-	return (v>>8)|(v<<8);
-}
-
 #if BOOST_OS_WINDOWS
 #define CPU_swapEndianU64(_v) _byteswap_uint64((uint64)(_v))
 #define CPU_swapEndianU32(_v) _byteswap_ulong((uint32)(_v))
+#define CPU_swapEndianU16(_v) _byteswap_ushort((uint16)(_v))
 #elif BOOST_OS_LINUX
 #define CPU_swapEndianU64(_v) bswap_64((uint64)(_v))
 #define CPU_swapEndianU32(_v) bswap_32((uint32)(_v))
+#define CPU_swapEndianU16(_v) bswap_16((uint16)(_v))
 #elif BOOST_OS_MACOS
 #define CPU_swapEndianU64(_v) OSSwapInt64((uint64)(_v))
 #define CPU_swapEndianU32(_v) OSSwapInt32((uint32)(_v))
+#define CPU_swapEndianU16(_v) OSSwapInt16((uint16)(_v))
 #endif
 
-// direct memory access (no hardware interface access)
-void memory_writeU32Direct(uint32 address, uint32 v);
-uint32 memory_readU32Direct(uint32 address);
-
-// memory access (includes hardware interface, slower)
+// C-style memory access, deprecated. Use memory_read<> and memory_write<> templates instead
 void memory_writeDouble(uint32 address, double vf);
 void memory_writeFloat(uint32 address, float vf);
 void memory_writeU32(uint32 address, uint32 v);
 void memory_writeU16(uint32 address, uint16 v);
 void memory_writeU8(uint32 address, uint8 v);
-void memory_writeU64Slow(uint32 address, uint64 v);
 void memory_writeU64(uint32 address, uint64 v);
 
 double memory_readDouble(uint32 address);
@@ -210,43 +203,24 @@ uint8 memory_readU8(uint32 address);
 void memory_createDump();
 
 template<size_t count>
-void memory_readBytes(uint32 address, std::array<uint8, count>& buffer)
+void memory_readBytes(VAddr address, std::array<uint8, count>& buffer)
 {
 	memcpy(buffer.data(), memory_getPointerFromVirtualOffset(address), count);
 }
 
-template <typename T> T memory_read(uint32 address)
+template <typename T> inline T memory_read(VAddr address)
 {
-	if constexpr(std::is_floating_point<T>::value)
-	{
-		if constexpr(sizeof(T) == sizeof(float))
-			return memory_readFloat(address);
-		else
-			return memory_readDouble(address);
-	}
-	else if(std::is_integral<T>::value)
-	{
-		if constexpr (sizeof(T) == sizeof(uint8))
-			return (T)memory_readU8(address);
-		else if constexpr (sizeof(T) == sizeof(uint16))
-			return (T)memory_readU16(address);
-		else if constexpr (sizeof(T) == sizeof(uint32))
-			return (T)memory_readU32(address);
-		else if constexpr (sizeof(T) == sizeof(uint64))
-			return (T)memory_readU64(address);
-	}
+	return *(betype<T>*)(memory_base + address);
+}
 
-	debugBreakpoint(); 
-	return {};
+template <typename T> inline void memory_write(VAddr address, T value)
+{
+	*(betype<T>*)(memory_base + address) = value;
 }
 
 // LLE implementation
 void memory_initPhysicalLayout();
 
-// updated code
-using EAddr = uint32; // effective address
-using PAddr = uint32; // physical address
-
 namespace MMU
 {
 	using MMIOFuncWrite32 = void (*)(PAddr addr, uint32 value);

src/Cafe/OS/RPL/rpl.cpp

@@ -734,7 +734,7 @@ uint32 RPLLoader_MakePPCCallable(void(*ppcCallableExport)(PPCInterpreter_t* hCPU
 	sint32 functionIndex = PPCInterpreter_registerHLECall(ppcCallableExport);
 	MPTR codeAddr = memory_getVirtualOffsetFromPointer(RPLLoader_AllocateTrampolineCodeSpace(4));
 	uint32 opcode = (1 << 26) | functionIndex;
-	memory_writeU32Direct(codeAddr, opcode);
+	memory_write<uint32>(codeAddr, opcode);
 	g_map_callableExports[ppcCallableExport] = codeAddr;
 	return codeAddr;
 }
@@ -772,7 +772,7 @@ uint32 rpl_mapHLEImport(RPLModule* rplLoaderContext, const char* rplName, const
 	{
 		MPTR codeAddr = memory_getVirtualOffsetFromPointer(RPLLoader_AllocateTrampolineCodeSpace(4));
 		uint32 opcode = (1 << 26) | functionIndex;
-		memory_writeU32Direct(codeAddr, opcode);
+		memory_write<uint32>(codeAddr, opcode);
 		// register mapped import
 		mappedFunctionImport_t newImport;
 		newImport.hash1 = mappedImportHash1;
@@ -792,8 +792,8 @@ uint32 rpl_mapHLEImport(RPLModule* rplLoaderContext, const char* rplName, const
 	uint32 codeStart = memory_getVirtualOffsetFromPointer(RPLLoader_AllocateTrampolineCodeSpace(256));
 	uint32 currentAddress = codeStart;
 	uint32 opcode = (1 << 26) | (0xFFD0); // opcode for HLE: Unsupported import
-	memory_writeU32Direct(codeStart + 0, opcode);
-	memory_writeU32Direct(codeStart + 4, 0x4E800020);
+	memory_write<uint32>(codeStart + 0, opcode);
+	memory_write<uint32>(codeStart + 4, 0x4E800020);
 	currentAddress += 8;
 	// write name of lib/function
 	sint32 libNameLength = std::min(128, (sint32)strlen(libName));