Merge branch 'wheremyfoodat:master' into master

.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

.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

.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

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/)
@@ -255,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(
@@ -502,7 +508,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)

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]);
 			}
 		}
 	};

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];
 	};

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,
@@ -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);
@@ -156,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);

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("") {}

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;

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;
@@ -142,7 +144,7 @@ namespace Audio {
 			} else if (counter1 == 0xffff && counter0 != 0xfffe) {
 				return 0;
 			} else {
-				return counter0 > counter1 ? 0 : 0;
+				return (counter0 > counter1) ? 0 : 1;
 			}
 		}
 
@@ -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(); }
 

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(); }
 

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);
 		}

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,
@@ -85,13 +94,16 @@ namespace Crypto {
 
 	class AESEngine {
 	  private:
-		constexpr static std::size_t AesKeySlotCount = 0x40;
+		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;
+
+		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();
@@ -104,10 +116,14 @@ namespace Crypto {
 	  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 +131,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 +148,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 +165,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);
 	};
-}
+}  // namespace Crypto

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";

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;

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;

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

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;
@@ -116,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);
 
@@ -133,6 +140,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;
@@ -141,4 +149,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);
 };

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;

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;
 	
@@ -35,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);
 };

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;
 

include/sdl_gyro.hpp

@@ -0,0 +1,17 @@
+#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) {
+		// 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

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)

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)

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)

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;

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)
@@ -35,6 +37,7 @@ class BOSSService {
 	void unregisterTask(u32 messagePointer);
 
 	s8 optoutFlag;
+
   public:
 	BOSSService(Memory& mem) : mem(mem) {}
 	void reset();

include/services/cam.hpp

@@ -12,6 +12,7 @@
 class Kernel;
 
 class CAMService {
+	using Handle = HorizonHandle;
 	using Event = std::optional<Handle>;
 
 	struct Port {

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;

include/services/cfg.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <cstring>
+
 #include "helpers.hpp"
 #include "logger.hpp"
 #include "memory.hpp"
@@ -7,6 +8,8 @@
 #include "result/result.hpp"
 
 class CFGService {
+	using Handle = HorizonHandle;
+
 	Memory& mem;
 	CountryCodes country = CountryCodes::US;  // Default to USA
 	MAKE_LOG_FUNCTION(log, cfgLogger)

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; }
 };

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)

include/services/dsp.hpp

@@ -14,6 +14,8 @@
 class Kernel;
 
 class DSPService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::DSP;
 	Memory& mem;
 	Kernel& kernel;

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)
 

include/services/fs.hpp

@@ -16,6 +16,8 @@
 class Kernel;
 
 class FSService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::FS;
 	Memory& mem;
 	Kernel& kernel;

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;

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)

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;
@@ -86,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);

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)

include/services/ir_user.hpp

@@ -11,6 +11,8 @@
 class Kernel;
 
 class IRUserService {
+	using Handle = HorizonHandle;
+
 	enum class DeviceID : u8 {
 		CirclePadPro = 1,
 	};

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;

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)

include/services/mic.hpp

@@ -9,6 +9,8 @@
 class Kernel;
 
 class MICService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::MIC;
 	Memory& mem;
 	Kernel& kernel;

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;

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)

include/services/nfc.hpp

@@ -12,6 +12,8 @@
 class Kernel;
 
 class NFCService {
+	using Handle = HorizonHandle;
+
 	Handle handle = KernelHandles::NFC;
 	Memory& mem;
 	Kernel& kernel;

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)

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;

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;

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)

include/services/ssl.hpp

@@ -1,12 +1,14 @@
 #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)

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,7 +46,7 @@ class Y2RService {
 		None = 0,
 		Rotate90 = 1,
 		Rotate180 = 2,
-		Rotate270 = 3
+		Rotate270 = 3,
 	};
 
 	enum class BlockAlignment : u32 {

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,20 +137,214 @@ 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;
 
+	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::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::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;
+			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) {

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,9 +26,8 @@ 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];
 	};
 )";
@@ -72,11 +73,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);
@@ -661,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 {
@@ -673,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);";

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);
 		}
 
@@ -754,3 +757,32 @@ 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];
+		}
+	}
+}

src/core/audio/hle_core.cpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <thread>
 #include <utility>
 
@@ -94,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);
@@ -102,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) {
@@ -110,7 +114,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) {
@@ -216,6 +220,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];
@@ -231,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;
@@ -247,6 +255,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;
@@ -266,16 +285,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;
@@ -285,7 +294,14 @@ 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;
+
 			config.embeddedBufferDirty = 0;
 			if (s32(config.length) >= 0) [[likely]] {
 				// TODO: Add sample format and channel count
@@ -297,7 +313,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,
@@ -316,8 +332,40 @@ namespace Audio {
 		}
 
 		if (config.bufferQueueDirty) {
+			// printf("Buffer queue dirty for voice %d\n", source.index);
+
+			u16 dirtyBuffers = config.buffersDirty;
 			config.bufferQueueDirty = 0;
-			printf("Buffer queue dirty for voice %d\n", source.index);
+			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.adpcm_ps),
+							.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;
@@ -369,6 +417,13 @@ namespace Audio {
 		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);
+		}
 	}
 
 	void HLE_DSP::generateFrame(DSPSource& source) {
@@ -385,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) {
@@ -398,9 +453,10 @@ 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;
 			}
 		}
@@ -568,7 +624,9 @@ namespace Audio {
 		previousBufferID = 0;
 		currentBufferID = 0;
 		syncCount = 0;
+		rateMultiplier = 1.f;
 
 		buffers = {};
+		currentSamples.clear();
 	}
 }  // namespace Audio

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);

src/core/crypto/aes_engine.cpp

@@ -1,7 +1,9 @@
-#include <iostream>
-#include <fstream>
-
 #include "crypto/aes_engine.hpp"
+
+#include <fstream>
+#include <iostream>
+#include <tuple>
+
 #include "helpers.hpp"
 
 namespace Crypto {
@@ -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;
 	}
-};
+
+	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

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");
 	}

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;

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);
 

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);
 

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) {

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);
 

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);
 

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,9 +73,27 @@ bool NCCH::loadFromHeader(Crypto::AESEngine &aesEngine, IOFile& file, const FSIn
 		if (!seedCrypto) {
 			secondaryKeyY = primaryKeyY;
 		} else {
-			Helpers::warn("Seed crypto is not supported");
+			// 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");
 				gotCryptoKeys = false;
 			}
+		}
 
 		auto primaryResult = getPrimaryKey(aesEngine, primaryKeyY);
 		auto secondaryResult = getSecondaryKey(aesEngine, secondaryKeyY);

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;
@@ -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];
@@ -945,7 +947,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 +982,6 @@ void RendererGL::clearShaderCache() {
 	for (auto& shader : shaderCache) {
 		CachedProgram& cachedProgram = shader.second;
 		cachedProgram.program.free();
-		glDeleteBuffers(1, &cachedProgram.uboBinding);
 	}
 
 	shaderCache.clear();

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]] {

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));

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 },

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;
 			}
 
@@ -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
@@ -299,6 +305,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;
 

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 (usize 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();
+}

src/panda_qt/main_window.cpp

@@ -9,15 +9,20 @@
 
 #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()), 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 +74,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 +106,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 +150,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 :(");
 	}
@@ -200,14 +205,17 @@ 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();
 	}
+}
 
+// Cleanup when the main window closes
+MainWindow::~MainWindow() {
 	delete emu;
 	delete menuBar;
 	delete aboutWindow;
@@ -360,6 +368,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 +440,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 +499,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");
@@ -497,6 +522,8 @@ void MainWindow::initControllers() {
 			SDL_Joystick* stick = SDL_GameControllerGetJoystick(gameController);
 			gameControllerID = SDL_JoystickInstanceID(stick);
 		}
+
+		setupControllerSensors(gameController);
 	}
 }
 
@@ -534,6 +561,8 @@ void MainWindow::pollControllers() {
 				if (gameController == nullptr) {
 					gameController = SDL_GameControllerOpen(event.cdevice.which);
 					gameControllerID = event.cdevice.which;
+
+					setupControllerSensors(gameController);
 				}
 				break;
 
@@ -574,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);
+	}
+}

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();
 	}

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();
@@ -35,7 +39,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 +59,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());
@@ -162,8 +166,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;
+						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);
+						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) {
@@ -195,6 +204,8 @@ void FrontendSDL::run() {
 					if (gameController == nullptr) {
 						gameController = SDL_GameControllerOpen(event.cdevice.which);
 						gameControllerID = event.cdevice.which;
+
+						setupControllerSensors(gameController);
 					}
 					break;
 
@@ -242,8 +253,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) {
@@ -271,6 +287,21 @@ void FrontendSDL::run() {
 					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;
+				}
+
 				case SDL_DROPFILE: {
 					char* droppedDir = event.drop.file;
 
@@ -289,6 +320,15 @@ void FrontendSDL::run() {
 					}
 					break;
 				}
+
+				case SDL_WINDOWEVENT: {
+					auto type = event.window.event;
+					if (type == SDL_WINDOWEVENT_RESIZED) {
+						windowWidth = event.window.data1;
+						windowHeight = event.window.data2;
+						emu.setOutputSize(windowWidth, windowHeight);
+					}
+				}
 			}
 		}
 
@@ -323,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);
+	}
+}

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
+#---------------------------------------------------------------------------------------

tests/PICA_LITP/source/main.c

@@ -0,0 +1,123 @@
+#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;
+}

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

third_party/metal-cpp

@@ -0,0 +1 @@
+Subproject commit a63bd172ddcba73a3d87ca32032b66ad41ddb9a6

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); }