From 0f80d0af7a2e2c9c8cad52c0b5ddc620b748f4b3 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Tue, 23 Jul 2024 15:22:15 +0300
Subject: [PATCH 01/38] Rename Handle to HorizonHandle, add metal-cpp
 submodule, format

---
 .gitmodules                           |  3 +++
 include/kernel/handles.hpp            |  8 ++++----
 include/kernel/kernel.hpp             |  2 ++
 include/kernel/kernel_types.hpp       | 10 +++++++++-
 include/memory.hpp                    | 10 +++++++++-
 include/services/ac.hpp               |  2 ++
 include/services/act.hpp              |  4 +++-
 include/services/am.hpp               |  4 +++-
 include/services/apt.hpp              |  7 +++++--
 include/services/boss.hpp             |  7 +++++--
 include/services/cam.hpp              |  1 +
 include/services/cecd.hpp             |  5 ++++-
 include/services/cfg.hpp              | 15 +++++++++------
 include/services/csnd.hpp             |  6 +++---
 include/services/dlp_srvr.hpp         |  4 +++-
 include/services/dsp.hpp              |  2 ++
 include/services/frd.hpp              | 11 +++++++----
 include/services/fs.hpp               |  4 +++-
 include/services/gsp_gpu.hpp          |  2 ++
 include/services/gsp_lcd.hpp          |  2 ++
 include/services/hid.hpp              |  2 ++
 include/services/http.hpp             |  2 ++
 include/services/ir_user.hpp          |  2 ++
 include/services/ldr_ro.hpp           |  4 +++-
 include/services/mcu/mcu_hwc.hpp      |  2 ++
 include/services/mic.hpp              |  6 ++++--
 include/services/ndm.hpp              | 11 +++++++++--
 include/services/news_u.hpp           |  2 ++
 include/services/nfc.hpp              |  2 ++
 include/services/nim.hpp              |  4 +++-
 include/services/nwm_uds.hpp          |  2 ++
 include/services/ptm.hpp              |  2 +-
 include/services/service_manager.hpp  |  2 ++
 include/services/soc.hpp              |  4 +++-
 include/services/ssl.hpp              |  8 +++++---
 include/services/y2r.hpp              | 15 +++++++++------
 src/core/kernel/address_arbiter.cpp   |  2 +-
 src/core/kernel/events.cpp            |  2 +-
 src/core/kernel/kernel.cpp            |  2 +-
 src/core/kernel/memory_management.cpp |  2 +-
 src/core/kernel/ports.cpp             |  6 +++---
 src/core/kernel/threads.cpp           |  6 +++---
 src/core/kernel/timers.cpp            |  2 +-
 src/core/services/fs.cpp              |  6 +++---
 src/core/services/service_manager.cpp |  2 +-
 third_party/metal-cpp                 |  1 +
 46 files changed, 150 insertions(+), 60 deletions(-)
 create mode 160000 third_party/metal-cpp

diff --git a/.gitmodules b/.gitmodules
index 5a136acb..656e1f41 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -73,3 +73,6 @@
 [submodule "third_party/hips"]
 	path = third_party/hips
 	url = https://github.com/wheremyfoodat/Hips
+[submodule "third_party/metal-cpp"]
+	path = third_party/metal-cpp
+	url = https://github.com/Panda3DS-emu/metal-cpp
diff --git a/include/kernel/handles.hpp b/include/kernel/handles.hpp
index fe746b65..45400837 100644
--- a/include/kernel/handles.hpp
+++ b/include/kernel/handles.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include "helpers.hpp"
 
-using Handle = u32;
+using HorizonHandle = u32;
 
 namespace KernelHandles {
 	enum : u32 {
@@ -61,17 +61,17 @@ namespace KernelHandles {
 	};
 
 	// Returns whether "handle" belongs to one of the OS services
-	static constexpr bool isServiceHandle(Handle handle) {
+	static constexpr bool isServiceHandle(HorizonHandle handle) {
 		return handle >= MinServiceHandle && handle <= MaxServiceHandle;
 	}
 
 	// Returns whether "handle" belongs to one of the OS services' shared memory areas
-	static constexpr bool isSharedMemHandle(Handle handle) {
+	static constexpr bool isSharedMemHandle(HorizonHandle handle) {
 		return handle >= MinSharedMemHandle && handle <= MaxSharedMemHandle;
 	}
 
 	// Returns the name of a handle as a string based on the given handle
-	static const char* getServiceName(Handle handle) {
+	static const char* getServiceName(HorizonHandle handle) {
 		switch (handle) {
 			case AC: return "AC";
 			case ACT: return "ACT";
diff --git a/include/kernel/kernel.hpp b/include/kernel/kernel.hpp
index e0c0651b..abc508ac 100644
--- a/include/kernel/kernel.hpp
+++ b/include/kernel/kernel.hpp
@@ -18,6 +18,8 @@ class CPU;
 struct Scheduler;
 
 class Kernel {
+	using Handle = HorizonHandle;
+
 	std::span<u32, 16> regs;
 	CPU& cpu;
 	Memory& mem;
diff --git a/include/kernel/kernel_types.hpp b/include/kernel/kernel_types.hpp
index a68ef8d5..a3a60c34 100644
--- a/include/kernel/kernel_types.hpp
+++ b/include/kernel/kernel_types.hpp
@@ -47,7 +47,7 @@ enum class ProcessorID : s32 {
 struct AddressArbiter {};
 
 struct ResourceLimits {
-    Handle handle;
+    HorizonHandle handle;
 
     s32 currentCommit = 0;
 };
@@ -91,6 +91,8 @@ struct Port {
 };
 
 struct Session {
+	using Handle = HorizonHandle;
+
 	Handle portHandle;  // The port this session is subscribed to
 	Session(Handle portHandle) : portHandle(portHandle) {}
 };
@@ -109,6 +111,8 @@ enum class ThreadStatus {
 };
 
 struct Thread {
+	using Handle = HorizonHandle;
+
 	u32 initialSP;   // Initial r13 value
 	u32 entrypoint;  // Initial r15 value
 	u32 priority;
@@ -161,6 +165,8 @@ static const char* kernelObjectTypeToString(KernelObjectType t) {
 }
 
 struct Mutex {
+    using Handle = HorizonHandle;
+
     u64 waitlist;           // Refer to the getWaitlist function below for documentation
     Handle ownerThread = 0; // Index of the thread that holds the mutex if it's locked
     Handle handle; // Handle of the mutex itself
@@ -203,6 +209,8 @@ struct MemoryBlock {
 
 // Generic kernel object class
 struct KernelObject {
+	using Handle = HorizonHandle;
+
     Handle handle = 0; // A u32 the OS will use to identify objects
     void* data = nullptr;
     KernelObjectType type;
diff --git a/include/memory.hpp b/include/memory.hpp
index 33ccbae5..2f01aa35 100644
--- a/include/memory.hpp
+++ b/include/memory.hpp
@@ -102,6 +102,8 @@ namespace KernelMemoryTypes {
 }
 
 class Memory {
+	using Handle = HorizonHandle;
+
 	u8* fcram;
 	u8* dspRam;  // Provided to us by Audio
 	u8* vram;    // Provided to the memory class by the GPU class
@@ -213,8 +215,14 @@ private:
 	}
 
 	enum class BatteryLevel {
-		Empty = 0, AlmostEmpty, OneBar, TwoBars, ThreeBars, FourBars
+		Empty = 0,
+		AlmostEmpty,
+		OneBar,
+		TwoBars,
+		ThreeBars,
+		FourBars,
 	};
+
 	u8 getBatteryState(bool adapterConnected, bool charging, BatteryLevel batteryLevel) {
 		u8 value = static_cast<u8>(batteryLevel) << 2; // Bits 2:4 are the battery level from 0 to 5
 		if (adapterConnected) value |= 1 << 0; // Bit 0 shows if the charger is connected
diff --git a/include/services/ac.hpp b/include/services/ac.hpp
index 4ba53033..56acd436 100644
--- a/include/services/ac.hpp
+++ b/include/services/ac.hpp
@@ -8,6 +8,8 @@
 #include "result/result.hpp"
 
 class ACService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::AC;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, acLogger)
diff --git a/include/services/act.hpp b/include/services/act.hpp
index 92c69c60..3fe68993 100644
--- a/include/services/act.hpp
+++ b/include/services/act.hpp
@@ -6,6 +6,8 @@
 #include "result/result.hpp"
 
 class ACTService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::ACT;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, actLogger)
@@ -15,7 +17,7 @@ class ACTService {
 	void generateUUID(u32 messagePointer);
 	void getAccountDataBlock(u32 messagePointer);
 
-public:
+  public:
 	ACTService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/am.hpp b/include/services/am.hpp
index 672909ff..f72a5efc 100644
--- a/include/services/am.hpp
+++ b/include/services/am.hpp
@@ -6,6 +6,8 @@
 #include "result/result.hpp"
 
 class AMService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::AM;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, amLogger)
@@ -15,7 +17,7 @@ class AMService {
 	void getPatchTitleInfo(u32 messagePointer);
 	void listTitleInfo(u32 messagePointer);
 
-public:
+  public:
 	AMService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/apt.hpp b/include/services/apt.hpp
index 48a59c2d..624151c1 100644
--- a/include/services/apt.hpp
+++ b/include/services/apt.hpp
@@ -12,7 +12,8 @@
 class Kernel;
 
 enum class ConsoleModel : u32 {
-	Old3DS, New3DS
+	Old3DS,
+	New3DS,
 };
 
 // https://www.3dbrew.org/wiki/NS_and_APT_Services#Command
@@ -41,6 +42,8 @@ namespace APT::Transitions {
 }
 
 class APTService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::APT;
 	Memory& mem;
 	Kernel& kernel;
@@ -99,7 +102,7 @@ class APTService {
 
 	u32 screencapPostPermission;
 
-public:
+  public:
 	APTService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel), appletManager(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/boss.hpp b/include/services/boss.hpp
index 769184e5..edc50dee 100644
--- a/include/services/boss.hpp
+++ b/include/services/boss.hpp
@@ -6,6 +6,8 @@
 #include "result/result.hpp"
 
 class BOSSService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::BOSS;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, bossLogger)
@@ -17,7 +19,7 @@ class BOSSService {
 	void getNewArrivalFlag(u32 messagePointer);
 	void getNsDataIdList(u32 messagePointer, u32 commandWord);
 	void getOptoutFlag(u32 messagePointer);
-	void getStorageEntryInfo(u32 messagePointer); // Unknown what this is, name taken from Citra
+	void getStorageEntryInfo(u32 messagePointer);  // Unknown what this is, name taken from Citra
 	void getTaskIdList(u32 messagePointer);
 	void getTaskInfo(u32 messagePointer);
 	void getTaskServiceStatus(u32 messagePointer);
@@ -35,7 +37,8 @@ class BOSSService {
 	void unregisterTask(u32 messagePointer);
 
 	s8 optoutFlag;
-public:
+
+  public:
 	BOSSService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/cam.hpp b/include/services/cam.hpp
index 60ede3b9..e5254997 100644
--- a/include/services/cam.hpp
+++ b/include/services/cam.hpp
@@ -12,6 +12,7 @@
 class Kernel;
 
 class CAMService {
+	using Handle = HorizonHandle;
 	using Event = std::optional<Handle>;
 
 	struct Port {
diff --git a/include/services/cecd.hpp b/include/services/cecd.hpp
index 656e38ad..4612c17b 100644
--- a/include/services/cecd.hpp
+++ b/include/services/cecd.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <optional>
+
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
@@ -9,6 +10,8 @@
 class Kernel;
 
 class CECDService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::CECD;
 	Memory& mem;
 	Kernel& kernel;
@@ -20,7 +23,7 @@ class CECDService {
 	void getInfoEventHandle(u32 messagePointer);
 	void openAndRead(u32 messagePointer);
 
-public:
+  public:
 	CECDService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/cfg.hpp b/include/services/cfg.hpp
index 7241a409..e2ddffa8 100644
--- a/include/services/cfg.hpp
+++ b/include/services/cfg.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <cstring>
+
 #include "helpers.hpp"
 #include "logger.hpp"
 #include "memory.hpp"
@@ -7,8 +8,10 @@
 #include "result/result.hpp"
 
 class CFGService {
+	using Handle = HorizonHandle;
+
 	Memory& mem;
-	CountryCodes country = CountryCodes::US; // Default to USA
+	CountryCodes country = CountryCodes::US;  // Default to USA
 	MAKE_LOG_FUNCTION(log, cfgLogger)
 
 	void writeStringU16(u32 pointer, const std::u16string& string);
@@ -27,12 +30,12 @@ class CFGService {
 
 	void getConfigInfo(u32 output, u32 blockID, u32 size, u32 permissionMask);
 
-public:
+  public:
 	enum class Type {
-		U, // cfg:u
-		I, // cfg:i
-		S, // cfg:s
-		NOR, // cfg:nor
+		U,    // cfg:u
+		I,    // cfg:i
+		S,    // cfg:s
+		NOR,  // cfg:nor
 	};
 
 	CFGService(Memory& mem) : mem(mem) {}
diff --git a/include/services/csnd.hpp b/include/services/csnd.hpp
index 8f6d60f8..93fa941d 100644
--- a/include/services/csnd.hpp
+++ b/include/services/csnd.hpp
@@ -10,6 +10,8 @@
 class Kernel;
 
 class CSNDService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::CSND;
 	Memory& mem;
 	Kernel& kernel;
@@ -30,7 +32,5 @@ class CSNDService {
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
 
-	void setSharedMemory(u8* ptr) {
-		sharedMemory = ptr;
-	}
+	void setSharedMemory(u8* ptr) { sharedMemory = ptr; }
 };
\ No newline at end of file
diff --git a/include/services/dlp_srvr.hpp b/include/services/dlp_srvr.hpp
index 1e714283..ae9cc96f 100644
--- a/include/services/dlp_srvr.hpp
+++ b/include/services/dlp_srvr.hpp
@@ -8,6 +8,8 @@
 // Please forgive me for how everything in this file is named
 // "dlp:SRVR" is not a nice name to work with
 class DlpSrvrService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::DLP_SRVR;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, dlpSrvrLogger)
@@ -15,7 +17,7 @@ class DlpSrvrService {
 	// Service commands
 	void isChild(u32 messagePointer);
 
-public:
+  public:
 	DlpSrvrService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/dsp.hpp b/include/services/dsp.hpp
index 5cbd4fd5..bc1adbca 100644
--- a/include/services/dsp.hpp
+++ b/include/services/dsp.hpp
@@ -14,6 +14,8 @@
 class Kernel;
 
 class DSPService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::DSP;
 	Memory& mem;
 	Kernel& kernel;
diff --git a/include/services/frd.hpp b/include/services/frd.hpp
index b9b3b0fe..914d9251 100644
--- a/include/services/frd.hpp
+++ b/include/services/frd.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <cassert>
+
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
@@ -15,6 +16,8 @@ struct FriendKey {
 static_assert(sizeof(FriendKey) == 16);
 
 class FRDService {
+	using Handle = HorizonHandle;
+
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, frdLogger)
 
@@ -51,11 +54,11 @@ class FRDService {
 	};
 	static_assert(sizeof(Profile) == 8);
 
-public:
+  public:
 	enum class Type {
-		A,    // frd:a
-		N,    // frd:n
-		U,    // frd:u
+		A,  // frd:a
+		N,  // frd:n
+		U,  // frd:u
 	};
 
 	FRDService(Memory& mem) : mem(mem) {}
diff --git a/include/services/fs.hpp b/include/services/fs.hpp
index 4a613121..3b3b3d44 100644
--- a/include/services/fs.hpp
+++ b/include/services/fs.hpp
@@ -16,6 +16,8 @@
 class Kernel;
 
 class FSService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::FS;
 	Memory& mem;
 	Kernel& kernel;
@@ -81,7 +83,7 @@ class FSService {
 	// Used for set/get priority: Not sure what sort of priority this is referring to
 	u32 priority;
 
-public:
+  public:
 	FSService(Memory& mem, Kernel& kernel, const EmulatorConfig& config)
 		: mem(mem), saveData(mem), sharedExtSaveData_nand(mem, "../SharedFiles/NAND", true), extSaveData_sdmc(mem, "SDMC"), sdmc(mem),
 		  sdmcWriteOnly(mem, true), selfNcch(mem), ncch(mem), userSaveData1(mem, ArchiveID::UserSaveData1),
diff --git a/include/services/gsp_gpu.hpp b/include/services/gsp_gpu.hpp
index 0da4fcd0..d7244609 100644
--- a/include/services/gsp_gpu.hpp
+++ b/include/services/gsp_gpu.hpp
@@ -22,6 +22,8 @@ enum class GPUInterrupt : u8 {
 class Kernel;
 
 class GPUService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::GPU;
 	Memory& mem;
 	GPU& gpu;
diff --git a/include/services/gsp_lcd.hpp b/include/services/gsp_lcd.hpp
index e7672d4f..f34f59ab 100644
--- a/include/services/gsp_lcd.hpp
+++ b/include/services/gsp_lcd.hpp
@@ -6,6 +6,8 @@
 #include "result/result.hpp"
 
 class LCDService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::LCD;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, gspLCDLogger)
diff --git a/include/services/hid.hpp b/include/services/hid.hpp
index d9018a4f..86a55479 100644
--- a/include/services/hid.hpp
+++ b/include/services/hid.hpp
@@ -38,6 +38,8 @@ namespace HID::Keys {
 class Kernel;
 
 class HIDService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::HID;
 	Memory& mem;
 	Kernel& kernel;
diff --git a/include/services/http.hpp b/include/services/http.hpp
index 1e7f30c3..8b23fb2d 100644
--- a/include/services/http.hpp
+++ b/include/services/http.hpp
@@ -5,6 +5,8 @@
 #include "memory.hpp"
 
 class HTTPService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::HTTP;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, httpLogger)
diff --git a/include/services/ir_user.hpp b/include/services/ir_user.hpp
index 186d9717..d475bdaa 100644
--- a/include/services/ir_user.hpp
+++ b/include/services/ir_user.hpp
@@ -11,6 +11,8 @@
 class Kernel;
 
 class IRUserService {
+	using Handle = HorizonHandle;
+
 	enum class DeviceID : u8 {
 		CirclePadPro = 1,
 	};
diff --git a/include/services/ldr_ro.hpp b/include/services/ldr_ro.hpp
index 71516547..cf60e036 100644
--- a/include/services/ldr_ro.hpp
+++ b/include/services/ldr_ro.hpp
@@ -8,6 +8,8 @@
 class Kernel;
 
 class LDRService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::LDR_RO;
 	Memory& mem;
 	Kernel& kernel;
@@ -22,7 +24,7 @@ class LDRService {
 	void loadCRR(u32 messagePointer);
 	void unloadCRO(u32 messagePointer);
 
-public:
+  public:
 	LDRService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/mcu/mcu_hwc.hpp b/include/services/mcu/mcu_hwc.hpp
index 354a0c20..4c6a8830 100644
--- a/include/services/mcu/mcu_hwc.hpp
+++ b/include/services/mcu/mcu_hwc.hpp
@@ -7,6 +7,8 @@
 
 namespace MCU {
 	class HWCService {
+		using Handle = HorizonHandle;
+
 		Handle handle = KernelHandles::MCU_HWC;
 		Memory& mem;
 		MAKE_LOG_FUNCTION(log, mcuLogger)
diff --git a/include/services/mic.hpp b/include/services/mic.hpp
index f709c27f..f166c5aa 100644
--- a/include/services/mic.hpp
+++ b/include/services/mic.hpp
@@ -9,6 +9,8 @@
 class Kernel;
 
 class MICService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::MIC;
 	Memory& mem;
 	Kernel& kernel;
@@ -29,14 +31,14 @@ class MICService {
 	void unmapSharedMem(u32 messagePointer);
 	void theCaptainToadFunction(u32 messagePointer);
 
-	u8 gain = 0; // How loud our microphone input signal is
+	u8 gain = 0;  // How loud our microphone input signal is
 	bool micEnabled = false;
 	bool shouldClamp = false;
 	bool currentlySampling = false;
 
 	std::optional<Handle> eventHandle;
 
-public:
+  public:
 	MICService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/ndm.hpp b/include/services/ndm.hpp
index 6d4e5ad8..67679403 100644
--- a/include/services/ndm.hpp
+++ b/include/services/ndm.hpp
@@ -6,7 +6,14 @@
 #include "result/result.hpp"
 
 class NDMService {
-	enum class ExclusiveState : u32 { None = 0, Infrastructure = 1, LocalComms = 2, StreetPass = 3, StreetPassData = 4 };
+	using Handle = HorizonHandle;
+	enum class ExclusiveState : u32 {
+		None = 0,
+		Infrastructure = 1,
+		LocalComms = 2,
+		StreetPass = 3,
+		StreetPassData = 4,
+	};
 
 	Handle handle = KernelHandles::NDM;
 	Memory& mem;
@@ -25,7 +32,7 @@ class NDMService {
 
 	ExclusiveState exclusiveState = ExclusiveState::None;
 
-public:
+  public:
 	NDMService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/news_u.hpp b/include/services/news_u.hpp
index 61266e9a..15ae0b16 100644
--- a/include/services/news_u.hpp
+++ b/include/services/news_u.hpp
@@ -5,6 +5,8 @@
 #include "memory.hpp"
 
 class NewsUService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::NEWS_U;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, newsLogger)
diff --git a/include/services/nfc.hpp b/include/services/nfc.hpp
index 8eea8a41..e242a326 100644
--- a/include/services/nfc.hpp
+++ b/include/services/nfc.hpp
@@ -12,6 +12,8 @@
 class Kernel;
 
 class NFCService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::NFC;
 	Memory& mem;
 	Kernel& kernel;
diff --git a/include/services/nim.hpp b/include/services/nim.hpp
index dfe13694..dbb3bb8b 100644
--- a/include/services/nim.hpp
+++ b/include/services/nim.hpp
@@ -6,6 +6,8 @@
 #include "result/result.hpp"
 
 class NIMService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::NIM;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, nimLogger)
@@ -13,7 +15,7 @@ class NIMService {
 	// Service commands
 	void initialize(u32 messagePointer);
 
-public:
+  public:
 	NIMService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/nwm_uds.hpp b/include/services/nwm_uds.hpp
index bf116bcf..a3b342b8 100644
--- a/include/services/nwm_uds.hpp
+++ b/include/services/nwm_uds.hpp
@@ -10,6 +10,8 @@
 class Kernel;
 
 class NwmUdsService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::NWM_UDS;
 	Memory& mem;
 	Kernel& kernel;
diff --git a/include/services/ptm.hpp b/include/services/ptm.hpp
index f752839b..5b797a1d 100644
--- a/include/services/ptm.hpp
+++ b/include/services/ptm.hpp
@@ -22,7 +22,7 @@ class PTMService {
 	void getStepHistoryAll(u32 messagePointer);
 	void getTotalStepCount(u32 messagePointer);
 
-public:
+  public:
 	enum class Type {
 		U,     // ptm:u
 		SYSM,  // ptm:sysm
diff --git a/include/services/service_manager.hpp b/include/services/service_manager.hpp
index 6679f98d..4fa1e665 100644
--- a/include/services/service_manager.hpp
+++ b/include/services/service_manager.hpp
@@ -42,6 +42,8 @@ struct EmulatorConfig;
 class Kernel;
 
 class ServiceManager {
+	using Handle = HorizonHandle;
+
 	std::span<u32, 16> regs;
 	Memory& mem;
 	Kernel& kernel;
diff --git a/include/services/soc.hpp b/include/services/soc.hpp
index 88f0b456..ff334a2c 100644
--- a/include/services/soc.hpp
+++ b/include/services/soc.hpp
@@ -5,6 +5,8 @@
 #include "memory.hpp"
 
 class SOCService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::SOC;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, socLogger)
@@ -14,7 +16,7 @@ class SOCService {
 	// Service commands
 	void initializeSockets(u32 messagePointer);
 
-public:
+  public:
 	SOCService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/include/services/ssl.hpp b/include/services/ssl.hpp
index 0282049a..4b45fc81 100644
--- a/include/services/ssl.hpp
+++ b/include/services/ssl.hpp
@@ -1,17 +1,19 @@
 #pragma once
+#include <random>
+
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
 #include "memory.hpp"
 
-#include <random>
-
 class SSLService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::SSL;
 	Memory& mem;
 	MAKE_LOG_FUNCTION(log, sslLogger)
 
-	std::mt19937 rng; // Use a Mersenne Twister for RNG since this service is supposed to have better rng than just rand()
+	std::mt19937 rng;  // Use a Mersenne Twister for RNG since this service is supposed to have better rng than just rand()
 	bool initialized;
 
 	// Service commands
diff --git a/include/services/y2r.hpp b/include/services/y2r.hpp
index 4aa96d7b..6afebdb8 100644
--- a/include/services/y2r.hpp
+++ b/include/services/y2r.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include <array>
 #include <optional>
+
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
@@ -10,6 +11,8 @@
 class Kernel;
 
 class Y2RService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::Y2R;
 	Memory& mem;
 	Kernel& kernel;
@@ -20,7 +23,7 @@ class Y2RService {
 
 	enum class BusyStatus : u32 {
 		NotBusy = 0,
-		Busy = 1
+		Busy = 1,
 	};
 
 	enum class InputFormat : u32 {
@@ -35,7 +38,7 @@ class Y2RService {
 		RGB32 = 0,
 		RGB24 = 1,
 		RGB15 = 2,
-		RGB565 = 3
+		RGB565 = 3,
 	};
 
 	// Clockwise rotation
@@ -43,12 +46,12 @@ class Y2RService {
 		None = 0,
 		Rotate90 = 1,
 		Rotate180 = 2,
-		Rotate270 = 3
+		Rotate270 = 3,
 	};
 
 	enum class BlockAlignment : u32 {
-		Line = 0, // Output buffer's pixels are arranged linearly. Used when outputting to the framebuffer.
-		Block8x8 = 1, // Output buffer's pixels are morton swizzled. Used when outputting to a GPU texture.
+		Line = 0,      // Output buffer's pixels are arranged linearly. Used when outputting to the framebuffer.
+		Block8x8 = 1,  // Output buffer's pixels are morton swizzled. Used when outputting to a GPU texture.
 	};
 
 	// https://github.com/citra-emu/citra/blob/ac9d72a95ca9a60de8d39484a14aecf489d6d016/src/core/hle/service/cam/y2r_u.cpp#L33
@@ -60,7 +63,7 @@ class Y2RService {
 		{{0x12A, 0x1CA, 0x88, 0x36, 0x21C, -0x1F04, 0x99C, -0x2421}},   // ITU_Rec709_Scaling
 	}};
 
-	CoefficientSet conversionCoefficients; // Current conversion coefficients
+	CoefficientSet conversionCoefficients;  // Current conversion coefficients
 
 	InputFormat inputFmt;
 	OutputFormat outputFmt;
diff --git a/src/core/kernel/address_arbiter.cpp b/src/core/kernel/address_arbiter.cpp
index 8c07b423..d15c81b8 100644
--- a/src/core/kernel/address_arbiter.cpp
+++ b/src/core/kernel/address_arbiter.cpp
@@ -12,7 +12,7 @@ static const char* arbitrationTypeToString(u32 type) {
 	}
 }
 
-Handle Kernel::makeArbiter() {
+HorizonHandle Kernel::makeArbiter() {
 	if (arbiterCount >= appResourceLimits.maxAddressArbiters) {
 		Helpers::panic("Overflowed the number of address arbiters");
 	}
diff --git a/src/core/kernel/events.cpp b/src/core/kernel/events.cpp
index 7c0d3047..6d3dfbd7 100644
--- a/src/core/kernel/events.cpp
+++ b/src/core/kernel/events.cpp
@@ -12,7 +12,7 @@ const char* Kernel::resetTypeToString(u32 type) {
 	}
 }
 
-Handle Kernel::makeEvent(ResetType resetType, Event::CallbackType callback) {
+HorizonHandle Kernel::makeEvent(ResetType resetType, Event::CallbackType callback) {
 	Handle ret = makeObject(KernelObjectType::Event);
 	objects[ret].data = new Event(resetType, callback);
 	return ret;
diff --git a/src/core/kernel/kernel.cpp b/src/core/kernel/kernel.cpp
index 0d1efc15..d4229b55 100644
--- a/src/core/kernel/kernel.cpp
+++ b/src/core/kernel/kernel.cpp
@@ -82,7 +82,7 @@ void Kernel::setVersion(u8 major, u8 minor) {
 	mem.kernelVersion = descriptor; // The memory objects needs a copy because you can read the kernel ver from config mem
 }
 
-Handle Kernel::makeProcess(u32 id) {
+HorizonHandle Kernel::makeProcess(u32 id) {
 	const Handle processHandle = makeObject(KernelObjectType::Process);
 	const Handle resourceLimitHandle = makeObject(KernelObjectType::ResourceLimit);
 
diff --git a/src/core/kernel/memory_management.cpp b/src/core/kernel/memory_management.cpp
index 0d234be5..aeac6269 100644
--- a/src/core/kernel/memory_management.cpp
+++ b/src/core/kernel/memory_management.cpp
@@ -154,7 +154,7 @@ void Kernel::mapMemoryBlock() {
 	regs[0] = Result::Success;
 }
 
-Handle Kernel::makeMemoryBlock(u32 addr, u32 size, u32 myPermission, u32 otherPermission) {
+HorizonHandle Kernel::makeMemoryBlock(u32 addr, u32 size, u32 myPermission, u32 otherPermission) {
 	Handle ret = makeObject(KernelObjectType::MemoryBlock);
 	objects[ret].data = new MemoryBlock(addr, size, myPermission, otherPermission);
 
diff --git a/src/core/kernel/ports.cpp b/src/core/kernel/ports.cpp
index 6038de44..61ab26e3 100644
--- a/src/core/kernel/ports.cpp
+++ b/src/core/kernel/ports.cpp
@@ -1,7 +1,7 @@
 #include "kernel.hpp"
 #include <cstring>
 
-Handle Kernel::makePort(const char* name) {
+HorizonHandle Kernel::makePort(const char* name) {
 	Handle ret = makeObject(KernelObjectType::Port);
 	portHandles.push_back(ret); // Push the port handle to our cache of port handles
 	objects[ret].data = new Port(name);
@@ -9,7 +9,7 @@ Handle Kernel::makePort(const char* name) {
 	return ret;
 }
 
-Handle Kernel::makeSession(Handle portHandle) {
+HorizonHandle Kernel::makeSession(Handle portHandle) {
 	const auto port = getObject(portHandle, KernelObjectType::Port);
 	if (port == nullptr) [[unlikely]] {
 		Helpers::panic("Trying to make session for non-existent port");
@@ -23,7 +23,7 @@ Handle Kernel::makeSession(Handle portHandle) {
 
 // Get the handle of a port based on its name
 // If there's no such port, return nullopt
-std::optional<Handle> Kernel::getPortHandle(const char* name) {
+std::optional<HorizonHandle> Kernel::getPortHandle(const char* name) {
 	for (auto handle : portHandles) {
 		const auto data = objects[handle].getData<Port>();
 		if (std::strncmp(name, data->name, Port::maxNameLen) == 0) {
diff --git a/src/core/kernel/threads.cpp b/src/core/kernel/threads.cpp
index 3a6201c1..9eb7a197 100644
--- a/src/core/kernel/threads.cpp
+++ b/src/core/kernel/threads.cpp
@@ -109,7 +109,7 @@ void Kernel::rescheduleThreads() {
 }
 
 // Internal OS function to spawn a thread
-Handle Kernel::makeThread(u32 entrypoint, u32 initialSP, u32 priority, ProcessorID id, u32 arg, ThreadStatus status) {
+HorizonHandle Kernel::makeThread(u32 entrypoint, u32 initialSP, u32 priority, ProcessorID id, u32 arg, ThreadStatus status) {
 	int index; // Index of the created thread in the  threads array
 
 	if (threadCount < appResourceLimits.maxThreads) [[likely]] { // If we have not yet created over too many threads
@@ -161,7 +161,7 @@ Handle Kernel::makeThread(u32 entrypoint, u32 initialSP, u32 priority, Processor
 	return ret;
 }
 
-Handle Kernel::makeMutex(bool locked) {
+HorizonHandle Kernel::makeMutex(bool locked) {
 	Handle ret = makeObject(KernelObjectType::Mutex);
 	objects[ret].data = new Mutex(locked, ret);
 
@@ -201,7 +201,7 @@ void Kernel::releaseMutex(Mutex* moo) {
 	}
 }
 
-Handle Kernel::makeSemaphore(u32 initialCount, u32 maximumCount) {
+HorizonHandle Kernel::makeSemaphore(u32 initialCount, u32 maximumCount) {
 	Handle ret = makeObject(KernelObjectType::Semaphore);
 	objects[ret].data = new Semaphore(initialCount, maximumCount);
 
diff --git a/src/core/kernel/timers.cpp b/src/core/kernel/timers.cpp
index 35fc57a4..8cfa4773 100644
--- a/src/core/kernel/timers.cpp
+++ b/src/core/kernel/timers.cpp
@@ -4,7 +4,7 @@
 #include "kernel.hpp"
 #include "scheduler.hpp"
 
-Handle Kernel::makeTimer(ResetType type) {
+HorizonHandle Kernel::makeTimer(ResetType type) {
 	Handle ret = makeObject(KernelObjectType::Timer);
 	objects[ret].data = new Timer(type);
 
diff --git a/src/core/services/fs.cpp b/src/core/services/fs.cpp
index 2e102958..e81db6cd 100644
--- a/src/core/services/fs.cpp
+++ b/src/core/services/fs.cpp
@@ -105,7 +105,7 @@ ArchiveBase* FSService::getArchiveFromID(u32 id, const FSPath& archivePath) {
 	}
 }
 
-std::optional<Handle> FSService::openFileHandle(ArchiveBase* archive, const FSPath& path, const FSPath& archivePath, const FilePerms& perms) {
+std::optional<HorizonHandle> FSService::openFileHandle(ArchiveBase* archive, const FSPath& path, const FSPath& archivePath, const FilePerms& perms) {
 	FileDescriptor opened = archive->openFile(path, perms);
 	if (opened.has_value()) { // If opened doesn't have a value, we failed to open the file
 		auto handle = kernel.makeObject(KernelObjectType::File);
@@ -119,7 +119,7 @@ std::optional<Handle> FSService::openFileHandle(ArchiveBase* archive, const FSPa
 	}
 }
 
-Rust::Result<Handle, Result::HorizonResult> FSService::openDirectoryHandle(ArchiveBase* archive, const FSPath& path) {
+Rust::Result<HorizonHandle, Result::HorizonResult> FSService::openDirectoryHandle(ArchiveBase* archive, const FSPath& path) {
 	Rust::Result<DirectorySession, Result::HorizonResult> opened = archive->openDirectory(path);
 	if (opened.isOk()) { // If opened doesn't have a value, we failed to open the directory
 		auto handle = kernel.makeObject(KernelObjectType::Directory);
@@ -132,7 +132,7 @@ Rust::Result<Handle, Result::HorizonResult> FSService::openDirectoryHandle(Archi
 	}
 }
 
-Rust::Result<Handle, Result::HorizonResult> FSService::openArchiveHandle(u32 archiveID, const FSPath& path) {
+Rust::Result<HorizonHandle, Result::HorizonResult> FSService::openArchiveHandle(u32 archiveID, const FSPath& path) {
 	ArchiveBase* archive = getArchiveFromID(archiveID, path);
 
 	if (archive == nullptr) [[unlikely]] {
diff --git a/src/core/services/service_manager.cpp b/src/core/services/service_manager.cpp
index 2a95b5c9..31e3d702 100644
--- a/src/core/services/service_manager.cpp
+++ b/src/core/services/service_manager.cpp
@@ -93,7 +93,7 @@ void ServiceManager::registerClient(u32 messagePointer) {
 }
 
 // clang-format off
-static std::map<std::string, Handle> serviceMap = {
+static std::map<std::string, HorizonHandle> serviceMap = {
 	{ "ac:u", KernelHandles::AC },
 	{ "act:a", KernelHandles::ACT },
 	{ "act:u", KernelHandles::ACT },
diff --git a/third_party/metal-cpp b/third_party/metal-cpp
new file mode 160000
index 00000000..a63bd172
--- /dev/null
+++ b/third_party/metal-cpp
@@ -0,0 +1 @@
+Subproject commit a63bd172ddcba73a3d87ca32032b66ad41ddb9a6

From c319e595457fb5e25a959c043953419bd26e1f58 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Tue, 23 Jul 2024 20:13:14 +0000
Subject: [PATCH 02/38] Resizing window on Qt (#556)

* Qt: Add screen resize

* Qt: Allocate screen on heap for setCentralWidget

* Fix header inclusion order

* Switch to std::function for resize callback

* rdeepfried
---
 include/panda_qt/main_window.hpp | 10 +++++++-
 include/panda_qt/screen.hpp      | 16 ++++++++++++-
 src/panda_qt/main_window.cpp     | 41 ++++++++++++++++++++++++--------
 src/panda_qt/screen.cpp          | 30 +++++++++++++++++++++--
 4 files changed, 83 insertions(+), 14 deletions(-)

diff --git a/include/panda_qt/main_window.hpp b/include/panda_qt/main_window.hpp
index 831074a2..c99fb4c2 100644
--- a/include/panda_qt/main_window.hpp
+++ b/include/panda_qt/main_window.hpp
@@ -50,6 +50,7 @@ class MainWindow : public QMainWindow {
 		PressTouchscreen,
 		ReleaseTouchscreen,
 		ReloadUbershader,
+		SetScreenSize,
 	};
 
 	// Tagged union representing our message queue messages
@@ -81,6 +82,11 @@ class MainWindow : public QMainWindow {
 				u16 x;
 				u16 y;
 			} touchscreen;
+
+			struct {
+				u32 width;
+				u32 height;
+			} screenSize;
 		};
 	};
 
@@ -95,7 +101,7 @@ class MainWindow : public QMainWindow {
 
 	QMenuBar* menuBar = nullptr;
 	InputMappings keyboardMappings;
-	ScreenWidget screen;
+	ScreenWidget* screen;
 	AboutWindow* aboutWindow;
 	ConfigWindow* configWindow;
 	CheatsWindow* cheatsEditor;
@@ -141,4 +147,6 @@ class MainWindow : public QMainWindow {
 	void loadLuaScript(const std::string& code);
 	void reloadShader(const std::string& shader);
 	void editCheat(u32 handle, const std::vector<uint8_t>& cheat, const std::function<void(u32)>& callback);
+
+	void handleScreenResize(u32 width, u32 height);
 };
diff --git a/include/panda_qt/screen.hpp b/include/panda_qt/screen.hpp
index dcff3e90..1ed4966b 100644
--- a/include/panda_qt/screen.hpp
+++ b/include/panda_qt/screen.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <QWidget>
+#include <functional>
 #include <memory>
 
 #include "gl/context.h"
@@ -10,15 +11,28 @@ class ScreenWidget : public QWidget {
 	Q_OBJECT
 
   public:
-	ScreenWidget(QWidget* parent = nullptr);
+	using ResizeCallback = std::function<void(u32, u32)>;
+
+	ScreenWidget(ResizeCallback resizeCallback, QWidget* parent = nullptr);
+	void resizeEvent(QResizeEvent* event) override;
+	// Called by the emulator thread for resizing the actual GL surface, since the emulator thread owns the GL context
+	void resizeSurface(u32 width, u32 height);
+
 	GL::Context* getGLContext() { return glContext.get(); }
 
 	// Dimensions of our output surface
 	u32 surfaceWidth = 0;
 	u32 surfaceHeight = 0;
+	WindowInfo windowInfo;
+
+	// Cached "previous" dimensions, used when resizing our window
+	u32 previousWidth = 0;
+	u32 previousHeight = 0;
 
   private:
 	std::unique_ptr<GL::Context> glContext = nullptr;
+	ResizeCallback resizeCallback;
+
 	bool createGLContext();
 
 	qreal devicePixelRatioFromScreen() const;
diff --git a/src/panda_qt/main_window.cpp b/src/panda_qt/main_window.cpp
index cfa45e85..1f9b8123 100644
--- a/src/panda_qt/main_window.cpp
+++ b/src/panda_qt/main_window.cpp
@@ -11,13 +11,17 @@
 #include "input_mappings.hpp"
 #include "services/dsp.hpp"
 
-MainWindow::MainWindow(QApplication* app, QWidget* parent) : QMainWindow(parent), keyboardMappings(InputMappings::defaultKeyboardMappings()), screen(this) {
+MainWindow::MainWindow(QApplication* app, QWidget* parent) : QMainWindow(parent), keyboardMappings(InputMappings::defaultKeyboardMappings()) {
 	setWindowTitle("Alber");
 	// Enable drop events for loading ROMs
 	setAcceptDrops(true);
 	resize(800, 240 * 4);
-	screen.show();
 
+	// We pass a callback to the screen widget that will be triggered every time we resize the screen
+	screen = new ScreenWidget([this](u32 width, u32 height) { handleScreenResize(width, height); }, this);
+	setCentralWidget(screen);
+
+	screen->show();
 	appRunning = true;
 
 	// Set our menu bar up
@@ -69,7 +73,7 @@ MainWindow::MainWindow(QApplication* app, QWidget* parent) : QMainWindow(parent)
 	connect(aboutAction, &QAction::triggered, this, &MainWindow::showAboutMenu);
 
 	emu = new Emulator();
-	emu->setOutputSize(screen.surfaceWidth, screen.surfaceHeight);
+	emu->setOutputSize(screen->surfaceWidth, screen->surfaceHeight);
 
 	// Set up misc objects
 	aboutWindow = new AboutWindow(nullptr);
@@ -101,7 +105,7 @@ MainWindow::MainWindow(QApplication* app, QWidget* parent) : QMainWindow(parent)
 
 		if (usingGL) {
 			// Make GL context current for this thread, enable VSync
-			GL::Context* glContext = screen.getGLContext();
+			GL::Context* glContext = screen->getGLContext();
 			glContext->MakeCurrent();
 			glContext->SetSwapInterval(emu->getConfig().vsyncEnabled ? 1 : 0);
 
@@ -145,13 +149,13 @@ void MainWindow::emuThreadMainLoop() {
 
 	// Unbind GL context if we're using GL, otherwise some setups seem to be unable to join this thread
 	if (usingGL) {
-		screen.getGLContext()->DoneCurrent();
+		screen->getGLContext()->DoneCurrent();
 	}
 }
 
 void MainWindow::swapEmuBuffer() {
 	if (usingGL) {
-		screen.getGLContext()->SwapBuffers();
+		screen->getGLContext()->SwapBuffers();
 	} else {
 		Helpers::panic("[Qt] Don't know how to swap buffers for the current rendering backend :(");
 	}
@@ -360,6 +364,15 @@ void MainWindow::dispatchMessage(const EmulatorMessage& message) {
 			emu->getRenderer()->setUbershader(*message.string.str);
 			delete message.string.str;
 			break;
+
+		case MessageType::SetScreenSize: {
+			const u32 width = message.screenSize.width;
+			const u32 height = message.screenSize.height;
+
+			emu->setOutputSize(width, height);
+			screen->resizeSurface(width, height);
+			break;
+		}
 	}
 }
 
@@ -423,13 +436,13 @@ void MainWindow::keyReleaseEvent(QKeyEvent* event) {
 void MainWindow::mousePressEvent(QMouseEvent* event) {
 	if (event->button() == Qt::MouseButton::LeftButton) {
 		const QPointF clickPos = event->globalPosition();
-		const QPointF widgetPos = screen.mapFromGlobal(clickPos);
+		const QPointF widgetPos = screen->mapFromGlobal(clickPos);
 
 		// Press is inside the screen area
-		if (widgetPos.x() >= 0 && widgetPos.x() < screen.width() && widgetPos.y() >= 0 && widgetPos.y() < screen.height()) {
+		if (widgetPos.x() >= 0 && widgetPos.x() < screen->width() && widgetPos.y() >= 0 && widgetPos.y() < screen->height()) {
 			// Go from widget positions to [0, 400) for x and [0, 480) for y
-			uint x = (uint)std::round(widgetPos.x() / screen.width() * 400.f);
-			uint y = (uint)std::round(widgetPos.y() / screen.height() * 480.f);
+			uint x = (uint)std::round(widgetPos.x() / screen->width() * 400.f);
+			uint y = (uint)std::round(widgetPos.y() / screen->height() * 480.f);
 
 			// Check if touch falls in the touch screen area
 			if (y >= 240 && y <= 480 && x >= 40 && x < 40 + 320) {
@@ -482,6 +495,14 @@ void MainWindow::editCheat(u32 handle, const std::vector<uint8_t>& cheat, const
 	sendMessage(message);
 }
 
+void MainWindow::handleScreenResize(u32 width, u32 height) {
+	EmulatorMessage message{.type = MessageType::SetScreenSize};
+	message.screenSize.width = width;
+	message.screenSize.height = height;
+
+	sendMessage(message);
+}
+
 void MainWindow::initControllers() {
 	// Make SDL use consistent positional button mapping
 	SDL_SetHint(SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS, "0");
diff --git a/src/panda_qt/screen.cpp b/src/panda_qt/screen.cpp
index 5a254e79..25ff576c 100644
--- a/src/panda_qt/screen.cpp
+++ b/src/panda_qt/screen.cpp
@@ -18,7 +18,7 @@
 // and https://github.com/melonDS-emu/melonDS/blob/master/src/frontend/qt_sdl/main.cpp
 
 #ifdef PANDA3DS_ENABLE_OPENGL
-ScreenWidget::ScreenWidget(QWidget* parent) : QWidget(parent) {
+ScreenWidget::ScreenWidget(ResizeCallback resizeCallback, QWidget* parent) : QWidget(parent), resizeCallback(resizeCallback) {
 	// Create a native window for use with our graphics API of choice
 	resize(800, 240 * 4);
 	
@@ -35,6 +35,30 @@ ScreenWidget::ScreenWidget(QWidget* parent) : QWidget(parent) {
 	}
 }
 
+void ScreenWidget::resizeEvent(QResizeEvent* event) {
+	previousWidth = surfaceWidth;
+	previousHeight = surfaceHeight;
+	QWidget::resizeEvent(event);
+
+	// Update surfaceWidth/surfaceHeight following the resize
+	std::optional<WindowInfo> windowInfo = getWindowInfo();
+	if (windowInfo) {
+		this->windowInfo = *windowInfo;
+	}
+
+	// This will call take care of calling resizeSurface from the emulator thread
+	resizeCallback(surfaceWidth, surfaceHeight);
+}
+
+// Note: This will run on the emulator thread, we don't want any Qt calls happening there.
+void ScreenWidget::resizeSurface(u32 width, u32 height) {
+	if (previousWidth != width || previousHeight != height) {
+		if (glContext) {
+			glContext->ResizeSurface(width, height);
+		}
+	}
+}
+
 bool ScreenWidget::createGLContext() {
 	// List of GL context versions we will try. Anything 4.1+ is good
 	static constexpr std::array<GL::Context::Version, 6> versionsToTry = {
@@ -45,6 +69,8 @@ bool ScreenWidget::createGLContext() {
 
 	std::optional<WindowInfo> windowInfo = getWindowInfo();
 	if (windowInfo.has_value()) {
+		this->windowInfo = *windowInfo;
+
 		glContext = GL::Context::Create(*getWindowInfo(), versionsToTry);
 		glContext->DoneCurrent();
 	}
@@ -110,4 +136,4 @@ std::optional<WindowInfo> ScreenWidget::getWindowInfo() {
 
 	return wi;
 }
-#endif
\ No newline at end of file
+#endif

From be75fa43a3b440510292831865339a4c582d1418 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 24 Jul 2024 02:00:45 +0300
Subject: [PATCH 03/38] More shader->GLSL recompiler work

---
 include/PICA/shader.hpp             |   5 +
 include/PICA/shader_decompiler.hpp  |  10 ++
 src/core/PICA/shader_decompiler.cpp | 167 +++++++++++++++++++++++++++-
 3 files changed, 176 insertions(+), 6 deletions(-)

diff --git a/include/PICA/shader.hpp b/include/PICA/shader.hpp
index 44ca2a15..68b16de8 100644
--- a/include/PICA/shader.hpp
+++ b/include/PICA/shader.hpp
@@ -58,6 +58,10 @@ namespace ShaderOpcodes {
 	};
 }
 
+namespace PICA::ShaderGen {
+	class ShaderDecompiler;
+};
+
 // Note: All PICA f24 vec4 registers must have the alignas(16) specifier to make them easier to access in SSE/NEON code in the JIT
 class PICAShader {
 	using f24 = Floats::f24;
@@ -135,6 +139,7 @@ class PICAShader {
 	// Add these as friend classes for the JIT so it has access to all important state
 	friend class ShaderJIT;
 	friend class ShaderEmitter;
+	friend class PICA::ShaderGen::ShaderDecompiler;
 
 	vec4f getSource(u32 source);
 	vec4f& getDest(u32 dest);
diff --git a/include/PICA/shader_decompiler.hpp b/include/PICA/shader_decompiler.hpp
index cbc569ae..1253226f 100644
--- a/include/PICA/shader_decompiler.hpp
+++ b/include/PICA/shader_decompiler.hpp
@@ -101,6 +101,16 @@ namespace PICA::ShaderGen {
 
 		void writeAttributes();
 
+		std::string getSource(u32 source, u32 index) const;
+		std::string getDest(u32 dest) const;
+		std::string getSwizzlePattern(u32 swizzle) const;
+		std::string getDestSwizzle(u32 destinationMask) const;
+
+		void setDest(u32 operandDescriptor, const std::string& dest, const std::string& value);
+		// Returns if the instruction uses the typical register encodings most instructions use
+		// With some exceptions like MAD/MADI, and the control flow instructions which are completely different
+		bool usesCommonEncoding(u32 instruction) const;
+
 	  public:
 		ShaderDecompiler(PICAShader& shader, EmulatorConfig& config, u32 entrypoint, API api, Language language)
 			: shader(shader), entrypoint(entrypoint), config(config), api(api), language(language), decompiledShader("") {}
diff --git a/src/core/PICA/shader_decompiler.cpp b/src/core/PICA/shader_decompiler.cpp
index 91b07574..bdbef8f3 100644
--- a/src/core/PICA/shader_decompiler.cpp
+++ b/src/core/PICA/shader_decompiler.cpp
@@ -4,6 +4,8 @@
 
 using namespace PICA;
 using namespace PICA::ShaderGen;
+using namespace Helpers;
+
 using Function = ControlFlow::Function;
 using ExitMode = Function::ExitMode;
 
@@ -70,11 +72,16 @@ const Function* ShaderDecompiler::findFunction(const AddressRange& range) {
 
 void ShaderDecompiler::writeAttributes() {
 	decompiledShader += R"(
+		layout(location = 0) in vec4 inputs[8];
+
 		layout(std140) uniform PICAShaderUniforms {
 			vec4 uniform_float[96];
 			uvec4 uniform_int;
 			uint uniform_bool;
 		};
+	
+		vec4 temp_registers[16];
+		vec4 dummy_vec = vec4(0.0);
 )";
 
 	decompiledShader += "\n";
@@ -130,24 +137,172 @@ std::string ShaderDecompiler::decompile() {
 	return decompiledShader;
 }
 
+std::string ShaderDecompiler::getSource(u32 source, [[maybe_unused]] u32 index) const {
+	if (source < 0x10) {
+		return "inputs[" + std::to_string(source) + "]";
+	} else if (source < 0x20) {
+		return "temp_registers[" + std::to_string(source - 0x10) + "]";
+	} else {
+		const usize floatIndex = (source - 0x20) & 0x7f;
+
+		if (floatIndex >= 96) [[unlikely]] {
+			return "dummy_vec";
+		}
+		return "uniform_float[" + std::to_string(floatIndex) + "]";
+	}
+}
+
+std::string ShaderDecompiler::getDest(u32 dest) const {
+	if (dest < 0x10) {
+		return "output_registers[" + std::to_string(dest) + "]";
+	} else if (dest < 0x20) {
+		return "temp_registers[" + std::to_string(dest - 0x10) + "]";
+	} else {
+		return "dummy_vec";
+	}
+}
+
+std::string ShaderDecompiler::getSwizzlePattern(u32 swizzle) const {
+	static constexpr std::array<char, 4> names = {'x', 'y', 'z', 'w'};
+	std::string ret(".    ");
+	
+	for (int i = 0; i < 4; i++) {
+		ret[3 - i + 1] = names[swizzle & 0x3];
+		swizzle >>= 2;
+	}
+
+	return ret;
+}
+
+std::string ShaderDecompiler::getDestSwizzle(u32 destinationMask) const {
+	std::string ret = ".";
+	
+	if (destinationMask & 0b1000) {
+		ret += "x";
+	}
+
+	if (destinationMask & 0b100) {
+		ret += "y";
+	}
+	
+	if (destinationMask & 0b10) {
+		ret += "z";
+	}
+	
+	if (destinationMask & 0b1) {
+		ret += "w";
+	}
+
+	return ret;
+}
+
+void ShaderDecompiler::setDest(u32 operandDescriptor, const std::string& dest, const std::string& value) {
+	u32 destinationMask = operandDescriptor & 0xF;
+
+	std::string destSwizzle = getDestSwizzle(destinationMask);
+	// We subtract 1 for the "." character of the swizzle descriptor
+	u32 writtenLaneCount = destSwizzle.size() - 1;
+
+	// All lanes are masked out, so the operation is a nop.
+	if (writtenLaneCount == 0) {
+		return;
+	}
+
+	decompiledShader += dest + destSwizzle + " = ";
+	if (writtenLaneCount == 1) {
+		decompiledShader += "float(" + value + ");\n";
+	} else {
+		decompiledShader += "vec" + std::to_string(writtenLaneCount) + "(" + value + ");\n";
+	}
+}
+
 void ShaderDecompiler::compileInstruction(u32& pc, bool& finished) {
 	const u32 instruction = shader.loadedShader[pc];
 	const u32 opcode = instruction >> 26;
 
-	switch (opcode) {
-		case ShaderOpcodes::DP4: decompiledShader += "dp4\n"; break;
-		case ShaderOpcodes::MOV: decompiledShader += "mov\n"; break;
-		case ShaderOpcodes::END: finished = true; return;
-		default: Helpers::warn("GLSL recompiler: Unknown opcode: %X", opcode); break;
+	if (usesCommonEncoding(instruction)) {
+		const u32 operandDescriptor = shader.operandDescriptors[instruction & 0x7f];
+		const bool invertSources = (opcode == ShaderOpcodes::SLTI || opcode == ShaderOpcodes::SGEI || opcode == ShaderOpcodes::DPHI);
+
+		// src1 and src2 indexes depend on whether this is one of the inverting instructions or not
+		const u32 src1Index = invertSources ? getBits<14, 5>(instruction) : getBits<12, 7>(instruction);
+		const u32 src2Index = invertSources ? getBits<7, 7>(instruction) : getBits<7, 5>(instruction);
+
+		const u32 idx = getBits<19, 2>(instruction);
+		const u32 destIndex = getBits<21, 5>(instruction);
+
+		const bool negate1 = (getBit<4>(operandDescriptor)) != 0;
+		const u32 swizzle1 = getBits<5, 8>(operandDescriptor);
+		const bool negate2 = (getBit<13>(operandDescriptor)) != 0;
+		const u32 swizzle2 = getBits<14, 8>(operandDescriptor);
+
+		std::string src1 = negate1 ? "-" : "";
+		src1 += getSource(src1Index, invertSources ? 0 : idx);
+		src1 += getSwizzlePattern(swizzle1);
+
+		std::string src2 = negate2 ? "-" : "";
+		src2 += getSource(src2Index, invertSources ? idx : 0);
+		src2 += getSwizzlePattern(swizzle2);
+
+		std::string dest = getDest(destIndex);
+
+		if (idx != 0) {
+			Helpers::panic("GLSL recompiler: Indexed instruction");
+		}
+
+		if (invertSources) {
+			Helpers::panic("GLSL recompiler: Inverted instruction");
+		}
+
+		switch (opcode) {
+			case ShaderOpcodes::DP4: setDest(operandDescriptor, dest, "vec4(dot(" + src1 + ", " + src2 + "))"); break;
+			case ShaderOpcodes::MOV: setDest(operandDescriptor, dest, src1); break;
+			default: Helpers::panic("GLSL recompiler: Unknown common opcode: %X", opcode); break;
+		}
+	} else {
+		switch (opcode) {
+			case ShaderOpcodes::END: finished = true; return;
+			default: Helpers::panic("GLSL recompiler: Unknown opcode: %X", opcode); break;
+		}
 	}
 
 	pc++;
 }
 
+
+bool ShaderDecompiler::usesCommonEncoding(u32 instruction) const {
+	const u32 opcode = instruction >> 26;
+	switch (opcode) {
+		case ShaderOpcodes::ADD:
+		case ShaderOpcodes::CMP1:
+		case ShaderOpcodes::CMP2:
+		case ShaderOpcodes::MUL:
+		case ShaderOpcodes::MIN:
+		case ShaderOpcodes::MAX:
+		case ShaderOpcodes::FLR:
+		case ShaderOpcodes::DP3:
+		case ShaderOpcodes::DP4:
+		case ShaderOpcodes::DPH:
+		case ShaderOpcodes::DPHI:
+		case ShaderOpcodes::LG2:
+		case ShaderOpcodes::EX2:
+		case ShaderOpcodes::RCP:
+		case ShaderOpcodes::RSQ:
+		case ShaderOpcodes::MOV:
+		case ShaderOpcodes::MOVA:
+		case ShaderOpcodes::SLT:
+		case ShaderOpcodes::SLTI:
+		case ShaderOpcodes::SGE:
+		case ShaderOpcodes::SGEI: return true;
+
+		default: return false;
+	}
+}
+
 void ShaderDecompiler::callFunction(const Function& function) { decompiledShader += function.getCallStatement() + ";\n"; }
 
 std::string ShaderGen::decompileShader(PICAShader& shader, EmulatorConfig& config, u32 entrypoint, API api, Language language) {
 	ShaderDecompiler decompiler(shader, config, entrypoint, api, language);
 
 	return decompiler.decompile();
-}
\ No newline at end of file
+}

From 156c3031a24d264f7d6d7653c986d5d80f452bf0 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 24 Jul 2024 16:47:46 +0300
Subject: [PATCH 04/38] More instructions in shader decompiler

---
 src/core/PICA/shader_decompiler.cpp | 48 ++++++++++++++++++++++++++++-
 1 file changed, 47 insertions(+), 1 deletion(-)

diff --git a/src/core/PICA/shader_decompiler.cpp b/src/core/PICA/shader_decompiler.cpp
index bdbef8f3..482aa36c 100644
--- a/src/core/PICA/shader_decompiler.cpp
+++ b/src/core/PICA/shader_decompiler.cpp
@@ -255,10 +255,56 @@ void ShaderDecompiler::compileInstruction(u32& pc, bool& finished) {
 		}
 
 		switch (opcode) {
-			case ShaderOpcodes::DP4: setDest(operandDescriptor, dest, "vec4(dot(" + src1 + ", " + src2 + "))"); break;
 			case ShaderOpcodes::MOV: setDest(operandDescriptor, dest, src1); break;
+			case ShaderOpcodes::ADD: setDest(operandDescriptor, dest, src1 + " + " + src2); break;
+			case ShaderOpcodes::MUL: setDest(operandDescriptor, dest, src1 + " * " + src2); break;
+			case ShaderOpcodes::MAX: setDest(operandDescriptor, dest, "max(" + src1 + ", " + src2 + ")"); break;
+			case ShaderOpcodes::MIN: setDest(operandDescriptor, dest, "min(" + src1 + ", " + src2 + ")"); break;
+
+			case ShaderOpcodes::DP3: setDest(operandDescriptor, dest, "vec4(dot(" + src1 + ".xyz, " + src2 + ".xyz))"); break;
+			case ShaderOpcodes::DP4: setDest(operandDescriptor, dest, "vec4(dot(" + src1 + ", " + src2 + "))"); break;
+			case ShaderOpcodes::RSQ: setDest(operandDescriptor, dest, "vec4(inversesqrt(" + src1 + ".x))"); break;
+
 			default: Helpers::panic("GLSL recompiler: Unknown common opcode: %X", opcode); break;
 		}
+	} else if (opcode >= 0x30 && opcode <= 0x3F) { // MAD and MADI
+		const u32 operandDescriptor = shader.operandDescriptors[instruction & 0x1f];
+		const bool isMADI = getBit<29>(instruction) == 0; // We detect MADI based on bit 29 of the instruction
+
+		// src1 and src2 indexes depend on whether this is one of the inverting instructions or not
+		const u32 src1Index = getBits<17, 5>(instruction);
+		const u32 src2Index = isMADI ? getBits<12, 5>(instruction) : getBits<10, 7>(instruction);
+		const u32 src3Index = isMADI ? getBits<5, 7>(instruction) : getBits<5, 5>(instruction);
+		const u32 idx = getBits<22, 2>(instruction);
+		const u32 destIndex = getBits<24, 5>(instruction);
+
+		const bool negate1 = (getBit<4>(operandDescriptor)) != 0;
+		const u32 swizzle1 = getBits<5, 8>(operandDescriptor);
+		const bool negate2 = (getBit<13>(operandDescriptor)) != 0;
+		const u32 swizzle2 = getBits<14, 8>(operandDescriptor);
+
+		const bool negate3 = (getBit<22>(operandDescriptor)) != 0;
+		const u32 swizzle3 = getBits<23, 8>(operandDescriptor);
+
+		std::string src1 = negate1 ? "-" : "";
+		src1 += getSource(src1Index, 0);
+		src1 += getSwizzlePattern(swizzle1);
+
+		std::string src2 = negate2 ? "-" : "";
+		src2 += getSource(src2Index, isMADI ? 0 : idx);
+		src2 += getSwizzlePattern(swizzle2);
+
+		std::string src3 = negate3 ? "-" : "";
+		src3 += getSource(src3Index, isMADI ? idx : 0);
+		src3 += getSwizzlePattern(swizzle3);
+
+		std::string dest = getDest(destIndex);
+
+		if (idx != 0) {
+			Helpers::panic("GLSL recompiler: Indexed instruction");
+		}
+
+		setDest(operandDescriptor, dest, src1 + " * " + src2 + " + " + src3);
 	} else {
 		switch (opcode) {
 			case ShaderOpcodes::END: finished = true; return;

From df5d14e3d8e0b5f618a0c65eefbee7533ad0baf4 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Thu, 25 Jul 2024 03:59:01 +0300
Subject: [PATCH 05/38] Shadergen: Remove unused vertex shader code

---
 src/core/PICA/shader_gen_glsl.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/core/PICA/shader_gen_glsl.cpp b/src/core/PICA/shader_gen_glsl.cpp
index 9802be90..1db239f9 100644
--- a/src/core/PICA/shader_gen_glsl.cpp
+++ b/src/core/PICA/shader_gen_glsl.cpp
@@ -72,11 +72,6 @@ std::string FragmentGenerator::getDefaultVertexShader() {
 		out float gl_ClipDistance[2];
 	#endif
 
-		vec4 abgr8888ToVec4(uint abgr) {
-			const float scale = 1.0 / 255.0;
-			return scale * vec4(float(abgr & 0xffu), float((abgr >> 8) & 0xffu), float((abgr >> 16) & 0xffu), float(abgr >> 24));
-		}
-
 		void main() {
 			gl_Position = a_coords;
 			vec4 colourAbs = abs(a_vertexColour);
@@ -677,4 +672,4 @@ void FragmentGenerator::compileFog(std::string& shader, const PICA::FragmentConf
 	shader += "vec2 value = texelFetch(u_tex_luts, ivec2(int(clamped_index), 24), 0).rg;"; // fog LUT is past the light LUTs
 	shader += "float fog_factor = clamp(value.r + value.g * delta, 0.0, 1.0);";
 	shader += "combinerOutput.rgb = mix(fog_color, combinerOutput.rgb, fog_factor);";
-}
\ No newline at end of file
+}

From 19b69bbdc23a58a97faf88f0fff591b958dffef4 Mon Sep 17 00:00:00 2001
From: Jonian Guveli <jonian@hardpixel.eu>
Date: Thu, 25 Jul 2024 11:04:57 +0300
Subject: [PATCH 06/38] Qt: Stop emuThread on closeEvent

---
 include/panda_qt/main_window.hpp | 1 +
 src/panda_qt/main_window.cpp     | 9 +++++++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/include/panda_qt/main_window.hpp b/include/panda_qt/main_window.hpp
index c99fb4c2..ecdbc02e 100644
--- a/include/panda_qt/main_window.hpp
+++ b/include/panda_qt/main_window.hpp
@@ -139,6 +139,7 @@ class MainWindow : public QMainWindow {
 	MainWindow(QApplication* app, QWidget* parent = nullptr);
 	~MainWindow();
 
+	void closeEvent(QCloseEvent *event) override;
 	void keyPressEvent(QKeyEvent* event) override;
 	void keyReleaseEvent(QKeyEvent* event) override;
 	void mousePressEvent(QMouseEvent* event) override;
diff --git a/src/panda_qt/main_window.cpp b/src/panda_qt/main_window.cpp
index 1f9b8123..284e88ea 100644
--- a/src/panda_qt/main_window.cpp
+++ b/src/panda_qt/main_window.cpp
@@ -204,14 +204,19 @@ void MainWindow::selectLuaFile() {
 	}
 }
 
-// Cleanup when the main window closes
-MainWindow::~MainWindow() {
+// Stop emulator thread when the main window closes
+void MainWindow::closeEvent(QCloseEvent *event) {
 	appRunning = false;  // Set our running atomic to false in order to make the emulator thread stop, and join it
 
 	if (emuThread.joinable()) {
 		emuThread.join();
 	}
 
+	SDL_Quit();
+}
+
+// Cleanup when the main window closes
+MainWindow::~MainWindow() {
 	delete emu;
 	delete menuBar;
 	delete aboutWindow;

From da23ec1a0683e2317a247a2eb3e5577a1d10c0b5 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Thu, 25 Jul 2024 13:40:01 +0300
Subject: [PATCH 07/38] Don't deinit SDL from non-SDL thread

---
 src/panda_qt/main_window.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/panda_qt/main_window.cpp b/src/panda_qt/main_window.cpp
index 284e88ea..65769116 100644
--- a/src/panda_qt/main_window.cpp
+++ b/src/panda_qt/main_window.cpp
@@ -211,8 +211,6 @@ void MainWindow::closeEvent(QCloseEvent *event) {
 	if (emuThread.joinable()) {
 		emuThread.join();
 	}
-
-	SDL_Quit();
 }
 
 // Cleanup when the main window closes
@@ -602,4 +600,4 @@ void MainWindow::pollControllers() {
 			}
 		}
 	}
-}
\ No newline at end of file
+}

From a0e506affc563ee54fa3c5658e8ccf30389aa574 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Thu, 25 Jul 2024 19:51:29 +0300
Subject: [PATCH 08/38] Share fragment UBO between shadergen programs

---
 include/renderer_gl/renderer_gl.hpp  |  2 +-
 src/core/renderer_gl/renderer_gl.cpp | 15 +++++++--------
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/include/renderer_gl/renderer_gl.hpp b/include/renderer_gl/renderer_gl.hpp
index f5a964a3..42b8bba1 100644
--- a/include/renderer_gl/renderer_gl.hpp
+++ b/include/renderer_gl/renderer_gl.hpp
@@ -69,11 +69,11 @@ class RendererGL final : public Renderer {
 	// The "default" vertex shader to use when using specialized shaders but not PICA vertex shader -> GLSL recompilation
 	// We can compile this once and then link it with all other generated fragment shaders
 	OpenGL::Shader defaultShadergenVs;
+	GLuint shadergenFragmentUBO;
 
 	// Cached recompiled fragment shader
 	struct CachedProgram {
 		OpenGL::Program program;
-		uint uboBinding;
 	};
 	std::unordered_map<PICA::FragmentConfig, CachedProgram> shaderCache;
 
diff --git a/src/core/renderer_gl/renderer_gl.cpp b/src/core/renderer_gl/renderer_gl.cpp
index 8b614d2d..c513a186 100644
--- a/src/core/renderer_gl/renderer_gl.cpp
+++ b/src/core/renderer_gl/renderer_gl.cpp
@@ -77,6 +77,11 @@ void RendererGL::initGraphicsContextInternal() {
 	gl.useProgram(displayProgram);
 	glUniform1i(OpenGL::uniformLocation(displayProgram, "u_texture"), 0);  // Init sampler object
 
+	// Allocate memory for the shadergen fragment uniform UBO
+	glGenBuffers(1, &shadergenFragmentUBO);
+	gl.bindUBO(shadergenFragmentUBO);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(PICA::FragmentUniforms), nullptr, GL_DYNAMIC_DRAW);
+
 	vbo.createFixedSize(sizeof(Vertex) * vertexBufferSize, GL_STREAM_DRAW);
 	gl.bindVBO(vbo);
 	vao.create();
@@ -853,17 +858,12 @@ OpenGL::Program& RendererGL::getSpecializedShader() {
 		glUniform1i(OpenGL::uniformLocation(program, "u_tex2"), 2);
 		glUniform1i(OpenGL::uniformLocation(program, "u_tex_luts"), 3);
 
-		// Allocate memory for the program UBO
-		glGenBuffers(1, &programEntry.uboBinding);
-		gl.bindUBO(programEntry.uboBinding);
-		glBufferData(GL_UNIFORM_BUFFER, sizeof(PICA::FragmentUniforms), nullptr, GL_DYNAMIC_DRAW);
-
 		// Set up the binding for our UBO. Sadly we can't specify it in the shader like normal people,
 		// As it's an OpenGL 4.2 feature that MacOS doesn't support...
 		uint uboIndex = glGetUniformBlockIndex(program.handle(), "FragmentUniforms");
 		glUniformBlockBinding(program.handle(), uboIndex, uboBlockBinding);
 	}
-	glBindBufferBase(GL_UNIFORM_BUFFER, uboBlockBinding, programEntry.uboBinding);
+	glBindBufferBase(GL_UNIFORM_BUFFER, uboBlockBinding, shadergenFragmentUBO);
 
 	// Upload uniform data to our shader's UBO
 	PICA::FragmentUniforms uniforms;
@@ -945,7 +945,7 @@ OpenGL::Program& RendererGL::getSpecializedShader() {
 		}
 	}
 
-	gl.bindUBO(programEntry.uboBinding);
+	gl.bindUBO(shadergenFragmentUBO);
 	glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(PICA::FragmentUniforms), &uniforms);
 
 	return program;
@@ -980,7 +980,6 @@ void RendererGL::clearShaderCache() {
 	for (auto& shader : shaderCache) {
 		CachedProgram& cachedProgram = shader.second;
 		cachedProgram.program.free();
-		glDeleteBuffers(1, &cachedProgram.uboBinding);
 	}
 
 	shaderCache.clear();

From 33cb3d9c9fdb29b28b639abe5badd64cd76c4b2e Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Thu, 25 Jul 2024 20:05:23 +0300
Subject: [PATCH 09/38] SDL: Add window resizing

---
 src/panda_sdl/frontend_sdl.cpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/panda_sdl/frontend_sdl.cpp b/src/panda_sdl/frontend_sdl.cpp
index 0c78eea1..3c7ccc1d 100644
--- a/src/panda_sdl/frontend_sdl.cpp
+++ b/src/panda_sdl/frontend_sdl.cpp
@@ -35,7 +35,7 @@ FrontendSDL::FrontendSDL() : keyboardMappings(InputMappings::defaultKeyboardMapp
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, config.rendererType == RendererType::Software ? 3 : 4);
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, config.rendererType == RendererType::Software ? 3 : 1);
-		window = SDL_CreateWindow("Alber", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 480, SDL_WINDOW_OPENGL);
+		window = SDL_CreateWindow("Alber", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 480, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
 
 		if (window == nullptr) {
 			Helpers::panic("Window creation failed: %s", SDL_GetError());
@@ -55,7 +55,7 @@ FrontendSDL::FrontendSDL() : keyboardMappings(InputMappings::defaultKeyboardMapp
 
 #ifdef PANDA3DS_ENABLE_VULKAN
 	if (config.rendererType == RendererType::Vulkan) {
-		window = SDL_CreateWindow("Alber", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 480, SDL_WINDOW_VULKAN);
+		window = SDL_CreateWindow("Alber", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 480, SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE);
 
 		if (window == nullptr) {
 			Helpers::warn("Window creation failed: %s", SDL_GetError());
@@ -289,6 +289,15 @@ void FrontendSDL::run() {
 					}
 					break;
 				}
+
+				case SDL_WINDOWEVENT: {
+					auto type = event.window.event;
+					if (type == SDL_WINDOWEVENT_RESIZED) {
+						const u32 width = event.window.data1;
+						const u32 height = event.window.data2;
+						emu.setOutputSize(width, height);
+					}
+				}
 			}
 		}
 

From 32ddc287891cc96355d2506b4455b267bccac3e7 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Thu, 25 Jul 2024 20:18:30 +0300
Subject: [PATCH 10/38] Shadergen: Move fog colour to uniform

---
 include/PICA/pica_frag_config.hpp    | 6 ------
 include/PICA/pica_frag_uniforms.hpp  | 4 +++-
 src/core/PICA/shader_gen_glsl.cpp    | 7 ++-----
 src/core/renderer_gl/renderer_gl.cpp | 2 ++
 4 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/include/PICA/pica_frag_config.hpp b/include/PICA/pica_frag_config.hpp
index 337fd211..5d5f8420 100644
--- a/include/PICA/pica_frag_config.hpp
+++ b/include/PICA/pica_frag_config.hpp
@@ -35,9 +35,6 @@ namespace PICA {
 
 			BitField<0, 3, FogMode> mode;
 			BitField<3, 1, u32> flipDepth;
-			BitField<8, 8, u32> fogColorR;
-			BitField<16, 8, u32> fogColorG;
-			BitField<24, 8, u32> fogColorB;
 		};
 	};
 
@@ -238,9 +235,6 @@ namespace PICA {
 
 			if (fogConfig.mode == FogMode::Fog) {
 				fogConfig.flipDepth = Helpers::getBit<16>(regs[InternalRegs::TexEnvUpdateBuffer]);
-				fogConfig.fogColorR = Helpers::getBits<0, 8>(regs[InternalRegs::FogColor]);
-				fogConfig.fogColorG = Helpers::getBits<8, 8>(regs[InternalRegs::FogColor]);
-				fogConfig.fogColorB = Helpers::getBits<16, 8>(regs[InternalRegs::FogColor]);
 			}
 		}
 	};
diff --git a/include/PICA/pica_frag_uniforms.hpp b/include/PICA/pica_frag_uniforms.hpp
index 09722d61..781fdcd3 100644
--- a/include/PICA/pica_frag_uniforms.hpp
+++ b/include/PICA/pica_frag_uniforms.hpp
@@ -34,8 +34,10 @@ namespace PICA {
 		alignas(16) vec4 tevBufferColor;
 		alignas(16) vec4 clipCoords;
 
-		// Note: We upload this as a u32 and decode on GPU
+		// Note: We upload these as a u32 and decode on GPU.
+		// Particularly the fog colour since fog is really uncommon and it doesn't matter if we decode on GPU.
 		u32 globalAmbientLight;
+		u32 fogColor;
 		// NOTE: THIS MUST BE LAST so that if lighting is disabled we can potentially omit uploading it
 		LightUniform lightUniforms[8];
 	};
diff --git a/src/core/PICA/shader_gen_glsl.cpp b/src/core/PICA/shader_gen_glsl.cpp
index 1db239f9..41b33d88 100644
--- a/src/core/PICA/shader_gen_glsl.cpp
+++ b/src/core/PICA/shader_gen_glsl.cpp
@@ -27,6 +27,7 @@ static constexpr const char* uniformDefinition = R"(
 
 		// Note: We upload this as a u32 and decode on GPU
 		uint globalAmbientLight;
+		uint inFogColor;
 		LightSource lightSources[8];
 	};
 )";
@@ -656,10 +657,6 @@ void FragmentGenerator::compileFog(std::string& shader, const PICA::FragmentConf
 		return;
 	}
 
-	float r = config.fogConfig.fogColorR / 255.0f;
-	float g = config.fogConfig.fogColorG / 255.0f;
-	float b = config.fogConfig.fogColorB / 255.0f;
-
 	if (config.fogConfig.flipDepth) {
 		shader += "float fog_index = (1.0 - depth) * 128.0;\n";
 	} else {
@@ -668,7 +665,7 @@ void FragmentGenerator::compileFog(std::string& shader, const PICA::FragmentConf
 
 	shader += "float clamped_index = clamp(floor(fog_index), 0.0, 127.0);";
 	shader += "float delta = fog_index - clamped_index;";
-	shader += "vec3 fog_color = vec3(" + std::to_string(r) + ", " + std::to_string(g) + ", " + std::to_string(b) + ");";
+	shader += "vec3 fog_color = (1.0 / 255.0) * vec3(float(inFogColor & 0xffu), float((inFogColor >> 8u) & 0xffu), float((inFogColor >> 16u) & 0xffu));";
 	shader += "vec2 value = texelFetch(u_tex_luts, ivec2(int(clamped_index), 24), 0).rg;"; // fog LUT is past the light LUTs
 	shader += "float fog_factor = clamp(value.r + value.g * delta, 0.0, 1.0);";
 	shader += "combinerOutput.rgb = mix(fog_color, combinerOutput.rgb, fog_factor);";
diff --git a/src/core/renderer_gl/renderer_gl.cpp b/src/core/renderer_gl/renderer_gl.cpp
index c513a186..f8fc31e7 100644
--- a/src/core/renderer_gl/renderer_gl.cpp
+++ b/src/core/renderer_gl/renderer_gl.cpp
@@ -903,6 +903,8 @@ OpenGL::Program& RendererGL::getSpecializedShader() {
 		vec[3] = float((color >> 24) & 0xFF) / 255.0f;
 	}
 
+	uniforms.fogColor = regs[PICA::InternalRegs::FogColor];
+
 	// Append lighting uniforms
 	if (fsConfig.lighting.enable) {
 		uniforms.globalAmbientLight = regs[InternalRegs::LightGlobalAmbient];

From 1413cdaebfb3b9be814b5b5b05616677e53bdef3 Mon Sep 17 00:00:00 2001
From: Jonian Guveli <jonian@hardpixel.eu>
Date: Fri, 26 Jul 2024 09:41:48 +0300
Subject: [PATCH 11/38] SDL: Fix mouse coords

---
 src/panda_sdl/frontend_sdl.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/panda_sdl/frontend_sdl.cpp b/src/panda_sdl/frontend_sdl.cpp
index 3c7ccc1d..b503dc42 100644
--- a/src/panda_sdl/frontend_sdl.cpp
+++ b/src/panda_sdl/frontend_sdl.cpp
@@ -162,8 +162,13 @@ void FrontendSDL::run() {
 					if (emu.romType == ROMType::None) break;
 
 					if (event.button.button == SDL_BUTTON_LEFT) {
-						const s32 x = event.button.x;
-						const s32 y = event.button.y;
+						// Get current window dimensions
+						int windowWidth, windowHeight;
+						SDL_GetWindowSize(window, &windowWidth, &windowHeight);
+
+						// Go from window positions to [0, 400) for x and [0, 480) for y
+						const s32 x = (s32)std::round(event.button.x * 400.f / windowWidth);
+						const s32 y = (s32)std::round(event.button.y * 480.f / windowHeight);
 
 						// Check if touch falls in the touch screen area
 						if (y >= 240 && y <= 480 && x >= 40 && x < 40 + 320) {

From 11e7eb7fd6c93a3a57a022573926275a1bc1f3e7 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Fri, 26 Jul 2024 12:05:33 +0300
Subject: [PATCH 12/38] SDL: Fixup touchscreen code

---
 CMakeLists.txt                     |  2 +-
 include/panda_sdl/frontend_sdl.hpp |  2 ++
 src/panda_sdl/frontend_sdl.cpp     | 12 ++++++------
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a3fe41dd..448086ba 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -502,7 +502,7 @@ if(NOT BUILD_HYDRA_CORE AND NOT BUILD_LIBRETRO_CORE)
         )
     else()
         set(FRONTEND_SOURCE_FILES src/panda_sdl/main.cpp src/panda_sdl/frontend_sdl.cpp src/panda_sdl/mappings.cpp)
-        set(FRONTEND_HEADER_FILES "")
+        set(FRONTEND_HEADER_FILES "include/panda_sdl/frontend_sdl.hpp")
     endif()
 
     target_link_libraries(Alber PRIVATE AlberCore)
diff --git a/include/panda_sdl/frontend_sdl.hpp b/include/panda_sdl/frontend_sdl.hpp
index dd6ab6c0..07038962 100644
--- a/include/panda_sdl/frontend_sdl.hpp
+++ b/include/panda_sdl/frontend_sdl.hpp
@@ -23,6 +23,8 @@ class FrontendSDL {
 	SDL_GameController* gameController = nullptr;
 	InputMappings keyboardMappings;
 
+	u32 windowWidth = 400;
+	u32 windowHeight = 480;
 	int gameControllerID;
 	bool programRunning = true;
 	
diff --git a/src/panda_sdl/frontend_sdl.cpp b/src/panda_sdl/frontend_sdl.cpp
index b503dc42..b2dc27b7 100644
--- a/src/panda_sdl/frontend_sdl.cpp
+++ b/src/panda_sdl/frontend_sdl.cpp
@@ -162,9 +162,9 @@ void FrontendSDL::run() {
 					if (emu.romType == ROMType::None) break;
 
 					if (event.button.button == SDL_BUTTON_LEFT) {
-						// Get current window dimensions
-						int windowWidth, windowHeight;
-						SDL_GetWindowSize(window, &windowWidth, &windowHeight);
+						if (windowWidth == 0 || windowHeight == 0) [[unlikely]] {
+							break;
+						}
 
 						// Go from window positions to [0, 400) for x and [0, 480) for y
 						const s32 x = (s32)std::round(event.button.x * 400.f / windowWidth);
@@ -298,9 +298,9 @@ void FrontendSDL::run() {
 				case SDL_WINDOWEVENT: {
 					auto type = event.window.event;
 					if (type == SDL_WINDOWEVENT_RESIZED) {
-						const u32 width = event.window.data1;
-						const u32 height = event.window.data2;
-						emu.setOutputSize(width, height);
+						windowWidth = event.window.data1;
+						windowHeight = event.window.data2;
+						emu.setOutputSize(windowWidth, windowHeight);
 					}
 				}
 			}

From 13bff602571bc9c0876bf48b7b71b113de537bee Mon Sep 17 00:00:00 2001
From: Jonian Guveli <jonian@hardpixel.eu>
Date: Fri, 26 Jul 2024 12:25:45 +0300
Subject: [PATCH 13/38] SDL: Fix mouse coords in gyroscope emulation

---
 src/panda_sdl/frontend_sdl.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/panda_sdl/frontend_sdl.cpp b/src/panda_sdl/frontend_sdl.cpp
index b2dc27b7..77b1f55f 100644
--- a/src/panda_sdl/frontend_sdl.cpp
+++ b/src/panda_sdl/frontend_sdl.cpp
@@ -247,8 +247,13 @@ void FrontendSDL::run() {
 
 					// Handle "dragging" across the touchscreen
 					if (hid.isTouchScreenPressed()) {
-						const s32 x = event.motion.x;
-						const s32 y = event.motion.y;
+						if (windowWidth == 0 || windowHeight == 0) [[unlikely]] {
+							break;
+						}
+
+						// Go from window positions to [0, 400) for x and [0, 480) for y
+						const s32 x = (s32)std::round(event.motion.x * 400.f / windowWidth);
+						const s32 y = (s32)std::round(event.motion.y * 480.f / windowHeight);
 
 						// Check if touch falls in the touch screen area and register the new touch screen position
 						if (y >= 240 && y <= 480 && x >= 40 && x < 40 + 320) {

From f095e6af0bd96ebfd540dd438bfdccc409dd79c5 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Fri, 26 Jul 2024 14:44:11 +0300
Subject: [PATCH 14/38] Shadergen: Move comments outside of emitted source code

---
 src/core/PICA/shader_gen_glsl.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/PICA/shader_gen_glsl.cpp b/src/core/PICA/shader_gen_glsl.cpp
index 41b33d88..60887d56 100644
--- a/src/core/PICA/shader_gen_glsl.cpp
+++ b/src/core/PICA/shader_gen_glsl.cpp
@@ -4,6 +4,8 @@
 using namespace PICA;
 using namespace PICA::ShaderGen;
 
+// Note: We upload global ambient and fog colour as u32 and decode on the GPU
+// This shouldn't matter much for GPU performance, especially fog since it's relatively rare
 static constexpr const char* uniformDefinition = R"(
 	struct LightSource {
 		vec3 specular0;
@@ -24,8 +26,6 @@ static constexpr const char* uniformDefinition = R"(
 		vec4 constantColors[6];
 		vec4 tevBufferColor;
 		vec4 clipCoords;
-
-		// Note: We upload this as a u32 and decode on GPU
 		uint globalAmbientLight;
 		uint inFogColor;
 		LightSource lightSources[8];

From d0f13de4c5747c3082a81b9c6c01cd020886c8c1 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Fri, 26 Jul 2024 16:25:38 +0300
Subject: [PATCH 15/38] Fix swapping loaded ELF files

---
 src/emulator.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/emulator.cpp b/src/emulator.cpp
index db6c2e1f..921af08f 100644
--- a/src/emulator.cpp
+++ b/src/emulator.cpp
@@ -299,6 +299,11 @@ bool Emulator::load3DSX(const std::filesystem::path& path) {
 }
 
 bool Emulator::loadELF(const std::filesystem::path& path) {
+	// We can't open a new file with this ifstream if it's associated with a file
+	if (loadedELF.is_open()) {
+		loadedELF.close();
+	}
+
 	loadedELF.open(path, std::ios_base::binary);  // Open ROM in binary mode
 	romType = ROMType::ELF;
 

From e557bd29764f914053d3535fafb803a2974497dd Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Sun, 28 Jul 2024 19:03:05 +0300
Subject: [PATCH 16/38] Fix HLE__DSP::RecvData

---
 src/core/audio/hle_core.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index 12c8f4c8..1f77974f 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -110,7 +110,7 @@ namespace Audio {
 			Helpers::panic("Audio: invalid register in HLE frontend");
 		}
 
-		return dspState == DSPState::On;
+		return dspState != DSPState::On;
 	}
 
 	void HLE_DSP::writeProcessPipe(u32 channel, u32 size, u32 buffer) {

From 908222f26fbbcdda2ecfc79cdf4c2eee7a823b37 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Sun, 28 Jul 2024 19:05:50 +0300
Subject: [PATCH 17/38] HLE DSP: Don't printf on buffer queue dirty

---
 src/core/audio/hle_core.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index 1f77974f..d39bdbbf 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -317,7 +317,7 @@ namespace Audio {
 
 		if (config.bufferQueueDirty) {
 			config.bufferQueueDirty = 0;
-			printf("Buffer queue dirty for voice %d\n", source.index);
+			// printf("Buffer queue dirty for voice %d\n", source.index);
 		}
 
 		config.dirtyRaw = 0;

From c7db6fe5dc39b6188e1eb7fbb61f0a0834d410c8 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Mon, 29 Jul 2024 19:54:46 +0300
Subject: [PATCH 18/38] FIx DSP region calculation

---
 include/audio/hle_core.hpp  | 2 +-
 src/core/audio/hle_core.cpp | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/include/audio/hle_core.hpp b/include/audio/hle_core.hpp
index b59dc811..117d9ecb 100644
--- a/include/audio/hle_core.hpp
+++ b/include/audio/hle_core.hpp
@@ -142,7 +142,7 @@ namespace Audio {
 			} else if (counter1 == 0xffff && counter0 != 0xfffe) {
 				return 0;
 			} else {
-				return counter0 > counter1 ? 0 : 0;
+				return counter0 > counter1 ? 0 : 1;
 			}
 		}
 
diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index d39bdbbf..23a99786 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -216,6 +216,11 @@ namespace Audio {
 		SharedMemory& read = readRegion();
 		SharedMemory& write = writeRegion();
 
+		// TODO: Properly implement mixers
+		// The DSP checks the DSP configuration dirty bits on every frame, applies them, and clears them
+		read.dspConfiguration.dirtyRaw = 0;
+		// read.dspConfiguration.dirtyRaw2 = 0;
+
 		for (int i = 0; i < sourceCount; i++) {
 			// Update source configuration from the read region of shared memory
 			auto& config = read.sourceConfigurations.config[i];
@@ -401,6 +406,7 @@ namespace Audio {
 				// samples.insert(samples.end(), source.currentSamples.begin(), source.currentSamples.begin() + sampleCount);
 				source.currentSamples.erase(source.currentSamples.begin(), source.currentSamples.begin() + sampleCount);
 
+				source.samplePosition += sampleCount;
 				outputCount += sampleCount;
 			}
 		}

From 45dd69d62ae144fdac5048cdc118c0d2749c484f Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Mon, 29 Jul 2024 21:58:00 +0300
Subject: [PATCH 19/38] HLE DSP: Pop unused samples when loading new buffer

---
 src/core/audio/hle_core.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index 23a99786..112db9d5 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <thread>
 #include <utility>
 
@@ -370,6 +371,13 @@ namespace Audio {
 				break;
 		}
 
+		// We're skipping the first samplePosition samples, so remove them from the buffer so as not to consume them later
+		if (source.samplePosition > 0) {
+			auto start = source.currentSamples.begin();
+			auto end = std::next(start, source.samplePosition);
+			source.currentSamples.erase(start, end);
+		}
+
 		// If the buffer is a looping buffer, re-push it
 		if (buffer.looping) {
 			source.pushBuffer(buffer);

From 57ecc18f325f09d629b5cf491b3f7844f927b4da Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Mon, 29 Jul 2024 23:03:17 +0300
Subject: [PATCH 20/38] HLE DSP: Implement buffer queue dirty bit

---
 src/core/audio/hle_core.cpp | 46 +++++++++++++++++++++++++++++++------
 1 file changed, 39 insertions(+), 7 deletions(-)

diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index 112db9d5..c01a8ccd 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -220,7 +220,7 @@ namespace Audio {
 		// TODO: Properly implement mixers
 		// The DSP checks the DSP configuration dirty bits on every frame, applies them, and clears them
 		read.dspConfiguration.dirtyRaw = 0;
-		// read.dspConfiguration.dirtyRaw2 = 0;
+		read.dspConfiguration.dirtyRaw2 = 0;
 
 		for (int i = 0; i < sourceCount; i++) {
 			// Update source configuration from the read region of shared memory
@@ -322,8 +322,40 @@ namespace Audio {
 		}
 
 		if (config.bufferQueueDirty) {
-			config.bufferQueueDirty = 0;
 			// printf("Buffer queue dirty for voice %d\n", source.index);
+
+			u16 dirtyBuffers = config.buffersDirty;
+			config.bufferQueueDirty = 0;
+			config.buffersDirty = 0;
+
+			for (int i = 0; i < 4; i++) {
+				bool dirty = ((dirtyBuffers >> i) & 1) != 0;
+				if (dirty) {
+					const auto& buffer = config.buffers[i];
+
+					if (s32(buffer.length) >= 0) [[likely]] {
+						// TODO: Add sample format and channel count
+						Source::Buffer newBuffer{
+							.paddr = buffer.physicalAddress,
+							.sampleCount = buffer.length,
+							.adpcmScale = u8(buffer.adpcmScale),
+							.previousSamples = {s16(buffer.adpcm_yn[0]), s16(buffer.adpcm_yn[1])},
+							.adpcmDirty = buffer.adpcmDirty != 0,
+							.looping = buffer.isLooping != 0,
+							.bufferID = buffer.bufferID,
+							.playPosition = 0,
+							.format = source.sampleFormat,
+							.sourceType = source.sourceType,
+							.fromQueue = true,
+							.hasPlayedOnce = false,
+						};
+
+						source.buffers.emplace(std::move(newBuffer));
+					} else {
+						printf("Buffer queue dirty: Invalid buffer size for DSP voice %d\n", source.index);
+					}
+				}
+			}
 		}
 
 		config.dirtyRaw = 0;
@@ -371,17 +403,17 @@ namespace Audio {
 				break;
 		}
 
+		// If the buffer is a looping buffer, re-push it
+		if (buffer.looping) {
+			source.pushBuffer(buffer);
+		}
+
 		// We're skipping the first samplePosition samples, so remove them from the buffer so as not to consume them later
 		if (source.samplePosition > 0) {
 			auto start = source.currentSamples.begin();
 			auto end = std::next(start, source.samplePosition);
 			source.currentSamples.erase(start, end);
 		}
-
-		// If the buffer is a looping buffer, re-push it
-		if (buffer.looping) {
-			source.pushBuffer(buffer);
-		}
 	}
 
 	void HLE_DSP::generateFrame(DSPSource& source) {

From 6668ba3e37fe4b2dce6840c818d0ae78524f2242 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Mon, 29 Jul 2024 23:46:36 +0300
Subject: [PATCH 21/38] HLE DSP: Fix embedded buffer starting sample position

---
 src/core/audio/hle_core.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index c01a8ccd..f150482b 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -292,6 +292,9 @@ namespace Audio {
 		}
 
 		if (config.embeddedBufferDirty) {
+			// Annoyingly, and only for embedded buffer, whether we use config.playPosition depends on the relevant dirty bit
+			const u32 playPosition = config.playPositionDirty ? config.playPosition : 0;
+
 			config.embeddedBufferDirty = 0;
 			if (s32(config.length) >= 0) [[likely]] {
 				// TODO: Add sample format and channel count
@@ -303,7 +306,7 @@ namespace Audio {
 					.adpcmDirty = config.adpcmDirty != 0,
 					.looping = config.isLooping != 0,
 					.bufferID = config.bufferID,
-					.playPosition = config.playPosition,
+					.playPosition = playPosition,
 					.format = source.sampleFormat,
 					.sourceType = source.sourceType,
 					.fromQueue = false,

From e26f58595eb4667a07ef14fbeb41bc3a73590f58 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Tue, 30 Jul 2024 00:36:16 +0300
Subject: [PATCH 22/38] HLE DSP: Reset flags should take priority

---
 src/core/audio/hle_core.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index f150482b..84d62401 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -253,6 +253,17 @@ namespace Audio {
 			return;
 		}
 
+		// The reset flags take priority, as you can reset a source and set it up to be played again at the same time
+		if (config.resetFlag) {
+			config.resetFlag = 0;
+			source.reset();
+		}
+
+		if (config.partialResetFlag) {
+			config.partialResetFlag = 0;
+			source.buffers = {};
+		}
+
 		if (config.enableDirty) {
 			config.enableDirty = 0;
 			source.enabled = config.enable != 0;
@@ -272,16 +283,6 @@ namespace Audio {
 			);
 		}
 
-		if (config.resetFlag) {
-			config.resetFlag = 0;
-			source.reset();
-		}
-
-		if (config.partialResetFlag) {
-			config.partialResetFlag = 0;
-			source.buffers = {};
-		}
-
 		// TODO: Should we check bufferQueueDirty here too?
 		if (config.formatDirty || config.embeddedBufferDirty) {
 			source.sampleFormat = config.format;

From f572373fc13468354c4d418faa759fdf711858dd Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Tue, 30 Jul 2024 14:29:18 +0300
Subject: [PATCH 23/38] AES: Implement seed crypto

---
 include/crypto/aes_engine.hpp  | 79 +++++++++++++++++-------------
 src/core/crypto/aes_engine.cpp | 89 +++++++++++++++++++++++++++-------
 src/core/loader/ncch.cpp       | 34 ++++++++++---
 src/emulator.cpp               |  6 +++
 4 files changed, 151 insertions(+), 57 deletions(-)

diff --git a/include/crypto/aes_engine.hpp b/include/crypto/aes_engine.hpp
index 324f4adf..f8a2d7e4 100644
--- a/include/crypto/aes_engine.hpp
+++ b/include/crypto/aes_engine.hpp
@@ -1,20 +1,29 @@
 #pragma once
 
 #include <array>
-#include <cstring>
-#include <cstdint>
 #include <climits>
+#include <cstdint>
+#include <cstring>
 #include <filesystem>
 #include <optional>
+#include <vector>
 
 #include "helpers.hpp"
+#include "io_file.hpp"
+#include "swap.hpp"
 
 namespace Crypto {
-	constexpr std::size_t AesKeySize = 0x10;
+	constexpr usize AesKeySize = 0x10;
 	using AESKey = std::array<u8, AesKeySize>;
 
-	template <std::size_t N>
-	static std::array<u8, N> rolArray(const std::array<u8, N>& value, std::size_t bits) {
+	struct Seed {
+		u64_le titleID;
+		AESKey seed;
+		std::array<u8, 8> pad;
+	};
+
+	template <usize N>
+	static std::array<u8, N> rolArray(const std::array<u8, N>& value, usize bits) {
 		const auto bitWidth = N * CHAR_BIT;
 
 		bits %= bitWidth;
@@ -24,18 +33,18 @@ namespace Crypto {
 
 		std::array<u8, N> result;
 
-		for (std::size_t i = 0; i < N; i++) {
+		for (usize i = 0; i < N; i++) {
 			result[i] = ((value[(i + byteShift) % N] << bitShift) | (value[(i + byteShift + 1) % N] >> (CHAR_BIT - bitShift))) & UINT8_MAX;
 		}
 
 		return result;
 	}
 
-	template <std::size_t N>
+	template <usize N>
 	static std::array<u8, N> addArray(const std::array<u8, N>& a, const std::array<u8, N>& b) {
 		std::array<u8, N> result;
-		std::size_t sum = 0;
-		std::size_t carry = 0;
+		usize sum = 0;
+		usize carry = 0;
 
 		for (std::int64_t i = N - 1; i >= 0; i--) {
 			sum = a[i] + b[i] + carry;
@@ -46,11 +55,11 @@ namespace Crypto {
 		return result;
 	}
 
-	template <std::size_t N>
+	template <usize N>
 	static std::array<u8, N> xorArray(const std::array<u8, N>& a, const std::array<u8, N>& b) {
 		std::array<u8, N> result;
 
-		for (std::size_t i = 0; i < N; i++) {
+		for (usize i = 0; i < N; i++) {
 			result[i] = a[i] ^ b[i];
 		}
 
@@ -63,7 +72,7 @@ namespace Crypto {
 		}
 
 		AESKey rawKey;
-		for (std::size_t i = 0; i < rawKey.size(); i++) {
+		for (usize i = 0; i < rawKey.size(); i++) {
 			rawKey[i] = static_cast<u8>(std::stoi(hex.substr(i * 2, 2), 0, 16));
 		}
 
@@ -76,7 +85,7 @@ namespace Crypto {
 		std::optional<AESKey> normalKey = std::nullopt;
 	};
 
-	enum KeySlotId : std::size_t {
+	enum KeySlotId : usize {
 		NCCHKey0 = 0x2C,
 		NCCHKey1 = 0x25,
 		NCCHKey2 = 0x18,
@@ -84,14 +93,18 @@ namespace Crypto {
 	};
 
 	class AESEngine {
-	private:
-		constexpr static std::size_t AesKeySlotCount = 0x40;
+	  private:
+		constexpr static usize AesKeySlotCount = 0x40;
 
 		std::optional<AESKey> m_generator = std::nullopt;
 		std::array<AESKeySlot, AesKeySlotCount> m_slots;
 		bool keysLoaded = false;
 
-		constexpr void updateNormalKey(std::size_t slotId) {
+		std::vector<Seed> seeds;
+		IOFile seedDatabase;
+		bool seedsLoaded = false;
+
+		constexpr void updateNormalKey(usize slotId) {
 			if (m_generator.has_value() && hasKeyX(slotId) && hasKeyY(slotId)) {
 				auto& keySlot = m_slots.at(slotId);
 				AESKey keyX = keySlot.keyX.value();
@@ -101,13 +114,17 @@ namespace Crypto {
 			}
 		}
 
-	public:
+	  public:
 		AESEngine() {}
 		void loadKeys(const std::filesystem::path& path);
+		void setSeedPath(const std::filesystem::path& path);
+		// Returns true on success, false on failure
+		bool loadSeeds();
+
 		bool haveKeys() { return keysLoaded; }
 		bool haveGenerator() { return m_generator.has_value(); }
 
-		constexpr bool hasKeyX(std::size_t slotId) {
+		constexpr bool hasKeyX(usize slotId) {
 			if (slotId >= AesKeySlotCount) {
 				return false;
 			}
@@ -115,18 +132,16 @@ namespace Crypto {
 			return m_slots.at(slotId).keyX.has_value();
 		}
 
-		constexpr AESKey getKeyX(std::size_t slotId) {
-			return m_slots.at(slotId).keyX.value_or(AESKey{});
-		}
+		constexpr AESKey getKeyX(usize slotId) { return m_slots.at(slotId).keyX.value_or(AESKey{}); }
 
-		constexpr void setKeyX(std::size_t slotId, const AESKey &key) {
+		constexpr void setKeyX(usize slotId, const AESKey& key) {
 			if (slotId < AesKeySlotCount) {
 				m_slots.at(slotId).keyX = key;
 				updateNormalKey(slotId);
 			}
 		}
 
-		constexpr bool hasKeyY(std::size_t slotId) {
+		constexpr bool hasKeyY(usize slotId) {
 			if (slotId >= AesKeySlotCount) {
 				return false;
 			}
@@ -134,18 +149,16 @@ namespace Crypto {
 			return m_slots.at(slotId).keyY.has_value();
 		}
 
-		constexpr AESKey getKeyY(std::size_t slotId) {
-			return m_slots.at(slotId).keyY.value_or(AESKey{});
-		}
+		constexpr AESKey getKeyY(usize slotId) { return m_slots.at(slotId).keyY.value_or(AESKey{}); }
 
-		constexpr void setKeyY(std::size_t slotId, const AESKey &key) {
+		constexpr void setKeyY(usize slotId, const AESKey& key) {
 			if (slotId < AesKeySlotCount) {
 				m_slots.at(slotId).keyY = key;
 				updateNormalKey(slotId);
 			}
 		}
 
-		constexpr bool hasNormalKey(std::size_t slotId) {
+		constexpr bool hasNormalKey(usize slotId) {
 			if (slotId >= AesKeySlotCount) {
 				return false;
 			}
@@ -153,14 +166,14 @@ namespace Crypto {
 			return m_slots.at(slotId).normalKey.has_value();
 		}
 
-		constexpr AESKey getNormalKey(std::size_t slotId) {
-			return m_slots.at(slotId).normalKey.value_or(AESKey{});
-		}
+		constexpr AESKey getNormalKey(usize slotId) { return m_slots.at(slotId).normalKey.value_or(AESKey{}); }
 
-		constexpr void setNormalKey(std::size_t slotId, const AESKey &key) {
+		constexpr void setNormalKey(usize slotId, const AESKey& key) {
 			if (slotId < AesKeySlotCount) {
 				m_slots.at(slotId).normalKey = key;
 			}
 		}
+
+		std::optional<AESKey> getSeedFromDB(u64 titleID);
 	};
-}
\ No newline at end of file
+}  // namespace Crypto
\ No newline at end of file
diff --git a/src/core/crypto/aes_engine.cpp b/src/core/crypto/aes_engine.cpp
index f4bf3494..dc3ae060 100644
--- a/src/core/crypto/aes_engine.cpp
+++ b/src/core/crypto/aes_engine.cpp
@@ -1,13 +1,15 @@
-#include <iostream>
-#include <fstream>
-
 #include "crypto/aes_engine.hpp"
+
+#include <fstream>
+#include <iostream>
+#include <tuple>
+
 #include "helpers.hpp"
 
 namespace Crypto {
 	void AESEngine::loadKeys(const std::filesystem::path& path) {
 		std::ifstream file(path, std::ios::in);
-	
+
 		if (file.fail()) {
 			Helpers::warn("Keys: Couldn't read key file: %s", path.c_str());
 			return;
@@ -58,18 +60,10 @@ namespace Crypto {
 			}
 
 			switch (keyType) {
-				case 'X':
-					setKeyX(slotId, key.value());
-					break;
-				case 'Y':
-					setKeyY(slotId, key.value());
-					break;
-				case 'N':
-					setNormalKey(slotId, key.value());
-					break;
-				default:
-					Helpers::warn("Keys: Invalid key type %c", keyType);
-					break;
+				case 'X': setKeyX(slotId, key.value()); break;
+				case 'Y': setKeyY(slotId, key.value()); break;
+				case 'N': setNormalKey(slotId, key.value()); break;
+				default: Helpers::warn("Keys: Invalid key type %c", keyType); break;
 			}
 		}
 
@@ -80,4 +74,65 @@ namespace Crypto {
 
 		keysLoaded = true;
 	}
-};
\ No newline at end of file
+
+	void AESEngine::setSeedPath(const std::filesystem::path& path) { seedDatabase.open(path, "rb"); }
+
+	// Loads seeds from a seed file, return true on success and false on failure
+	bool AESEngine::loadSeeds() {
+		if (!seedDatabase.isOpen()) {
+			return false;
+		}
+
+		// The # of seeds is stored at offset 0
+		u32_le seedCount = 0;
+
+		if (!seedDatabase.rewind()) {
+			return false;
+		}
+
+		auto [success, size] = seedDatabase.readBytes(&seedCount, sizeof(u32));
+		if (!success || size != sizeof(u32)) {
+			return false;
+		}
+
+		// Key data starts from offset 16
+		if (!seedDatabase.seek(16)) {
+			return false;
+		}
+
+		Crypto::Seed seed;
+		for (uint i = 0; i < seedCount; i++) {
+			std::tie(success, size) = seedDatabase.readBytes(&seed, sizeof(seed));
+			if (!success || size != sizeof(seed)) {
+				return false;
+			}
+
+			seeds.push_back(seed);
+		}
+
+		return true;
+	}
+
+	std::optional<Crypto::AESKey> AESEngine::getSeedFromDB(u64 titleID) {
+		// We don't have a seed db nor any seeds loaded, return nullopt
+		if (!seedDatabase.isOpen() && seeds.empty()) {
+			return std::nullopt;
+		}
+
+		// We have a seed DB but haven't loaded the seeds yet, so load them
+		if (seedDatabase.isOpen() && seeds.empty()) {
+			bool success = loadSeeds();
+			if (!success) {
+				return std::nullopt;
+			}
+		}
+
+		for (Crypto::Seed& seed : seeds) {
+			if (seed.titleID == titleID) {
+				return seed.seed;
+			}
+		}
+
+		return std::nullopt;
+	}
+};  // namespace Crypto
\ No newline at end of file
diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp
index a575d4f2..3a7cb1f6 100644
--- a/src/core/loader/ncch.cpp
+++ b/src/core/loader/ncch.cpp
@@ -1,12 +1,15 @@
+#include "loader/ncch.hpp"
+
 #include <cryptopp/aes.h>
 #include <cryptopp/modes.h>
-#include <cstring>
-#include <vector>
-#include "loader/lz77.hpp"
-#include "loader/ncch.hpp"
-#include "memory.hpp"
+#include <cryptopp/sha.h>
 
+#include <cstring>
 #include <iostream>
+#include <vector>
+
+#include "loader/lz77.hpp"
+#include "memory.hpp"
 
 bool NCCH::loadFromHeader(Crypto::AESEngine &aesEngine, IOFile& file, const FSInfo &info) {
     // 0x200 bytes for the NCCH header
@@ -70,8 +73,25 @@ bool NCCH::loadFromHeader(Crypto::AESEngine &aesEngine, IOFile& file, const FSIn
 		if (!seedCrypto) {
 			secondaryKeyY = primaryKeyY;
 		} else {
-			Helpers::warn("Seed crypto is not supported");
-			gotCryptoKeys = false;
+			// In seed crypto mode, the secondary key is computed through a SHA256 hash of the primary key and a title-specific seed, which we fetch
+			// from seeddb.bin
+			std::optional<Crypto::AESKey> seedOptional = aesEngine.getSeedFromDB(programID);
+			if (seedOptional.has_value()) {
+				auto seed = *seedOptional;
+				
+				CryptoPP::SHA256 shaEngine;
+				std::array<u8, 32> data;
+				std::array<u8, CryptoPP::SHA256::DIGESTSIZE> hash;
+
+				std::memcpy(&data[0], primaryKeyY.data(), primaryKeyY.size());
+				std::memcpy(&data[16], seed.data(), seed.size());
+				shaEngine.CalculateDigest(hash.data(), data.data(), data.size());
+				// Note that SHA256 will produce a 256-bit hash, while we only need 128 bits cause this is an AES key
+				// So the latter 16 bytes of the SHA256 are thrown out.
+				std::memcpy(secondaryKeyY.data(), hash.data(), secondaryKeyY.size());
+			} else {
+				Helpers::warn("Couldn't find a seed value for this title. Make sure you have a seeddb.bin file alongside your aes_keys.txt");
+			}
 		}
 
 		auto primaryResult = getPrimaryKey(aesEngine, primaryKeyY);
diff --git a/src/emulator.cpp b/src/emulator.cpp
index 921af08f..e4bfc4af 100644
--- a/src/emulator.cpp
+++ b/src/emulator.cpp
@@ -220,6 +220,8 @@ bool Emulator::loadROM(const std::filesystem::path& path) {
 	const std::filesystem::path appDataPath = getAppDataRoot();
 	const std::filesystem::path dataPath = appDataPath / path.filename().stem();
 	const std::filesystem::path aesKeysPath = appDataPath / "sysdata" / "aes_keys.txt";
+	const std::filesystem::path seedDBPath = appDataPath / "sysdata" / "seeddb.bin";
+
 	IOFile::setAppDataDir(dataPath);
 
 	// Open the text file containing our AES keys if it exists. We use the std::filesystem::exists overload that takes an error code param to
@@ -229,6 +231,10 @@ bool Emulator::loadROM(const std::filesystem::path& path) {
 		aesEngine.loadKeys(aesKeysPath);
 	}
 
+	if (std::filesystem::exists(seedDBPath, ec) && !ec) {
+		aesEngine.setSeedPath(seedDBPath);
+	}
+
 	kernel.initializeFS();
 	auto extension = path.extension();
 	bool success;  // Tracks if we loaded the ROM successfully

From e6c97edb1c41a5bca22aeaa8befe226ba1c511bb Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Tue, 30 Jul 2024 14:32:42 +0300
Subject: [PATCH 24/38] AES: Remove unused seedsLoaded variable

---
 include/crypto/aes_engine.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/include/crypto/aes_engine.hpp b/include/crypto/aes_engine.hpp
index f8a2d7e4..c96b36d3 100644
--- a/include/crypto/aes_engine.hpp
+++ b/include/crypto/aes_engine.hpp
@@ -102,7 +102,6 @@ namespace Crypto {
 
 		std::vector<Seed> seeds;
 		IOFile seedDatabase;
-		bool seedsLoaded = false;
 
 		constexpr void updateNormalKey(usize slotId) {
 			if (m_generator.has_value() && hasKeyX(slotId) && hasKeyY(slotId)) {
@@ -176,4 +175,4 @@ namespace Crypto {
 
 		std::optional<AESKey> getSeedFromDB(u64 titleID);
 	};
-}  // namespace Crypto
\ No newline at end of file
+}  // namespace Crypto

From bec63c43a169204f2f022d535c8d36bdfb7c5565 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Tue, 30 Jul 2024 14:36:39 +0300
Subject: [PATCH 25/38] AES: Properly handle missing seeds

---
 src/core/loader/ncch.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp
index 3a7cb1f6..96d13813 100644
--- a/src/core/loader/ncch.cpp
+++ b/src/core/loader/ncch.cpp
@@ -91,6 +91,7 @@ bool NCCH::loadFromHeader(Crypto::AESEngine &aesEngine, IOFile& file, const FSIn
 				std::memcpy(secondaryKeyY.data(), hash.data(), secondaryKeyY.size());
 			} else {
 				Helpers::warn("Couldn't find a seed value for this title. Make sure you have a seeddb.bin file alongside your aes_keys.txt");
+				gotCryptoKeys = false;
 			}
 		}
 

From e666afd1a30d80f69df1ea015ed835ac86af1eef Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 31 Jul 2024 02:51:40 +0300
Subject: [PATCH 26/38] DSP HLE: Fix buffer queue metadata

---
 include/audio/hle_core.hpp  | 2 +-
 src/core/audio/hle_core.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/audio/hle_core.hpp b/include/audio/hle_core.hpp
index 117d9ecb..35c1c1b8 100644
--- a/include/audio/hle_core.hpp
+++ b/include/audio/hle_core.hpp
@@ -142,7 +142,7 @@ namespace Audio {
 			} else if (counter1 == 0xffff && counter0 != 0xfffe) {
 				return 0;
 			} else {
-				return counter0 > counter1 ? 0 : 1;
+				return (counter0 > counter1) ? 0 : 1;
 			}
 		}
 
diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index 84d62401..ffab9301 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -342,7 +342,7 @@ namespace Audio {
 						Source::Buffer newBuffer{
 							.paddr = buffer.physicalAddress,
 							.sampleCount = buffer.length,
-							.adpcmScale = u8(buffer.adpcmScale),
+							.adpcmScale = u8(buffer.adpcm_ps),
 							.previousSamples = {s16(buffer.adpcm_yn[0]), s16(buffer.adpcm_yn[1])},
 							.adpcmDirty = buffer.adpcmDirty != 0,
 							.looping = buffer.isLooping != 0,

From d1922798c5978cafb992f074f823a051ed0dc419 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 31 Jul 2024 18:22:14 +0300
Subject: [PATCH 27/38] CMake: Disable /GS when using MSVC for user builds

---
 CMakeLists.txt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 448086ba..b55e2390 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -55,6 +55,11 @@ if(BUILD_LIBRETRO_CORE)
     add_compile_definitions(__LIBRETRO__)
 endif()
 
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND ENABLE_USER_BUILD)
+    # Disable stack buffer overflow checks in user builds
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GS-")
+endif() 
+
 add_library(AlberCore STATIC)
 
 include_directories(${PROJECT_SOURCE_DIR}/include/)

From 195f3388e9a5f88e18ee2779c71069c60668f544 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Fri, 2 Aug 2024 22:53:51 +0300
Subject: [PATCH 28/38] PICA: Add LITP test + interpreter implementation

---
 include/PICA/shader.hpp               |   3 +-
 src/core/PICA/shader_interpreter.cpp  |  32 ++++
 tests/PICA_LITP/Makefile              | 255 ++++++++++++++++++++++++++
 tests/PICA_LITP/source/main.c         | 128 +++++++++++++
 tests/PICA_LITP/source/vshader.v.pica |  73 ++++++++
 5 files changed, 490 insertions(+), 1 deletion(-)
 create mode 100644 tests/PICA_LITP/Makefile
 create mode 100644 tests/PICA_LITP/source/main.c
 create mode 100644 tests/PICA_LITP/source/vshader.v.pica

diff --git a/include/PICA/shader.hpp b/include/PICA/shader.hpp
index 68b16de8..e5f57c72 100644
--- a/include/PICA/shader.hpp
+++ b/include/PICA/shader.hpp
@@ -23,7 +23,7 @@ namespace ShaderOpcodes {
 		DST = 0x04,
 		EX2 = 0x05,
 		LG2 = 0x06,
-		LIT = 0x07,
+		LITP = 0x07,
 		MUL = 0x08,
 		SGE = 0x09,
 		SLT = 0x0A,
@@ -161,6 +161,7 @@ class PICAShader {
 	void jmpc(u32 instruction);
 	void jmpu(u32 instruction);
 	void lg2(u32 instruction);
+	void litp(u32 instruction);
 	void loop(u32 instruction);
 	void mad(u32 instruction);
 	void madi(u32 instruction);
diff --git a/src/core/PICA/shader_interpreter.cpp b/src/core/PICA/shader_interpreter.cpp
index 003ef97a..a85c7464 100644
--- a/src/core/PICA/shader_interpreter.cpp
+++ b/src/core/PICA/shader_interpreter.cpp
@@ -74,6 +74,9 @@ void PICAShader::run() {
 				break;
 			}
 
+			// Undocumented, implementation based on 3DBrew and hw testing (see tests/PICA_LITP)
+			case ShaderOpcodes::LITP: [[unlikely]] litp(instruction); break;
+
 			default: Helpers::panic("Unimplemented PICA instruction %08X (Opcode = %02X)", instruction, opcode);
 		}
 
@@ -753,4 +756,33 @@ void PICAShader::jmpu(u32 instruction) {
 
 	if (((boolUniform >> bit) & 1) == test)  // Jump if the bool uniform is the value we want
 		pc = dest;
+}
+
+void PICAShader::litp(u32 instruction) {
+	const u32 operandDescriptor = operandDescriptors[instruction & 0x7f];
+	u32 src = getBits<12, 7>(instruction);
+	const u32 idx = getBits<19, 2>(instruction);
+	const u32 dest = getBits<21, 5>(instruction);
+
+	src = getIndexedSource(src, idx);
+	vec4f srcVec = getSourceSwizzled<1>(src, operandDescriptor);
+	vec4f& destVector = getDest(dest);
+
+	// Compare registers are set based on whether src.x and src.w are >= 0.0
+	cmpRegister[0] = (srcVec[0].toFloat32() >= 0.0f);
+	cmpRegister[1] = (srcVec[3].toFloat32() >= 0.0f);
+
+	vec4f result;
+	// TODO: Does max here have the same non-IEEE NaN behavior as the max instruction?
+	result[0] = f24::fromFloat32(std::max(srcVec[0].toFloat32(), 0.0f));
+	result[1] = f24::fromFloat32(std::clamp(srcVec[1].toFloat32(), -127.9961f, 127.9961f));
+	result[2] = f24::zero();
+	result[3] = f24::fromFloat32(std::max(srcVec[3].toFloat32(), 0.0f));
+
+	u32 componentMask = operandDescriptor & 0xf;
+	for (int i = 0; i < 4; i++) {
+		if (componentMask & (1 << i)) {
+			destVector[3 - i] = result[3 - i];
+		}
+	}
 }
\ No newline at end of file
diff --git a/tests/PICA_LITP/Makefile b/tests/PICA_LITP/Makefile
new file mode 100644
index 00000000..46a94048
--- /dev/null
+++ b/tests/PICA_LITP/Makefile
@@ -0,0 +1,255 @@
+#---------------------------------------------------------------------------------
+.SUFFIXES:
+#---------------------------------------------------------------------------------
+
+ifeq ($(strip $(DEVKITARM)),)
+$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
+endif
+
+TOPDIR ?= $(CURDIR)
+include $(DEVKITARM)/3ds_rules
+
+#---------------------------------------------------------------------------------
+# TARGET is the name of the output
+# BUILD is the directory where object files & intermediate files will be placed
+# SOURCES is a list of directories containing source code
+# DATA is a list of directories containing data files
+# INCLUDES is a list of directories containing header files
+# GRAPHICS is a list of directories containing graphics files
+# GFXBUILD is the directory where converted graphics files will be placed
+#   If set to $(BUILD), it will statically link in the converted
+#   files as if they were data files.
+#
+# NO_SMDH: if set to anything, no SMDH file is generated.
+# ROMFS is the directory which contains the RomFS, relative to the Makefile (Optional)
+# APP_TITLE is the name of the app stored in the SMDH file (Optional)
+# APP_DESCRIPTION is the description of the app stored in the SMDH file (Optional)
+# APP_AUTHOR is the author of the app stored in the SMDH file (Optional)
+# ICON is the filename of the icon (.png), relative to the project folder.
+#   If not set, it attempts to use one of the following (in this order):
+#     - <Project name>.png
+#     - icon.png
+#     - <libctru folder>/default_icon.png
+#---------------------------------------------------------------------------------
+TARGET		:=	$(notdir $(CURDIR))
+BUILD		:=	build
+SOURCES		:=	source
+DATA		:=	data
+INCLUDES	:=	include
+GRAPHICS	:=	gfx
+GFXBUILD	:=	$(BUILD)
+#ROMFS		:=	romfs
+#GFXBUILD	:=	$(ROMFS)/gfx
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+ARCH	:=	-march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
+
+CFLAGS	:=	-g -Wall -O2 -mword-relocations \
+			-ffunction-sections \
+			$(ARCH)
+
+CFLAGS	+=	$(INCLUDE) -D__3DS__
+
+CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++11
+
+ASFLAGS	:=	-g $(ARCH)
+LDFLAGS	=	-specs=3dsx.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
+
+LIBS	:= -lcitro3d -lctru -lm
+
+#---------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS	:= $(CTRULIB)
+
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+
+export OUTPUT	:=	$(CURDIR)/$(TARGET)
+export TOPDIR	:=	$(CURDIR)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR	:=	$(CURDIR)/$(BUILD)
+
+CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+PICAFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.v.pica)))
+SHLISTFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.shlist)))
+GFXFILES	:=	$(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.t3s)))
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+#---------------------------------------------------------------------------------
+ifeq ($(GFXBUILD),$(BUILD))
+#---------------------------------------------------------------------------------
+export T3XFILES :=  $(GFXFILES:.t3s=.t3x)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+export ROMFS_T3XFILES	:=	$(patsubst %.t3s, $(GFXBUILD)/%.t3x, $(GFXFILES))
+export T3XHFILES		:=	$(patsubst %.t3s, $(BUILD)/%.h, $(GFXFILES))
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_SOURCES 	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES)) \
+			$(PICAFILES:.v.pica=.shbin.o) $(SHLISTFILES:.shlist=.shbin.o) \
+			$(addsuffix .o,$(T3XFILES))
+
+export OFILES := $(OFILES_BIN) $(OFILES_SOURCES)
+
+export HFILES	:=	$(PICAFILES:.v.pica=_shbin.h) $(SHLISTFILES:.shlist=_shbin.h) \
+			$(addsuffix .h,$(subst .,_,$(BINFILES))) \
+			$(GFXFILES:.t3s=.h)
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I$(CURDIR)/$(BUILD)
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
+
+export _3DSXDEPS	:=	$(if $(NO_SMDH),,$(OUTPUT).smdh)
+
+ifeq ($(strip $(ICON)),)
+	icons := $(wildcard *.png)
+	ifneq (,$(findstring $(TARGET).png,$(icons)))
+		export APP_ICON := $(TOPDIR)/$(TARGET).png
+	else
+		ifneq (,$(findstring icon.png,$(icons)))
+			export APP_ICON := $(TOPDIR)/icon.png
+		endif
+	endif
+else
+	export APP_ICON := $(TOPDIR)/$(ICON)
+endif
+
+ifeq ($(strip $(NO_SMDH)),)
+	export _3DSXFLAGS += --smdh=$(CURDIR)/$(TARGET).smdh
+endif
+
+ifneq ($(ROMFS),)
+	export _3DSXFLAGS += --romfs=$(CURDIR)/$(ROMFS)
+endif
+
+.PHONY: all clean
+
+#---------------------------------------------------------------------------------
+all: $(BUILD) $(GFXBUILD) $(DEPSDIR) $(ROMFS_T3XFILES) $(T3XHFILES)
+	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+
+$(BUILD):
+	@mkdir -p $@
+
+ifneq ($(GFXBUILD),$(BUILD))
+$(GFXBUILD):
+	@mkdir -p $@
+endif
+
+ifneq ($(DEPSDIR),$(BUILD))
+$(DEPSDIR):
+	@mkdir -p $@
+endif
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(BUILD) $(TARGET).3dsx $(OUTPUT).smdh $(TARGET).elf $(GFXBUILD)
+
+#---------------------------------------------------------------------------------
+$(GFXBUILD)/%.t3x	$(BUILD)/%.h	:	%.t3s
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@tex3ds -i $< -H $(BUILD)/$*.h -d $(DEPSDIR)/$*.d -o $(GFXBUILD)/$*.t3x
+
+#---------------------------------------------------------------------------------
+else
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+$(OUTPUT).3dsx	:	$(OUTPUT).elf $(_3DSXDEPS)
+
+$(OFILES_SOURCES) : $(HFILES)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h :	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+#---------------------------------------------------------------------------------
+.PRECIOUS	:	%.t3x
+#---------------------------------------------------------------------------------
+%.t3x.o	%_t3x.h :	%.t3x
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+#---------------------------------------------------------------------------------
+# rules for assembling GPU shaders
+#---------------------------------------------------------------------------------
+define shader-as
+	$(eval CURBIN := $*.shbin)
+	$(eval DEPSFILE := $(DEPSDIR)/$*.shbin.d)
+	echo "$(CURBIN).o: $< $1" > $(DEPSFILE)
+	echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"_end[];" > `(echo $(CURBIN) | tr . _)`.h
+	echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(CURBIN) | tr . _)`.h
+	echo "extern const u32" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_size";" >> `(echo $(CURBIN) | tr . _)`.h
+	picasso -o $(CURBIN) $1
+	bin2s $(CURBIN) | $(AS) -o $*.shbin.o
+endef
+
+%.shbin.o %_shbin.h : %.v.pica %.g.pica
+	@echo $(notdir $^)
+	@$(call shader-as,$^)
+
+%.shbin.o %_shbin.h : %.v.pica
+	@echo $(notdir $<)
+	@$(call shader-as,$<)
+
+%.shbin.o %_shbin.h : %.shlist
+	@echo $(notdir $<)
+	@$(call shader-as,$(foreach file,$(shell cat $<),$(dir $<)$(file)))
+
+#---------------------------------------------------------------------------------
+%.t3x	%.h	:	%.t3s
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@tex3ds -i $< -H $*.h -d $*.d -o $*.t3x
+
+-include $(DEPSDIR)/*.d
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------
diff --git a/tests/PICA_LITP/source/main.c b/tests/PICA_LITP/source/main.c
new file mode 100644
index 00000000..3c2a3f0c
--- /dev/null
+++ b/tests/PICA_LITP/source/main.c
@@ -0,0 +1,128 @@
+#include <3ds.h>
+#include <citro3d.h>
+#include <string.h>
+#include "vshader_shbin.h"
+
+#define CLEAR_COLOR 0x68B0D8FF
+
+#define DISPLAY_TRANSFER_FLAGS \
+	(GX_TRANSFER_FLIP_VERT(0) | GX_TRANSFER_OUT_TILED(0) | GX_TRANSFER_RAW_COPY(0) | \
+	GX_TRANSFER_IN_FORMAT(GX_TRANSFER_FMT_RGBA8) | GX_TRANSFER_OUT_FORMAT(GX_TRANSFER_FMT_RGB8) | \
+	GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_NO))
+
+static DVLB_s* vshader_dvlb;
+static shaderProgram_s program;
+static int uLoc_projection;
+static C3D_Mtx projection;
+
+static void sceneInit(void)
+{
+	// Load the vertex shader, create a shader program and bind it
+	vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
+	shaderProgramInit(&program);
+	shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
+	C3D_BindProgram(&program);
+
+	// Get the location of the uniforms
+	uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
+
+	// Configure attributes for use with the vertex shader
+	// Attribute format and element count are ignored in immediate mode
+	C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
+	AttrInfo_Init(attrInfo);
+	AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
+	AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 3); // v1=color
+
+	// Compute the projection matrix
+	Mtx_OrthoTilt(&projection, 0.0, 400.0, 0.0, 240.0, 0.0, 1.0, true);
+
+	// Configure the first fragment shading substage to just pass through the vertex color
+	// See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
+	C3D_TexEnv* env = C3D_GetTexEnv(0);
+	C3D_TexEnvInit(env);
+	C3D_TexEnvSrc(env, C3D_Both, GPU_PRIMARY_COLOR, 0, 0);
+	C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
+}
+
+static void sceneRender(void)
+{
+	// Update the uniforms
+	C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, uLoc_projection, &projection);
+
+	// Draw the triangle directly
+	C3D_ImmDrawBegin(GPU_TRIANGLES);
+        // Triangle 1
+        // This vertex has r >= 0 and a >= 0 so the shader should output magenta (cmp.x = cmp.y = 1)
+		C3D_ImmSendAttrib(200.0f, 200.0f, 0.5f, 0.0f); // v0=position
+		C3D_ImmSendAttrib(1.0f, 0.0f, 0.0f, 1.0f);     // v1=color
+
+        // This vertex only has a >= 0, so the shader should output lime (cmp.x = 0, cmp.y = 1)
+		C3D_ImmSendAttrib(100.0f, 40.0f, 0.5f, 0.0f);
+		C3D_ImmSendAttrib(-0.5f, 1.0f, 0.0f, 1.0f);
+
+        // This vertex only has r >= 0, so the shader should output cyan (cmp.x = 1, cmp.y = 0)
+		C3D_ImmSendAttrib(300.0f, 40.0f, 0.5f, 0.0f);
+		C3D_ImmSendAttrib(0.5f, 0.0f, 1.0f, -1.0f);
+
+		// Triangle 2
+		// The next 3 vertices have r < 0, a < 0, so the output of the shader should be the output of litp  with alpha set to 1 (cmp.x = cmp.y = 0)
+		C3D_ImmSendAttrib(10.0f, 20.0f, 0.5f, 0.0f);
+        // Output g component should be 64 / 128  = 0.5
+		C3D_ImmSendAttrib(-1.0f, 64.0f, 0.0f, -1.0f);
+
+        C3D_ImmSendAttrib(90.0f, 20.0f, 0.5f, 0.0f);
+		// Output g component should be 128 / 128 = 1.0
+		C3D_ImmSendAttrib(-1.0f, 256.0f, 1.0f, -1.0f);
+
+		C3D_ImmSendAttrib(40.0f, 40.0f, 0.5f, 0.0f);
+        // Output g component should be 0 / 128 = 0
+		C3D_ImmSendAttrib(-1.0f, 0.0f, 0.5f, -1.0f);
+	C3D_ImmDrawEnd();
+}
+
+static void sceneExit(void)
+{
+	// Free the shader program
+	shaderProgramFree(&program);
+	DVLB_Free(vshader_dvlb);
+}
+
+int main()
+{
+	// Initialize graphics
+	gfxInitDefault();
+	C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
+
+	// Initialize the render target
+	C3D_RenderTarget* target = C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
+	C3D_RenderTargetSetOutput(target, GFX_TOP, GFX_LEFT, DISPLAY_TRANSFER_FLAGS);
+
+	// Initialize the scene
+	sceneInit();
+
+	// Main loop
+	while (aptMainLoop())
+	{
+		hidScanInput();
+
+		// Respond to user input
+		u32 kDown = hidKeysDown();
+		if (kDown & KEY_START)
+			break; // break in order to return to hbmenu
+
+		// Render the scene
+		C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
+			C3D_RenderTargetClear(target, C3D_CLEAR_ALL, CLEAR_COLOR, 0);
+			C3D_FrameDrawOn(target);
+			sceneRender();
+		C3D_FrameEnd(0);
+	}
+
+	// Deinitialize the scene
+	sceneExit();
+
+	// Deinitialize graphics
+	C3D_Fini();
+	gfxExit();
+	return 0;
+}
\ No newline at end of file
diff --git a/tests/PICA_LITP/source/vshader.v.pica b/tests/PICA_LITP/source/vshader.v.pica
new file mode 100644
index 00000000..d745f939
--- /dev/null
+++ b/tests/PICA_LITP/source/vshader.v.pica
@@ -0,0 +1,73 @@
+; Example PICA200 vertex shader
+
+; Uniforms
+.fvec projection[4]
+
+; Constants
+.constf myconst(0.0, 1.0, -1.0, 0.1)
+.constf myconst2(0.3, 0.0, 0.0, 0.0)
+.alias  zeros myconst.xxxx ; Vector full of zeros
+.alias  ones  myconst.yyyy ; Vector full of ones
+
+.constf magenta(0.8, 0.192, 0.812, 1.0)
+.constf cyan(0.137, 0.949, 0.906, 1.0)
+.constf lime(0.286, 0.929, 0.412, 1.0)
+
+.constf normalize_y(1.0, 1.0/128.0, 1.0, 1.0)
+
+; Outputs
+.out outpos position
+.out outclr color
+
+; Inputs (defined as aliases for convenience)
+.alias inpos v0
+.alias inclr v1
+
+.bool test
+
+.proc main
+	; Force the w component of inpos to be 1.0
+	mov r0.xyz, inpos
+	mov r0.w,   ones
+
+	; outpos = projectionMatrix * inpos
+	dp4 outpos.x, projection[0], r0
+	dp4 outpos.y, projection[1], r0
+	dp4 outpos.z, projection[2], r0
+	dp4 outpos.w, projection[3], r0
+
+	; Test litp via the output fragment colour
+	; r1 = input colour
+	mov r1, inclr
+
+	; This should perform the following operation:
+	; cmp = (x >= 0, w >= 0)
+	; dest = ( max(x, 0), clamp(y, -128, +128 ), 0, max(w, 0) );
+	litp r2, r1
+
+	ifc cmp.x
+		ifc cmp.y
+			; cmp.x = 1, cmp.y = 1, write magenta
+			mov outclr, magenta
+			end
+		.else
+			; cmp.x = 1, cmp.y = 0, write cyan
+			mov outclr, cyan
+			end
+		.end
+	.else
+		ifc cmp.y
+			; cmp.x = 0, cmp.y
+			mov outclr, lime
+			end
+		.end
+	.end
+
+	; cmp.x 0, cmp.y = 0, write output of litp to out colour, with y normalized to [-1, 1]
+	mul r2.xyz, normalize_y, r2	
+	; Set alpha to one
+	mov r2.a, ones.a
+
+	mov outclr, r2
+	end
+.end
\ No newline at end of file

From 24c4e02143f2803cfbee7723bb6c480605911d4d Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Fri, 2 Aug 2024 22:59:33 +0300
Subject: [PATCH 29/38] Format litp test

---
 tests/PICA_LITP/source/main.c | 79 ++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 42 deletions(-)

diff --git a/tests/PICA_LITP/source/main.c b/tests/PICA_LITP/source/main.c
index 3c2a3f0c..9bcab5b9 100644
--- a/tests/PICA_LITP/source/main.c
+++ b/tests/PICA_LITP/source/main.c
@@ -1,22 +1,22 @@
 #include <3ds.h>
 #include <citro3d.h>
 #include <string.h>
+
 #include "vshader_shbin.h"
 
+
 #define CLEAR_COLOR 0x68B0D8FF
 
-#define DISPLAY_TRANSFER_FLAGS \
-	(GX_TRANSFER_FLIP_VERT(0) | GX_TRANSFER_OUT_TILED(0) | GX_TRANSFER_RAW_COPY(0) | \
-	GX_TRANSFER_IN_FORMAT(GX_TRANSFER_FMT_RGBA8) | GX_TRANSFER_OUT_FORMAT(GX_TRANSFER_FMT_RGB8) | \
-	GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_NO))
+#define DISPLAY_TRANSFER_FLAGS                                                                                                      \
+	(GX_TRANSFER_FLIP_VERT(0) | GX_TRANSFER_OUT_TILED(0) | GX_TRANSFER_RAW_COPY(0) | GX_TRANSFER_IN_FORMAT(GX_TRANSFER_FMT_RGBA8) | \
+	 GX_TRANSFER_OUT_FORMAT(GX_TRANSFER_FMT_RGB8) | GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_NO))
 
 static DVLB_s* vshader_dvlb;
 static shaderProgram_s program;
 static int uLoc_projection;
 static C3D_Mtx projection;
 
-static void sceneInit(void)
-{
+static void sceneInit(void) {
 	// Load the vertex shader, create a shader program and bind it
 	vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
 	shaderProgramInit(&program);
@@ -30,8 +30,8 @@ static void sceneInit(void)
 	// Attribute format and element count are ignored in immediate mode
 	C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
 	AttrInfo_Init(attrInfo);
-	AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
-	AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 3); // v1=color
+	AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3);  // v0=position
+	AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 3);  // v1=color
 
 	// Compute the projection matrix
 	Mtx_OrthoTilt(&projection, 0.0, 400.0, 0.0, 240.0, 0.0, 1.0, true);
@@ -44,51 +44,48 @@ static void sceneInit(void)
 	C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
 }
 
-static void sceneRender(void)
-{
+static void sceneRender(void) {
 	// Update the uniforms
 	C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, uLoc_projection, &projection);
 
 	// Draw the triangle directly
 	C3D_ImmDrawBegin(GPU_TRIANGLES);
-        // Triangle 1
-        // This vertex has r >= 0 and a >= 0 so the shader should output magenta (cmp.x = cmp.y = 1)
-		C3D_ImmSendAttrib(200.0f, 200.0f, 0.5f, 0.0f); // v0=position
-		C3D_ImmSendAttrib(1.0f, 0.0f, 0.0f, 1.0f);     // v1=color
+	// Triangle 1
+	// This vertex has r >= 0 and a >= 0 so the shader should output magenta (cmp.x = cmp.y = 1)
+	C3D_ImmSendAttrib(200.0f, 200.0f, 0.5f, 0.0f);  // v0=position
+	C3D_ImmSendAttrib(1.0f, 0.0f, 0.0f, 1.0f);      // v1=color
 
-        // This vertex only has a >= 0, so the shader should output lime (cmp.x = 0, cmp.y = 1)
-		C3D_ImmSendAttrib(100.0f, 40.0f, 0.5f, 0.0f);
-		C3D_ImmSendAttrib(-0.5f, 1.0f, 0.0f, 1.0f);
+	// This vertex only has a >= 0, so the shader should output lime (cmp.x = 0, cmp.y = 1)
+	C3D_ImmSendAttrib(100.0f, 40.0f, 0.5f, 0.0f);
+	C3D_ImmSendAttrib(-0.5f, 1.0f, 0.0f, 1.0f);
 
-        // This vertex only has r >= 0, so the shader should output cyan (cmp.x = 1, cmp.y = 0)
-		C3D_ImmSendAttrib(300.0f, 40.0f, 0.5f, 0.0f);
-		C3D_ImmSendAttrib(0.5f, 0.0f, 1.0f, -1.0f);
+	// This vertex only has r >= 0, so the shader should output cyan (cmp.x = 1, cmp.y = 0)
+	C3D_ImmSendAttrib(300.0f, 40.0f, 0.5f, 0.0f);
+	C3D_ImmSendAttrib(0.5f, 0.0f, 1.0f, -1.0f);
 
-		// Triangle 2
-		// The next 3 vertices have r < 0, a < 0, so the output of the shader should be the output of litp  with alpha set to 1 (cmp.x = cmp.y = 0)
-		C3D_ImmSendAttrib(10.0f, 20.0f, 0.5f, 0.0f);
-        // Output g component should be 64 / 128  = 0.5
-		C3D_ImmSendAttrib(-1.0f, 64.0f, 0.0f, -1.0f);
+	// Triangle 2
+	// The next 3 vertices have r < 0, a < 0, so the output of the shader should be the output of litp  with alpha set to 1 (cmp.x = cmp.y = 0)
+	C3D_ImmSendAttrib(10.0f, 20.0f, 0.5f, 0.0f);
+	// Output g component should be 64 / 128  = 0.5
+	C3D_ImmSendAttrib(-1.0f, 64.0f, 0.0f, -1.0f);
 
-        C3D_ImmSendAttrib(90.0f, 20.0f, 0.5f, 0.0f);
-		// Output g component should be 128 / 128 = 1.0
-		C3D_ImmSendAttrib(-1.0f, 256.0f, 1.0f, -1.0f);
+	C3D_ImmSendAttrib(90.0f, 20.0f, 0.5f, 0.0f);
+	// Output g component should be 128 / 128 = 1.0
+	C3D_ImmSendAttrib(-1.0f, 256.0f, 1.0f, -1.0f);
 
-		C3D_ImmSendAttrib(40.0f, 40.0f, 0.5f, 0.0f);
-        // Output g component should be 0 / 128 = 0
-		C3D_ImmSendAttrib(-1.0f, 0.0f, 0.5f, -1.0f);
+	C3D_ImmSendAttrib(40.0f, 40.0f, 0.5f, 0.0f);
+	// Output g component should be 0 / 128 = 0
+	C3D_ImmSendAttrib(-1.0f, 0.0f, 0.5f, -1.0f);
 	C3D_ImmDrawEnd();
 }
 
-static void sceneExit(void)
-{
+static void sceneExit(void) {
 	// Free the shader program
 	shaderProgramFree(&program);
 	DVLB_Free(vshader_dvlb);
 }
 
-int main()
-{
+int main() {
 	// Initialize graphics
 	gfxInitDefault();
 	C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
@@ -101,20 +98,18 @@ int main()
 	sceneInit();
 
 	// Main loop
-	while (aptMainLoop())
-	{
+	while (aptMainLoop()) {
 		hidScanInput();
 
 		// Respond to user input
 		u32 kDown = hidKeysDown();
-		if (kDown & KEY_START)
-			break; // break in order to return to hbmenu
+		if (kDown & KEY_START) break;  // break in order to return to hbmenu
 
 		// Render the scene
 		C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
-			C3D_RenderTargetClear(target, C3D_CLEAR_ALL, CLEAR_COLOR, 0);
-			C3D_FrameDrawOn(target);
-			sceneRender();
+		C3D_RenderTargetClear(target, C3D_CLEAR_ALL, CLEAR_COLOR, 0);
+		C3D_FrameDrawOn(target);
+		sceneRender();
 		C3D_FrameEnd(0);
 	}
 

From 68a6d73a1851168211ee1dd2047bb3ce41497c3f Mon Sep 17 00:00:00 2001
From: Jonian Guveli <jonian@hardpixel.eu>
Date: Sat, 3 Aug 2024 10:32:26 +0300
Subject: [PATCH 30/38] Libretro: Add support for cheats

---
 src/libretro_core.cpp | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/src/libretro_core.cpp b/src/libretro_core.cpp
index 3e0436b8..c91460b8 100644
--- a/src/libretro_core.cpp
+++ b/src/libretro_core.cpp
@@ -1,5 +1,6 @@
 #include <stdexcept>
 #include <cstdio>
+#include <regex>
 
 #include <libretro.h>
 
@@ -381,5 +382,24 @@ void* retro_get_memory_data(uint id) {
 	return nullptr;
 }
 
-void retro_cheat_set(uint index, bool enabled, const char* code) {}
-void retro_cheat_reset() {}
+void retro_cheat_set(uint index, bool enabled, const char* code) {
+	std::string cheatCode = std::regex_replace(code, std::regex("[^0-9a-fA-F]"), "");
+	std::vector<u8> bytes;
+
+	for (size_t i = 0; i < cheatCode.size(); i += 2) {
+		std::string hex = cheatCode.substr(i, 2);
+		bytes.push_back((u8)std::stoul(hex, nullptr, 16));
+	}
+
+	u32 id = emulator->getCheats().addCheat(bytes.data(), bytes.size());
+
+	if (enabled) {
+		emulator->getCheats().enableCheat(id);
+	} else {
+		emulator->getCheats().disableCheat(id);
+	}
+}
+
+void retro_cheat_reset() {
+	emulator->getCheats().reset();
+}

From 6e65367e07456b0b71cb1bfe945fd6c9a0e2cc3b Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Sat, 3 Aug 2024 12:52:52 +0300
Subject: [PATCH 31/38] size_t -> usize

---
 src/libretro_core.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libretro_core.cpp b/src/libretro_core.cpp
index c91460b8..b099067f 100644
--- a/src/libretro_core.cpp
+++ b/src/libretro_core.cpp
@@ -386,7 +386,7 @@ void retro_cheat_set(uint index, bool enabled, const char* code) {
 	std::string cheatCode = std::regex_replace(code, std::regex("[^0-9a-fA-F]"), "");
 	std::vector<u8> bytes;
 
-	for (size_t i = 0; i < cheatCode.size(); i += 2) {
+	for (usize i = 0; i < cheatCode.size(); i += 2) {
 		std::string hex = cheatCode.substr(i, 2);
 		bytes.push_back((u8)std::stoul(hex, nullptr, 16));
 	}

From 85bae2e94eadb187ddbfcf5fe2005ac7bcd3bd5e Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Sun, 4 Aug 2024 16:46:43 +0300
Subject: [PATCH 32/38] HLE DSP: Handle cycle drifting

---
 include/audio/dsp_core.hpp    |  2 +-
 include/audio/hle_core.hpp    |  4 +++-
 include/audio/null_core.hpp   |  2 +-
 include/audio/teakra_core.hpp |  2 +-
 src/core/audio/hle_core.cpp   | 21 ++++++++++++++-------
 src/core/audio/null_core.cpp  |  2 +-
 src/emulator.cpp              |  2 +-
 7 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/include/audio/dsp_core.hpp b/include/audio/dsp_core.hpp
index a4fb1ab1..5addfd19 100644
--- a/include/audio/dsp_core.hpp
+++ b/include/audio/dsp_core.hpp
@@ -43,7 +43,7 @@ namespace Audio {
 		virtual ~DSPCore() {}
 
 		virtual void reset() = 0;
-		virtual void runAudioFrame() = 0;
+		virtual void runAudioFrame(u64 eventTimestamp) = 0;
 		virtual u8* getDspMemory() = 0;
 
 		virtual u16 recvData(u32 regId) = 0;
diff --git a/include/audio/hle_core.hpp b/include/audio/hle_core.hpp
index 35c1c1b8..c0e0896f 100644
--- a/include/audio/hle_core.hpp
+++ b/include/audio/hle_core.hpp
@@ -42,6 +42,7 @@ namespace Audio {
 				return this->bufferID > other.bufferID;
 			}
 		};
+
 		// Buffer of decoded PCM16 samples. TODO: Are there better alternatives to use over deque?
 		using SampleBuffer = std::deque<std::array<s16, 2>>;
 
@@ -53,6 +54,7 @@ namespace Audio {
 
 		std::array<float, 3> gain0, gain1, gain2;
 		u32 samplePosition;  // Sample number into the current audio buffer
+		float rateMultiplier;
 		u16 syncCount;
 		u16 currentBufferID;
 		u16 previousBufferID;
@@ -185,7 +187,7 @@ namespace Audio {
 		~HLE_DSP() override {}
 
 		void reset() override;
-		void runAudioFrame() override;
+		void runAudioFrame(u64 eventTimestamp) override;
 
 		u8* getDspMemory() override { return dspRam.rawMemory.data(); }
 
diff --git a/include/audio/null_core.hpp b/include/audio/null_core.hpp
index 7d6f1c9e..bedec8d3 100644
--- a/include/audio/null_core.hpp
+++ b/include/audio/null_core.hpp
@@ -27,7 +27,7 @@ namespace Audio {
 		~NullDSP() override {}
 
 		void reset() override;
-		void runAudioFrame() override;
+		void runAudioFrame(u64 eventTimestamp) override;
 
 		u8* getDspMemory() override { return dspRam.data(); }
 
diff --git a/include/audio/teakra_core.hpp b/include/audio/teakra_core.hpp
index 6a011231..17104985 100644
--- a/include/audio/teakra_core.hpp
+++ b/include/audio/teakra_core.hpp
@@ -83,7 +83,7 @@ namespace Audio {
 		void reset() override;
 
 		// Run 1 slice of DSP instructions and schedule the next audio frame
-		void runAudioFrame() override {
+		void runAudioFrame(u64 eventTimestamp) override {
 			runSlice();
 			scheduler.addEvent(Scheduler::EventType::RunDSP, scheduler.currentTimestamp + Audio::lleSlice * 2);
 		}
diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index ffab9301..d1297ad8 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -95,7 +95,7 @@ namespace Audio {
 		scheduler.removeEvent(Scheduler::EventType::RunDSP);
 	}
 
-	void HLE_DSP::runAudioFrame() {
+	void HLE_DSP::runAudioFrame(u64 eventTimestamp) {
 		// Signal audio pipe when an audio frame is done
 		if (dspState == DSPState::On) [[likely]] {
 			dspService.triggerPipeEvent(DSPPipeType::Audio);
@@ -103,7 +103,10 @@ namespace Audio {
 
 		// TODO: Should this be called if dspState != DSPState::On?
 		outputFrame();
-		scheduler.addEvent(Scheduler::EventType::RunDSP, scheduler.currentTimestamp + Audio::cyclesPerFrame);
+
+		// How many cycles we were late
+		const u64 cycleDrift = scheduler.currentTimestamp - eventTimestamp;
+		scheduler.addEvent(Scheduler::EventType::RunDSP, scheduler.currentTimestamp + Audio::cyclesPerFrame - cycleDrift);
 	}
 
 	u16 HLE_DSP::recvData(u32 regId) {
@@ -237,10 +240,9 @@ namespace Audio {
 			auto& status = write.sourceStatuses.status[i];
 			status.enabled = source.enabled;
 			status.syncCount = source.syncCount;
-			status.currentBufferIDDirty = source.isBufferIDDirty ? 1 : 0;
+			status.currentBufferIDDirty = (source.isBufferIDDirty ? 1 : 0);
 			status.currentBufferID = source.currentBufferID;
 			status.previousBufferID = source.previousBufferID;
-			// TODO: Properly update sample position
 			status.samplePosition = source.samplePosition;
 
 			source.isBufferIDDirty = false;
@@ -292,6 +294,10 @@ namespace Audio {
 			source.sourceType = config.monoOrStereo;
 		}
 
+		if (config.rateMultiplierDirty) {
+			source.rateMultiplier = (config.rateMultiplier > 0.f) ? config.rateMultiplier : 1.f;
+		}
+
 		if (config.embeddedBufferDirty) {
 			// Annoyingly, and only for embedded buffer, whether we use config.playPosition depends on the relevant dirty bit
 			const u32 playPosition = config.playPositionDirty ? config.playPosition : 0;
@@ -434,7 +440,7 @@ namespace Audio {
 
 			decodeBuffer(source);
 		} else {
-			constexpr uint maxSampleCount = Audio::samplesInFrame;
+			uint maxSampleCount = uint(float(Audio::samplesInFrame) * source.rateMultiplier);
 			uint outputCount = 0;
 
 			while (outputCount < maxSampleCount) {
@@ -447,9 +453,9 @@ namespace Audio {
 				}
 
 				const uint sampleCount = std::min<s32>(maxSampleCount - outputCount, source.currentSamples.size());
-				// samples.insert(samples.end(), source.currentSamples.begin(), source.currentSamples.begin() + sampleCount);
-				source.currentSamples.erase(source.currentSamples.begin(), source.currentSamples.begin() + sampleCount);
 
+				// samples.insert(samples.end(), source.currentSamples.begin(), source.currentSamples.begin() + sampleCount);
+				source.currentSamples.erase(source.currentSamples.begin(), std::next(source.currentSamples.begin(), sampleCount));
 				source.samplePosition += sampleCount;
 				outputCount += sampleCount;
 			}
@@ -618,6 +624,7 @@ namespace Audio {
 		previousBufferID = 0;
 		currentBufferID = 0;
 		syncCount = 0;
+		rateMultiplier = 1.f;
 
 		buffers = {};
 	}
diff --git a/src/core/audio/null_core.cpp b/src/core/audio/null_core.cpp
index ec073ae7..93c746cb 100644
--- a/src/core/audio/null_core.cpp
+++ b/src/core/audio/null_core.cpp
@@ -74,7 +74,7 @@ namespace Audio {
 		scheduler.removeEvent(Scheduler::EventType::RunDSP);
 	}
 
-	void NullDSP::runAudioFrame() {
+	void NullDSP::runAudioFrame(u64 eventTimestamp) {
 		// Signal audio pipe when an audio frame is done
 		if (dspState == DSPState::On) [[likely]] {
 			dspService.triggerPipeEvent(DSPPipeType::Audio);
diff --git a/src/emulator.cpp b/src/emulator.cpp
index 921af08f..8ce71e43 100644
--- a/src/emulator.cpp
+++ b/src/emulator.cpp
@@ -167,7 +167,7 @@ void Emulator::pollScheduler() {
 
 			case Scheduler::EventType::UpdateTimers: kernel.pollTimers(); break;
 			case Scheduler::EventType::RunDSP: {
-				dsp->runAudioFrame();
+				dsp->runAudioFrame(time);
 				break;
 			}
 

From 860eacc7e6b94da8f2d977880d4e99cf5bd97d96 Mon Sep 17 00:00:00 2001
From: Paris Oplopoios <parisoplop@gmail.com>
Date: Thu, 8 Aug 2024 17:29:44 +0300
Subject: [PATCH 33/38] Add createFromBinary function (#573)

* Add createFromBinary function

* Indentation

---------

Co-authored-by: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
---
 third_party/opengl/opengl.hpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/third_party/opengl/opengl.hpp b/third_party/opengl/opengl.hpp
index 4a08650a..607815fa 100644
--- a/third_party/opengl/opengl.hpp
+++ b/third_party/opengl/opengl.hpp
@@ -432,6 +432,25 @@ namespace OpenGL {
 			return m_handle != 0;
 		}
 
+		bool createFromBinary(const uint8_t* binary, size_t size, GLenum format) {
+			m_handle = glCreateProgram();
+			glProgramBinary(m_handle, format, binary, size);
+
+			GLint success;
+			glGetProgramiv(m_handle, GL_LINK_STATUS, &success);
+
+			if (!success) {
+				char buf[4096];
+				glGetProgramInfoLog(m_handle, 4096, nullptr, buf);
+				fprintf(stderr, "Failed to link program\nError: %s\n", buf);
+				glDeleteProgram(m_handle);
+
+				m_handle = 0;
+			}
+
+			return m_handle != 0;
+		}
+
 		GLuint handle() const { return m_handle; }
 		bool exists() const { return m_handle != 0; }
 		void use() const { glUseProgram(m_handle); }

From 88e0782f71e7fbf5544dbf899e7b0315012a38df Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 14 Aug 2024 20:13:38 +0300
Subject: [PATCH 34/38] HLE DSP: Fix source resetting

---
 src/core/audio/hle_core.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/core/audio/hle_core.cpp b/src/core/audio/hle_core.cpp
index d1297ad8..83271a43 100644
--- a/src/core/audio/hle_core.cpp
+++ b/src/core/audio/hle_core.cpp
@@ -627,5 +627,6 @@ namespace Audio {
 		rateMultiplier = 1.f;
 
 		buffers = {};
+		currentSamples.clear();
 	}
 }  // namespace Audio

From 17b9699c24d89acec9af6b33f11498d280d4f42e Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 14 Aug 2024 17:58:26 +0000
Subject: [PATCH 35/38] Workaround MacOS runner image breaking again

---
 .github/workflows/MacOS_Build.yml | 2 +-
 .github/workflows/Qt_Build.yml    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/MacOS_Build.yml b/.github/workflows/MacOS_Build.yml
index f6fafde9..912c8568 100644
--- a/.github/workflows/MacOS_Build.yml
+++ b/.github/workflows/MacOS_Build.yml
@@ -40,7 +40,7 @@ jobs:
       run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
 
     - name: Install bundle dependencies
-      run: brew install dylibbundler imagemagick
+      run: brew install --overwrite python@3.12 && brew install dylibbundler imagemagick
 
     - name: Run bundle script
       run: ./.github/mac-bundle.sh
diff --git a/.github/workflows/Qt_Build.yml b/.github/workflows/Qt_Build.yml
index 4d5c8b57..40141fb1 100644
--- a/.github/workflows/Qt_Build.yml
+++ b/.github/workflows/Qt_Build.yml
@@ -67,7 +67,7 @@ jobs:
 
     - name: Install bundle dependencies
       run: |
-        brew install dylibbundler imagemagick
+        brew install --overwrite python@3.12 && brew install dylibbundler imagemagick
 
     - name: Install qt
       run: brew install qt && which macdeployqt

From d208c24c0cf88ce6c1ffb4266edb365116a6cbf3 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 14 Aug 2024 22:35:02 +0300
Subject: [PATCH 36/38] Implement controller gyroscope in SDL

---
 CMakeLists.txt                     |  1 +
 include/panda_sdl/frontend_sdl.hpp |  2 ++
 include/sdl_gyro.hpp               | 20 ++++++++++++++++++++
 include/services/hid.hpp           |  2 ++
 src/core/services/hid.cpp          |  1 -
 src/panda_sdl/frontend_sdl.cpp     | 29 +++++++++++++++++++++++++++++
 6 files changed, 54 insertions(+), 1 deletion(-)
 create mode 100644 include/sdl_gyro.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b55e2390..2865a3f8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -260,6 +260,7 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/termcolor.hpp
                  include/audio/miniaudio_device.hpp include/ring_buffer.hpp include/bitfield.hpp include/audio/dsp_shared_mem.hpp
                  include/audio/hle_core.hpp include/capstone.hpp include/audio/aac.hpp include/PICA/pica_frag_config.hpp
                  include/PICA/pica_frag_uniforms.hpp include/PICA/shader_gen_types.hpp include/PICA/shader_decompiler.hpp
+                 include/sdl_gyro.hpp
 )
 
 cmrc_add_resource_library(
diff --git a/include/panda_sdl/frontend_sdl.hpp b/include/panda_sdl/frontend_sdl.hpp
index 07038962..cbd0b88e 100644
--- a/include/panda_sdl/frontend_sdl.hpp
+++ b/include/panda_sdl/frontend_sdl.hpp
@@ -37,4 +37,6 @@ class FrontendSDL {
 	// And so the user can still use the keyboard to control the analog
 	bool keyboardAnalogX = false;
 	bool keyboardAnalogY = false;
+
+	void setupControllerSensors(SDL_GameController* controller);
 };
\ No newline at end of file
diff --git a/include/sdl_gyro.hpp b/include/sdl_gyro.hpp
new file mode 100644
index 00000000..17faab94
--- /dev/null
+++ b/include/sdl_gyro.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <glm/glm.hpp>
+#include <numbers>
+
+#include "services/hid.hpp"
+
+namespace Gyro::SDL {
+	// Convert the rotation data we get from SDL sensor events to rotation data we can feed right to HID
+	// Returns [pitch, roll, yaw]
+	static glm::vec3 convertRotation(glm::vec3 rotation) { 
+		// Flip axes
+		glm::vec3 ret = -rotation;
+		// Convert from radians/s to deg/s and scale by the gyroscope coefficient from the HID service
+		ret *= 180.f / std::numbers::pi;
+		ret *= HIDService::gyroscopeCoeff;
+
+		return ret;
+	}
+}  // namespace Gyro::SDL
\ No newline at end of file
diff --git a/include/services/hid.hpp b/include/services/hid.hpp
index 86a55479..bce2cc1b 100644
--- a/include/services/hid.hpp
+++ b/include/services/hid.hpp
@@ -88,6 +88,8 @@ class HIDService {
 	}
 
   public:
+	static constexpr float gyroscopeCoeff = 14.375f;  // Same as retail 3DS
+
 	HIDService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
diff --git a/src/core/services/hid.cpp b/src/core/services/hid.cpp
index ef6cbb41..aa13096c 100644
--- a/src/core/services/hid.cpp
+++ b/src/core/services/hid.cpp
@@ -103,7 +103,6 @@ void HIDService::getGyroscopeLowCalibrateParam(u32 messagePointer) {
 void HIDService::getGyroscopeCoefficient(u32 messagePointer) {
 	log("HID::GetGyroscopeLowRawToDpsCoefficient\n");
 
-	constexpr float gyroscopeCoeff = 14.375f; // Same as retail 3DS
 	mem.write32(messagePointer, IPC::responseHeader(0x15, 2, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 	mem.write32(messagePointer + 8, Helpers::bit_cast<u32, float>(gyroscopeCoeff));
diff --git a/src/panda_sdl/frontend_sdl.cpp b/src/panda_sdl/frontend_sdl.cpp
index 77b1f55f..703fb1c7 100644
--- a/src/panda_sdl/frontend_sdl.cpp
+++ b/src/panda_sdl/frontend_sdl.cpp
@@ -2,6 +2,8 @@
 
 #include <glad/gl.h>
 
+#include "sdl_gyro.hpp"
+
 FrontendSDL::FrontendSDL() : keyboardMappings(InputMappings::defaultKeyboardMappings()) {
 	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) {
 		Helpers::panic("Failed to initialize SDL2");
@@ -20,6 +22,8 @@ FrontendSDL::FrontendSDL() : keyboardMappings(InputMappings::defaultKeyboardMapp
 			SDL_Joystick* stick = SDL_GameControllerGetJoystick(gameController);
 			gameControllerID = SDL_JoystickInstanceID(stick);
 		}
+
+		setupControllerSensors(gameController);
 	}
 
 	const EmulatorConfig& config = emu.getConfig();
@@ -200,6 +204,8 @@ void FrontendSDL::run() {
 					if (gameController == nullptr) {
 						gameController = SDL_GameControllerOpen(event.cdevice.which);
 						gameControllerID = event.cdevice.which;
+
+						setupControllerSensors(gameController);
 					}
 					break;
 
@@ -280,6 +286,21 @@ void FrontendSDL::run() {
 					}
 					break;
 				}
+									
+				case SDL_CONTROLLERSENSORUPDATE: {
+					if (event.csensor.sensor == SDL_SENSOR_GYRO) {
+						glm::vec3 rotation = Gyro::SDL::convertRotation({
+							event.csensor.data[0],
+							event.csensor.data[1],
+							event.csensor.data[2],
+						});
+
+						hid.setPitch(s16(rotation.x));
+						hid.setRoll(s16(rotation.y));
+						hid.setYaw(s16(rotation.z));
+					}
+					break;
+				}
 
 				case SDL_DROPFILE: {
 					char* droppedDir = event.drop.file;
@@ -342,3 +363,11 @@ void FrontendSDL::run() {
 		SDL_GL_SwapWindow(window);
 	}
 }
+
+void FrontendSDL::setupControllerSensors(SDL_GameController* controller) {
+	bool haveGyro = SDL_GameControllerHasSensor(controller, SDL_SENSOR_GYRO) == SDL_TRUE;
+
+	if (haveGyro) {
+		SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
+	}
+}
\ No newline at end of file

From 520e00c5531f92bd9dca36901835bc546fbe1dd9 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 14 Aug 2024 22:57:45 +0300
Subject: [PATCH 37/38] Qt: Add controller gyroscope

---
 include/panda_qt/main_window.hpp |  1 +
 src/panda_qt/main_window.cpp     | 28 ++++++++++++++++++++++++++++
 src/panda_sdl/frontend_sdl.cpp   |  2 +-
 3 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/include/panda_qt/main_window.hpp b/include/panda_qt/main_window.hpp
index ecdbc02e..3ff16a1d 100644
--- a/include/panda_qt/main_window.hpp
+++ b/include/panda_qt/main_window.hpp
@@ -122,6 +122,7 @@ class MainWindow : public QMainWindow {
 	void showAboutMenu();
 	void initControllers();
 	void pollControllers();
+	void setupControllerSensors(SDL_GameController* controller);
 	void sendMessage(const EmulatorMessage& message);
 	void dispatchMessage(const EmulatorMessage& message);
 
diff --git a/src/panda_qt/main_window.cpp b/src/panda_qt/main_window.cpp
index 65769116..f1949da7 100644
--- a/src/panda_qt/main_window.cpp
+++ b/src/panda_qt/main_window.cpp
@@ -9,6 +9,7 @@
 
 #include "cheats.hpp"
 #include "input_mappings.hpp"
+#include "sdl_gyro.hpp"
 #include "services/dsp.hpp"
 
 MainWindow::MainWindow(QApplication* app, QWidget* parent) : QMainWindow(parent), keyboardMappings(InputMappings::defaultKeyboardMappings()) {
@@ -521,6 +522,8 @@ void MainWindow::initControllers() {
 			SDL_Joystick* stick = SDL_GameControllerGetJoystick(gameController);
 			gameControllerID = SDL_JoystickInstanceID(stick);
 		}
+
+		setupControllerSensors(gameController);
 	}
 }
 
@@ -558,6 +561,8 @@ void MainWindow::pollControllers() {
 				if (gameController == nullptr) {
 					gameController = SDL_GameControllerOpen(event.cdevice.which);
 					gameControllerID = event.cdevice.which;
+
+					setupControllerSensors(gameController);
 				}
 				break;
 
@@ -598,6 +603,29 @@ void MainWindow::pollControllers() {
 				}
 				break;
 			}
+
+			case SDL_CONTROLLERSENSORUPDATE: {
+				if (event.csensor.sensor == SDL_SENSOR_GYRO) {
+					auto rotation = Gyro::SDL::convertRotation({
+						event.csensor.data[0],
+						event.csensor.data[1],
+						event.csensor.data[2],
+					});
+
+					hid.setPitch(s16(rotation.x));
+					hid.setRoll(s16(rotation.y));
+					hid.setYaw(s16(rotation.z));
+				}
+				break;
+			}
 		}
 	}
 }
+
+void MainWindow::setupControllerSensors(SDL_GameController* controller) {
+	bool haveGyro = SDL_GameControllerHasSensor(controller, SDL_SENSOR_GYRO) == SDL_TRUE;
+
+	if (haveGyro) {
+		SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
+	}
+}
\ No newline at end of file
diff --git a/src/panda_sdl/frontend_sdl.cpp b/src/panda_sdl/frontend_sdl.cpp
index 703fb1c7..8f9f4240 100644
--- a/src/panda_sdl/frontend_sdl.cpp
+++ b/src/panda_sdl/frontend_sdl.cpp
@@ -289,7 +289,7 @@ void FrontendSDL::run() {
 									
 				case SDL_CONTROLLERSENSORUPDATE: {
 					if (event.csensor.sensor == SDL_SENSOR_GYRO) {
-						glm::vec3 rotation = Gyro::SDL::convertRotation({
+						auto rotation = Gyro::SDL::convertRotation({
 							event.csensor.data[0],
 							event.csensor.data[1],
 							event.csensor.data[2],

From ff7e0f9ca88e10900a3132c8e646aecaee688760 Mon Sep 17 00:00:00 2001
From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com>
Date: Wed, 14 Aug 2024 23:41:48 +0300
Subject: [PATCH 38/38] Optimize gyro calculation

---
 include/sdl_gyro.hpp | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/include/sdl_gyro.hpp b/include/sdl_gyro.hpp
index 17faab94..e2df18df 100644
--- a/include/sdl_gyro.hpp
+++ b/include/sdl_gyro.hpp
@@ -8,13 +8,10 @@
 namespace Gyro::SDL {
 	// Convert the rotation data we get from SDL sensor events to rotation data we can feed right to HID
 	// Returns [pitch, roll, yaw]
-	static glm::vec3 convertRotation(glm::vec3 rotation) { 
-		// Flip axes
-		glm::vec3 ret = -rotation;
-		// Convert from radians/s to deg/s and scale by the gyroscope coefficient from the HID service
-		ret *= 180.f / std::numbers::pi;
-		ret *= HIDService::gyroscopeCoeff;
-
-		return ret;
+	static glm::vec3 convertRotation(glm::vec3 rotation) {
+		// Convert the rotation from rad/s to deg/s and scale by the gyroscope coefficient in HID
+		constexpr float scale = 180.f / std::numbers::pi * HIDService::gyroscopeCoeff;
+		// The axes are also inverted, so invert scale before the multiplication.
+		return rotation * -scale;
 	}
 }  // namespace Gyro::SDL
\ No newline at end of file