Merge branch 'master' into moar-gpu

.github/workflows/Linux_Build.yml

@@ -23,6 +23,9 @@ jobs:
     - name: Fetch submodules
       run: git submodule update --init --recursive
 
+    - name: Install misc packages
+      run: sudo apt-get update && sudo apt install libx11-dev libgl1-mesa-glx
+
     - name: Setup Vulkan SDK
       uses: humbletim/setup-vulkan-sdk@v1.2.0
       with:

.gitmodules

@@ -31,3 +31,6 @@
 [submodule "third_party/glm"]
 	path = third_party/glm
 	url = https://github.com/g-truc/glm
+[submodule "third_party/discord-rpc"]
+	path = third_party/discord-rpc
+	url = https://github.com/discord/discord-rpc

CMakeLists.txt

@@ -1,4 +1,10 @@
-cmake_minimum_required(VERSION 3.10)
+# We need to be able to use enable_language(OBJC) on Mac, so we need CMake 3.16 vs the 3.10 we use otherwise. Blame Apple.
+if (APPLE)
+    cmake_minimum_required(VERSION 3.16)
+else()
+    cmake_minimum_required(VERSION 3.10)
+endif()
+
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 
@@ -7,12 +13,16 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION
 endif()
 
 if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE Release)
+    set(CMAKE_BUILD_TYPE Release)
 endif()
 
 project(Alber)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
+if(APPLE)
+    enable_language(OBJC)
+endif()
+
 if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-format-nonliteral -Wno-format-security")
 endif() 
@@ -24,6 +34,7 @@ option(ENABLE_VULKAN "Enable Vulkan rendering backend" ON)
 option(ENABLE_LTO "Enable link-time optimization" OFF)
 option(ENABLE_USER_BUILD "Make a user-facing build. These builds have various assertions disabled, LTO, and more" OFF)
 option(ENABLE_HTTP_SERVER "Enable HTTP server. Used for Discord bot support" OFF)
+option(ENABLE_DISCORD_RPC "Compile with Discord RPC support (disabled by default)" ON)
 
 include_directories(${PROJECT_SOURCE_DIR}/include/)
 include_directories(${PROJECT_SOURCE_DIR}/include/kernel)
@@ -44,6 +55,11 @@ add_compile_definitions(NOMINMAX)             # Make windows.h not define min/ma
 add_compile_definitions(WIN32_LEAN_AND_MEAN)  # Make windows.h not include literally everything
 add_compile_definitions(SDL_MAIN_HANDLED)
 
+if(ENABLE_DISCORD_RPC)
+    add_subdirectory(third_party/discord-rpc)
+    include_directories(third_party/discord-rpc/include)
+endif()
+
 set(SDL_STATIC ON CACHE BOOL "" FORCE)
 set(SDL_SHARED OFF CACHE BOOL "" FORCE)
 set(SDL_TEST OFF CACHE BOOL "" FORCE)
@@ -101,6 +117,7 @@ set(SOURCE_FILES src/main.cpp src/emulator.cpp src/io_file.cpp src/config.cpp
 				 src/core/CPU/cpu_dynarmic.cpp src/core/CPU/dynarmic_cycles.cpp
 				 src/core/memory.cpp src/renderer.cpp src/core/renderer_null/renderer_null.cpp
 				 src/http_server.cpp src/stb_image_write.c src/core/cheats.cpp src/core/action_replay.cpp
+                 src/discord_rpc.cpp
 )
 set(CRYPTO_SOURCE_FILES src/core/crypto/aes_engine.cpp)
 set(KERNEL_SOURCE_FILES src/core/kernel/kernel.cpp src/core/kernel/resource_limits.cpp
@@ -118,7 +135,7 @@ set(SERVICE_SOURCE_FILES src/core/services/service_manager.cpp src/core/services
                          src/core/services/frd.cpp src/core/services/nim.cpp src/core/services/shared_font.cpp
                          src/core/services/y2r.cpp src/core/services/cam.cpp src/core/services/ldr_ro.cpp
                          src/core/services/act.cpp src/core/services/nfc.cpp src/core/services/dlp_srvr.cpp
-                         src/core/services/ir_user.cpp
+                         src/core/services/ir_user.cpp src/core/services/http.cpp
 )
 set(PICA_SOURCE_FILES src/core/PICA/gpu.cpp src/core/PICA/regs.cpp src/core/PICA/shader_unit.cpp
                       src/core/PICA/shader_interpreter.cpp src/core/PICA/dynapica/shader_rec.cpp
@@ -158,7 +175,8 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/termcolor.hpp
                  include/crypto/aes_engine.hpp include/metaprogramming.hpp include/PICA/pica_vertex.hpp
                  include/config.hpp include/services/ir_user.hpp include/http_server.hpp include/cheats.hpp
                  include/action_replay.hpp include/renderer_sw/renderer_sw.hpp include/compiler_builtins.hpp
-                 include/fs/romfs.hpp include/fs/ivfc.hpp include/math_util.hpp
+                 include/fs/romfs.hpp include/fs/ivfc.hpp include/discord_rpc.hpp include/services/http.hpp include/result/result_cfg.hpp
+                 include/math_util.hpp
 )
 
 set(THIRD_PARTY_SOURCE_FILES third_party/imgui/imgui.cpp
@@ -253,11 +271,16 @@ endif()
 add_executable(Alber ${ALL_SOURCES})
 
 if(ENABLE_LTO OR ENABLE_USER_BUILD)
-  set_target_properties(Alber PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
+    set_target_properties(Alber PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
 endif()
 
 target_link_libraries(Alber PRIVATE dynarmic SDL2-static cryptopp glad)
 
+if(ENABLE_DISCORD_RPC)
+    target_compile_definitions(Alber PUBLIC "PANDA3DS_ENABLE_DISCORD_RPC=1")
+    target_link_libraries(Alber PRIVATE discord-rpc)
+endif()
+
 if(ENABLE_OPENGL)
     target_compile_definitions(Alber PUBLIC "PANDA3DS_ENABLE_OPENGL=1")
     target_link_libraries(Alber PRIVATE resources_renderer_gl)

include/config.hpp

@@ -6,6 +6,7 @@
 // Remember to initialize every field here to its default value otherwise bad things will happen
 struct EmulatorConfig {
 	bool shaderJitEnabled = false;
+	bool discordRpcEnabled = false;
 	RendererType rendererType = RendererType::OpenGL;
 
 	EmulatorConfig(const std::filesystem::path& path);

include/discord_rpc.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifdef PANDA3DS_ENABLE_DISCORD_RPC
+#include <discord_rpc.h>
+
+#include <cstdint>
+#include <string>
+
+namespace Discord {
+	enum class RPCStatus { Idling, Playing };
+
+	class RPC {
+		std::uint64_t startTimestamp;
+		bool enabled = false;
+
+	  public:
+		void init();
+		void update(RPCStatus status, const std::string& title);
+		void stop();
+	};
+}  // namespace Discord
+
+#endif

include/emulator.hpp

@@ -11,6 +11,7 @@
 #include "config.hpp"
 #include "cpu.hpp"
 #include "crypto/aes_engine.hpp"
+#include "discord_rpc.hpp"
 #include "io_file.hpp"
 #include "memory.hpp"
 
@@ -64,6 +65,11 @@ class Emulator {
 	friend struct HttpServer;
 #endif
 
+#ifdef PANDA3DS_ENABLE_DISCORD_RPC
+	Discord::RPC discordRpc;
+#endif
+	void updateDiscord();
+
 	// Keep the handle for the ROM here to reload when necessary and to prevent deleting it
 	// This is currently only used for ELFs, NCSDs use the IOFile API instead
 	std::ifstream loadedELF;

include/kernel/handles.hpp

@@ -20,7 +20,8 @@ namespace KernelHandles {
 		CFG,  // CFG service (Console & region info)
 		DLP_SRVR, // Download Play: Server. Used for network play.
 		DSP,  // DSP service (Used for audio decoding and output)
-		HID,  // HID service (Handles everything input-related including gyro)
+		HID,  // HID service (Handles input-related things including gyro. Does NOT handle New3DS controls or CirclePadPro)
+		HTTP, // HTTP service (Handles HTTP requests)
 		IR_USER, // One of 3 infrared communication services
         FRD,  // Friend service (Miiverse friend service)
 		FS,   // Filesystem service
@@ -69,6 +70,7 @@ namespace KernelHandles {
 			case DSP: return "DSP";
 			case DLP_SRVR: return "DLP::SRVR";
 			case HID: return "HID";
+			case HTTP: return "HTTP";
 			case IR_USER: return "IR:USER";
 			case FRD: return "FRD";
 			case FS: return "FS";

include/logger.hpp

@@ -43,6 +43,7 @@ namespace Log {
 	static Logger<false> frdLogger;
 	static Logger<false> fsLogger;
 	static Logger<false> hidLogger;
+	static Logger<false> httpLogger;
 	static Logger<false> irUserLogger;
 	static Logger<false> gspGPULogger;
 	static Logger<false> gspLCDLogger;

include/result/result.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "result_cfg.hpp"
 #include "result_common.hpp"
 #include "result_kernel.hpp"
 #include "result_os.hpp"

include/result/result_cfg.hpp

@@ -0,0 +1,8 @@
+#pragma once
+#include "result_common.hpp"
+
+DEFINE_HORIZON_RESULT_MODULE(Result::CFG, Config);
+
+namespace Result::CFG {
+	DEFINE_HORIZON_RESULT(NotFound, 1018, WrongArgument, Permanent);
+};

include/services/act.hpp

@@ -13,6 +13,7 @@ class ACTService {
 	// Service commands
 	void initialize(u32 messagePointer);
 	void generateUUID(u32 messagePointer);
+	void getAccountDataBlock(u32 messagePointer);
 
 public:
 	ACTService(Memory& mem) : mem(mem) {}

include/services/boss.hpp

@@ -11,6 +11,7 @@ class BOSSService {
 	MAKE_LOG_FUNCTION(log, bossLogger)
 
 	// Service commands
+	void cancelTask(u32 messagePointer);
 	void initializeSession(u32 messagePointer);
 	void getNsDataIdList(u32 messagePointer);
 	void getOptoutFlag(u32 messagePointer);

include/services/cfg.hpp

@@ -16,6 +16,7 @@ class CFGService {
 
 	// Service functions
 	void getConfigInfoBlk2(u32 messagePointer);
+	void getCountryCodeID(u32 messagePointer);
 	void getRegionCanadaUSA(u32 messagePointer);
 	void getSystemModel(u32 messagePointer);
 	void genUniqueConsoleHash(u32 messagePointer);

include/services/http.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include "helpers.hpp"
+#include "kernel_types.hpp"
+#include "logger.hpp"
+#include "memory.hpp"
+
+class HTTPService {
+	Handle handle = KernelHandles::HTTP;
+	Memory& mem;
+	MAKE_LOG_FUNCTION(log, httpLogger)
+
+	bool initialized = false;
+
+	// Service commands
+	void initialize(u32 messagePointer);
+
+  public:
+	HTTPService(Memory& mem) : mem(mem) {}
+	void reset();
+	void handleSyncRequest(u32 messagePointer);
+};

include/services/service_manager.hpp

@@ -21,6 +21,7 @@
 #include "services/gsp_gpu.hpp"
 #include "services/gsp_lcd.hpp"
 #include "services/hid.hpp"
+#include "services/http.hpp"
 #include "services/ir_user.hpp"
 #include "services/ldr_ro.hpp"
 #include "services/mic.hpp"
@@ -53,6 +54,7 @@ class ServiceManager {
 	DlpSrvrService dlp_srvr;
 	DSPService dsp;
 	HIDService hid;
+	HTTPService http;
 	IRUserService ir_user;
 	FRDService frd;
 	FSService fs;

src/config.cpp

@@ -29,6 +29,15 @@ void EmulatorConfig::load(const std::filesystem::path& path) {
 		return;
 	}
 
+	if (data.contains("General")) {
+		auto generalResult = toml::expect<toml::value>(data.at("General"));
+		if (generalResult.is_ok()) {
+			auto general = generalResult.unwrap();
+
+			discordRpcEnabled = toml::find_or<toml::boolean>(general, "EnableDiscordRPC", false);
+		}
+	}
+
 	if (data.contains("GPU")) {
 		auto gpuResult = toml::expect<toml::value>(data.at("GPU"));
 		if (gpuResult.is_ok()) {
@@ -68,6 +77,7 @@ void EmulatorConfig::save(const std::filesystem::path& path) {
 		printf("Saving new configuration file %s\n", path.string().c_str());
 	}
 
+	data["General"]["EnableDiscordRPC"] = discordRpcEnabled;
 	data["GPU"]["EnableShaderJIT"] = shaderJitEnabled;
 	data["GPU"]["Renderer"] = std::string(Renderer::typeToString(rendererType));
 

src/core/services/act.cpp

@@ -4,7 +4,8 @@
 namespace ACTCommands {
 	enum : u32 {
 		Initialize = 0x00010084,
-		GenerateUUID = 0x000D0040
+		GetAccountDataBlock = 0x000600C2,
+		GenerateUUID = 0x000D0040,
 	};
 }
 
@@ -14,6 +15,7 @@ void ACTService::handleSyncRequest(u32 messagePointer) {
 	const u32 command = mem.read32(messagePointer);
 	switch (command) {
 		case ACTCommands::GenerateUUID: generateUUID(messagePointer); break;
+		case ACTCommands::GetAccountDataBlock: getAccountDataBlock(messagePointer); break;
 		case ACTCommands::Initialize: initialize(messagePointer); break;
 		default: Helpers::panic("ACT service requested. Command: %08X\n", command);
 	}
@@ -32,4 +34,17 @@ void ACTService::generateUUID(u32 messagePointer) {
 	// TODO: The header is probably wrong
 	mem.write32(messagePointer, IPC::responseHeader(0xD, 1, 0));
 	mem.write32(messagePointer + 4, Result::Success);
+}
+
+void ACTService::getAccountDataBlock(u32 messagePointer) {
+	log("ACT::GetAccountDataBlock (stubbed)\n");
+
+	const u32 size = mem.read32(messagePointer + 8);
+	const u32 blkID = mem.read32(messagePointer + 12);
+	const u32 outputPointer = mem.read32(messagePointer + 20);
+
+	// TODO: This header is probably also wrong
+	// Also we need to populate the data block here. Half of it is undocumented though >_<
+	mem.write32(messagePointer, IPC::responseHeader(0x6, 1, 0));
+	mem.write32(messagePointer + 4, Result::Success);
 }

src/core/services/boss.cpp

@@ -11,6 +11,7 @@ namespace BOSSCommands {
 		GetTaskIdList = 0x000E0000,
 		GetNsDataIdList = 0x00100102,
 		ReceiveProperty = 0x00160082,
+		CancelTask = 0x001E0042,
 		GetTaskInfo = 0x00250082,
 		RegisterStorageEntry = 0x002F0140,
 		GetStorageEntryInfo = 0x00300000
@@ -24,6 +25,7 @@ void BOSSService::reset() {
 void BOSSService::handleSyncRequest(u32 messagePointer) {
 	const u32 command = mem.read32(messagePointer);
 	switch (command) {
+		case BOSSCommands::CancelTask: cancelTask(messagePointer); break;
 		case BOSSCommands::GetNsDataIdList: getNsDataIdList(messagePointer); break;
 		case BOSSCommands::GetOptoutFlag: getOptoutFlag(messagePointer); break;
 		case BOSSCommands::GetStorageEntryInfo: getStorageEntryInfo(messagePointer); break;
@@ -93,6 +95,12 @@ void BOSSService::receiveProperty(u32 messagePointer) {
 	mem.write32(messagePointer + 8, 0); // Read size
 }
 
+void BOSSService::cancelTask(u32 messagePointer) {
+	log("BOSS::CancelTask (stubbed)\n");
+	mem.write32(messagePointer, IPC::responseHeader(0x1E, 1, 2));
+	mem.write32(messagePointer + 4, Result::Success);
+}
+
 void BOSSService::unregisterTask(u32 messagePointer) {
 	log("BOSS::UnregisterTask (stubbed)\n");
 	mem.write32(messagePointer, IPC::responseHeader(0x0C, 1, 2));

src/core/services/cfg.cpp

@@ -5,6 +5,8 @@
 
 #include <array>
 #include <bit>
+#include <string>
+#include <unordered_map>
 
 namespace CFGCommands {
 	enum : u32 {
@@ -12,7 +14,8 @@ namespace CFGCommands {
 		SecureInfoGetRegion = 0x00020000,
 		GenHashConsoleUnique = 0x00030040,
 		GetRegionCanadaUSA = 0x00040000,
-		GetSystemModel = 0x00050000
+		GetSystemModel = 0x00050000,
+		GetCountryCodeID = 0x000A0040,
 	};
 }
 
@@ -22,6 +25,7 @@ void CFGService::handleSyncRequest(u32 messagePointer) {
 	const u32 command = mem.read32(messagePointer);
 	switch (command) {
 		case CFGCommands::GetConfigInfoBlk2: [[likely]] getConfigInfoBlk2(messagePointer); break;
+		case CFGCommands::GetCountryCodeID: getCountryCodeID(messagePointer); break;
 		case CFGCommands::GetRegionCanadaUSA: getRegionCanadaUSA(messagePointer); break;
 		case CFGCommands::GetSystemModel: getSystemModel(messagePointer); break;
 		case CFGCommands::GenHashConsoleUnique: genUniqueConsoleHash(messagePointer); break;
@@ -115,6 +119,8 @@ void CFGService::getConfigInfoBlk2(u32 messagePointer) {
 		for (u32 i = 0; i < size; i += 4) {
 			mem.write32(output + i, 0);
 		}
+	} else if (size == 4 && blockID == 0x170000) {  // Miiverse access key
+		mem.write32(output, 0);
 	} else {
 		Helpers::panic("Unhandled GetConfigInfoBlk2 configuration. Size = %d, block = %X", size, blockID);
 	}
@@ -152,4 +158,43 @@ void CFGService::getRegionCanadaUSA(u32 messagePointer) {
 	mem.write32(messagePointer, IPC::responseHeader(0x4, 2, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 	mem.write8(messagePointer + 8, ret);
+}
+
+constexpr u16 C(const char name[3]) { return name[0] | (name[1] << 8); }
+static std::unordered_map<u16, u16> countryCodeToTableIDMap = {
+	{C("JP"), 1},   {C("AI"), 8},   {C("AG"), 9},   {C("AR"), 10},  {C("AW"), 11},  {C("BS"), 12},  {C("BB"), 13},  {C("BZ"), 14},  {C("BO"), 15},
+	{C("BR"), 16},  {C("VG"), 17},  {C("CA"), 18},  {C("KY"), 19},  {C("CL"), 20},  {C("CO"), 21},  {C("CR"), 22},  {C("DM"), 23},  {C("DO"), 24},
+	{C("EC"), 25},  {C("SV"), 26},  {C("GF"), 27},  {C("GD"), 28},  {C("GP"), 29},  {C("GT"), 30},  {C("GY"), 31},  {C("HT"), 32},  {C("HN"), 33},
+	{C("JM"), 34},  {C("MQ"), 35},  {C("MX"), 36},  {C("MS"), 37},  {C("AN"), 38},  {C("NI"), 39},  {C("PA"), 40},  {C("PY"), 41},  {C("PE"), 42},
+	{C("KN"), 43},  {C("LC"), 44},  {C("VC"), 45},  {C("SR"), 46},  {C("TT"), 47},  {C("TC"), 48},  {C("US"), 49},  {C("UY"), 50},  {C("VI"), 51},
+	{C("VE"), 52},  {C("AL"), 64},  {C("AU"), 65},  {C("AT"), 66},  {C("BE"), 67},  {C("BA"), 68},  {C("BW"), 69},  {C("BG"), 70},  {C("HR"), 71},
+	{C("CY"), 72},  {C("CZ"), 73},  {C("DK"), 74},  {C("EE"), 75},  {C("FI"), 76},  {C("FR"), 77},  {C("DE"), 78},  {C("GR"), 79},  {C("HU"), 80},
+	{C("IS"), 81},  {C("IE"), 82},  {C("IT"), 83},  {C("LV"), 84},  {C("LS"), 85},  {C("LI"), 86},  {C("LT"), 87},  {C("LU"), 88},  {C("MK"), 89},
+	{C("MT"), 90},  {C("ME"), 91},  {C("MZ"), 92},  {C("NA"), 93},  {C("NL"), 94},  {C("NZ"), 95},  {C("NO"), 96},  {C("PL"), 97},  {C("PT"), 98},
+	{C("RO"), 99},  {C("RU"), 100}, {C("RS"), 101}, {C("SK"), 102}, {C("SI"), 103}, {C("ZA"), 104}, {C("ES"), 105}, {C("SZ"), 106}, {C("SE"), 107},
+	{C("CH"), 108}, {C("TR"), 109}, {C("GB"), 110}, {C("ZM"), 111}, {C("ZW"), 112}, {C("AZ"), 113}, {C("MR"), 114}, {C("ML"), 115}, {C("NE"), 116},
+	{C("TD"), 117}, {C("SD"), 118}, {C("ER"), 119}, {C("DJ"), 120}, {C("SO"), 121}, {C("AD"), 122}, {C("GI"), 123}, {C("GG"), 124}, {C("IM"), 125},
+	{C("JE"), 126}, {C("MC"), 127}, {C("TW"), 128}, {C("KR"), 136}, {C("HK"), 144}, {C("MO"), 145}, {C("ID"), 152}, {C("SG"), 153}, {C("TH"), 154},
+	{C("PH"), 155}, {C("MY"), 156}, {C("CN"), 160}, {C("AE"), 168}, {C("IN"), 169}, {C("EG"), 170}, {C("OM"), 171}, {C("QA"), 172}, {C("KW"), 173},
+	{C("SA"), 174}, {C("SY"), 175}, {C("BH"), 176}, {C("JO"), 177}, {C("SM"), 184}, {C("VA"), 185}, {C("BM"), 186},
+};
+
+void CFGService::getCountryCodeID(u32 messagePointer) {
+	// Read the character code as a u16 instead of as ASCII, and use it to index the unordered_map above and get the result
+	const u16 characterCode = mem.read16(messagePointer + 4);
+	log("CFG::GetCountryCodeID (code = %04X)\n", characterCode);
+
+	mem.write32(messagePointer, IPC::responseHeader(0x0A, 2, 0));
+	
+	// If the character code is valid, return its table ID and a success code
+	if (auto search = countryCodeToTableIDMap.find(characterCode); search != countryCodeToTableIDMap.end()) {
+		mem.write32(messagePointer + 4, Result::Success);
+		mem.write16(messagePointer + 8, search->second);
+	}
+	
+	else {
+		Helpers::warn("CFG::GetCountryCodeID: Invalid country code %X", characterCode);
+		mem.write32(messagePointer + 4, Result::CFG::NotFound);
+		mem.write16(messagePointer + 8, 0xFF);
+	}
 }

src/core/services/http.cpp

@@ -0,0 +1,42 @@
+#include "services/http.hpp"
+
+#include "ipc.hpp"
+#include "result/result.hpp"
+
+namespace HTTPCommands {
+	enum : u32 {
+		Initialize = 0x00010044,
+	};
+}
+
+void HTTPService::reset() { initialized = false; }
+
+void HTTPService::handleSyncRequest(u32 messagePointer) {
+	const u32 command = mem.read32(messagePointer);
+	switch (command) {
+		case HTTPCommands::Initialize: initialize(messagePointer); break;
+		default: Helpers::panic("HTTP service requested. Command: %08X\n", command);
+	}
+}
+
+void HTTPService::initialize(u32 messagePointer) {
+	const u32 postBufferSize = mem.read32(messagePointer + 4);
+	const u32 postMemoryBlockHandle = mem.read32(messagePointer + 20);
+	log("HTTP::Initialize (POST buffer size = %X, POST buffer memory block handle = %X)\n", postBufferSize, postMemoryBlockHandle);
+
+	mem.write32(messagePointer, IPC::responseHeader(0x01, 1, 0));
+
+	if (initialized) {
+		Helpers::warn("HTTP: Tried to initialize service while already initialized");
+		// TODO: Error code here
+	}
+
+	// 3DBrew: The provided POST buffer must be page-aligned (0x1000).
+	if (postBufferSize & 0xfff) {
+		Helpers::warn("HTTP: POST buffer size is not page-aligned");
+	}
+
+	initialized = true;
+	// We currently don't emulate HTTP properly. TODO: Prepare POST buffer here
+	mem.write32(messagePointer + 4, Result::Success);
+}

src/core/services/service_manager.cpp

@@ -7,8 +7,8 @@
 
 ServiceManager::ServiceManager(std::span<u32, 16> regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel)
 	: regs(regs), mem(mem), kernel(kernel), ac(mem), am(mem), boss(mem), act(mem), apt(mem, kernel), cam(mem), cecd(mem, kernel), cfg(mem),
-	  dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), ir_user(mem, kernel), frd(mem), fs(mem, kernel), gsp_gpu(mem, gpu, kernel, currentPID),
-	  gsp_lcd(mem), ldr(mem), mic(mem), nfc(mem, kernel), nim(mem), ndm(mem), ptm(mem), y2r(mem, kernel) {}
+	  dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), http(mem), ir_user(mem, kernel), frd(mem), fs(mem, kernel),
+	  gsp_gpu(mem, gpu, kernel, currentPID), gsp_lcd(mem), ldr(mem), mic(mem), nfc(mem, kernel), nim(mem), ndm(mem), ptm(mem), y2r(mem, kernel) {}
 
 static constexpr int MAX_NOTIFICATION_COUNT = 16;
 
@@ -25,6 +25,7 @@ void ServiceManager::reset() {
 	dlp_srvr.reset();
 	dsp.reset();
 	hid.reset();
+	http.reset();
 	ir_user.reset();
 	frd.reset();
 	fs.reset();
@@ -98,6 +99,7 @@ static std::map<std::string, Handle> serviceMap = {
 	{ "dlp:SRVR", KernelHandles::DLP_SRVR },
 	{ "dsp::DSP", KernelHandles::DSP },
 	{ "hid:USER", KernelHandles::HID },
+	{ "http:C", KernelHandles::HTTP },
 	{ "ir:USER", KernelHandles::IR_USER },
 	{ "frd:u", KernelHandles::FRD },
 	{ "fs:USER", KernelHandles::FS },
@@ -182,6 +184,7 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
 		case KernelHandles::CFG: cfg.handleSyncRequest(messagePointer); break;
 		case KernelHandles::DLP_SRVR: dlp_srvr.handleSyncRequest(messagePointer); break;
 		case KernelHandles::HID: hid.handleSyncRequest(messagePointer); break;
+		case KernelHandles::HTTP: http.handleSyncRequest(messagePointer); break;
 		case KernelHandles::IR_USER: ir_user.handleSyncRequest(messagePointer); break;
         case KernelHandles::FRD: frd.handleSyncRequest(messagePointer); break;
 		case KernelHandles::LCD: gsp_lcd.handleSyncRequest(messagePointer); break;

src/discord_rpc.cpp

@@ -0,0 +1,41 @@
+#ifdef PANDA3DS_ENABLE_DISCORD_RPC
+
+#include "discord_rpc.hpp"
+
+#include <cstring>
+#include <ctime>
+
+void Discord::RPC::init() {
+	DiscordEventHandlers handlers{};
+	Discord_Initialize("1138176975865909360", &handlers, 1, nullptr);
+
+	startTimestamp = time(nullptr);
+	enabled = true;
+}
+
+void Discord::RPC::update(Discord::RPCStatus status, const std::string& game) {
+	DiscordRichPresence rpc{};
+
+	if (status == Discord::RPCStatus::Playing) {
+		rpc.details = "Playing a game";
+		rpc.state = game.c_str();
+	} else {
+		rpc.details = "Idle";
+	}
+
+	rpc.largeImageKey = "pand";
+	rpc.largeImageText = "Panda3DS is a 3DS emulator for Windows, MacOS and Linux";
+	rpc.startTimestamp = startTimestamp;
+
+	Discord_UpdatePresence(&rpc);
+}
+
+void Discord::RPC::stop() {
+	if (enabled) {
+		enabled = false;
+		Discord_ClearPresence();
+		Discord_Shutdown();
+	}
+}
+
+#endif

src/emulator.cpp

@@ -13,7 +13,7 @@ __declspec(dllexport) DWORD AmdPowerXpressRequestHighPerformance = 1;
 
 Emulator::Emulator()
 	: config(std::filesystem::current_path() / "config.toml"), kernel(cpu, memory, gpu), cpu(memory, kernel), gpu(memory, config),
-	  memory(cpu.getTicksRef()), cheats(memory, kernel.getServiceManager().getHID())
+	  memory(cpu.getTicksRef()), cheats(memory, kernel.getServiceManager().getHID()), running(false), programRunning(false)
 #ifdef PANDA3DS_ENABLE_HTTP_SERVER
 	  , httpServer(this)
 #endif
@@ -34,6 +34,13 @@ Emulator::Emulator()
 	needOpenGL = needOpenGL || (config.rendererType == RendererType::OpenGL);
 #endif
 
+#ifdef PANDA3DS_ENABLE_DISCORD_RPC
+	if (config.discordRpcEnabled) {
+		discordRpc.init();
+		updateDiscord();
+	}
+#endif
+
 	if (needOpenGL) {
 		// Demand 3.3 core for software renderer, or 4.1 core for OpenGL renderer (max available on MacOS)
 		// MacOS gets mad if we don't explicitly demand a core profile
@@ -75,12 +82,16 @@ Emulator::Emulator()
 		}
 	}
 
-	running = false;
-	programRunning = false;
 	reset(ReloadOption::NoReload);
 }
 
-Emulator::~Emulator() { config.save(std::filesystem::current_path() / "config.toml"); }
+Emulator::~Emulator() {
+	config.save(std::filesystem::current_path() / "config.toml");
+
+#ifdef PANDA3DS_ENABLE_DISCORD_RPC
+	discordRpc.stop();
+#endif
+}
 
 void Emulator::reset(ReloadOption reload) {
 	cpu.reset();
@@ -121,6 +132,7 @@ void Emulator::run() {
 #ifdef PANDA3DS_ENABLE_HTTP_SERVER
 		httpServer.processActions();
 #endif
+
 		runFrame();
 		HIDService& hid = kernel.getServiceManager().getHID();
 
@@ -431,6 +443,9 @@ bool Emulator::loadROM(const std::filesystem::path& path) {
 
 	if (success) {
 		romPath = path;
+#ifdef PANDA3DS_ENABLE_DISCORD_RPC
+		updateDiscord();
+#endif
 	} else {
 		romPath = std::nullopt;
 		romType = ROMType::None;
@@ -487,3 +502,18 @@ bool Emulator::loadELF(std::ifstream& file) {
 
 // Reset our graphics context and initialize the GPU's graphics context
 void Emulator::initGraphicsContext() { gpu.initGraphicsContext(window); }
+
+#ifdef PANDA3DS_ENABLE_DISCORD_RPC
+void Emulator::updateDiscord() {
+	if (config.discordRpcEnabled) {
+		if (romType != ROMType::None) {
+			const auto name = romPath.value().stem();
+			discordRpc.update(Discord::RPCStatus::Playing, name.string());
+		} else {
+			discordRpc.update(Discord::RPCStatus::Idling, "");
+		}
+	}
+}
+#else
+void Emulator::updateDiscord() {}
+#endif

third_party/discord-rpc

@@ -0,0 +1 @@
+Subproject commit 963aa9f3e5ce81a4682c6ca3d136cddda614db33