Merge remote-tracking branch 'origin/main' into feature/autosave

# Conflicts:
#	src/dusk/imgui/ImGuiMenuEnhancements.cpp
#	src/dusk/settings.cpp
#	src/f_ap/f_ap_game.cpp

src/dusk/audio/DuskDsp.cpp

@@ -5,14 +5,15 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <cstdio>
 #include <span>
 
 #include "Adpcm.hpp"
 #include "freeverb/revmodel.hpp"
-#include "JSystem/JAudio2/JASDriverIF.h"
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/endian.h"
+#include "dusk/logging.h"
 #include "global.h"
 #include "tracy/Tracy.hpp"
 
@@ -95,6 +96,13 @@ static void RenderChannel(
     ChannelAuxData& channelAux,
     OutputSubframe& subframe);
 
+static void RenderOutputChannel(
+    const JASDsp::TChannel& sourceChannel,
+    ChannelAuxData& aux,
+    OutputChannel outputChannel,
+    const std::span<f32> inputSamples,
+    OutputSubframe& fullOutputSubframe);
+
 /**
  * Converts a pitch value on a DSP channel to a sample rate.
  */
@@ -117,6 +125,8 @@ static void ResetChannel(JASDsp::TChannel& channel, ChannelAuxData& aux) {
     aux.resamplePos = 0.0;
     aux.resamplePrev = 0;
 
+    aux.oscPhase = 0;
+
     aux.prev_lp_out = 0.0f;
     aux.prev_lp_in = 0.0f;
 
@@ -141,6 +151,119 @@ static void MixSubframe(DspSubframe& dst, const DspSubframe& src) {
     }
 }
 
+enum class OscType : u16 {
+    SQUARE_WAVE_PW_50        = 0,
+    SAW_WAVE                 = 1,
+    SQUARE_WAVE_PW_25        = 3,
+    TRIANGLE_WAVE            = 4,
+    // idk what 5 and 6 are
+    SINE_WAVE                = 7,
+    // idk what 8 and 9 are
+    SINE_WAVE_VAR_STEP       = 10,
+    EVOLVING_HARMONIC        = 11,
+    EVOLVING_RAMP            = 12,
+};
+
+static s16 gEvolvingHarmonic[64];
+
+static void GenerateEvolvingHarmonic() {
+    static bool initialized = false;
+    if (!initialized) {
+        gEvolvingHarmonic[62] = 8191;
+        gEvolvingHarmonic[63] = 16383;
+        initialized = true;
+    }
+
+    u32 prev2 = (u32)gEvolvingHarmonic[62];
+    u32 prev1 = (u32)gEvolvingHarmonic[63];
+
+    for (int i = 0; i < 64; i += 2) {
+        u32 cur = (u32)gEvolvingHarmonic[i];
+        gEvolvingHarmonic[i] = (s16)((s32)(prev2 * prev1 - (cur << 16)) >> 16);
+        prev2 = prev1;
+        prev1 = cur;
+
+        cur = (u32)gEvolvingHarmonic[i + 1];
+        gEvolvingHarmonic[i + 1] = (s16)((s32)(2u * (prev2 * prev1 + (cur << 16))) >> 16);
+        prev2 = prev1;
+        prev1 = cur;
+    }
+}
+
+
+static void RenderOscChannel(
+    JASDsp::TChannel& channel,
+    ChannelAuxData& channelAux,
+    OutputSubframe& subframe) {
+    if (channel.mResetFlag)
+        ResetChannel(channel, channelAux);
+
+    const u32 pitch = channel.mPitch;
+    DspSubframe buf = {};
+    const auto oscType = static_cast<OscType>(channel.mBytesPerBlock);
+
+    switch (oscType) {
+    case OscType::SQUARE_WAVE_PW_50: {
+        std::generate(buf.begin(), buf.end(), [&] {
+            f32 s = channelAux.oscPhase < 0x8000u ? 0.5f : -0.5f;
+            channelAux.oscPhase += pitch >> 1;
+            return s;
+        });
+        break;
+    }
+    case OscType::SQUARE_WAVE_PW_25: {
+        std::generate(buf.begin(), buf.end(), [&] {
+            f32 s = channelAux.oscPhase < 0x4000u ? 0.5f : -0.5f;
+            channelAux.oscPhase += pitch >> 1;
+            return s;
+        });
+        break;
+    }
+    case OscType::SAW_WAVE:
+    case OscType::EVOLVING_RAMP: {
+        std::generate(buf.begin(), buf.end(), [&] {
+            f32 s = (f32)(s16)channelAux.oscPhase / 32768.0f;
+            channelAux.oscPhase += pitch >> 1;
+            return s;
+        });
+        break;
+    }
+    case OscType::SINE_WAVE:
+    case OscType::SINE_WAVE_VAR_STEP: {
+        std::generate(buf.begin(), buf.end(), [&] {
+            f32 s = sinf((f32)channelAux.oscPhase * (2.0f * M_PI / 65536.0f)) * 0.5f;
+            channelAux.oscPhase += pitch >> 1;
+            return s;
+        });
+        break;
+    }
+    case OscType::TRIANGLE_WAVE: {
+        std::generate(buf.begin(), buf.end(), [&] {
+            f32 s = 0.5f - fabsf((f32)(s16)channelAux.oscPhase / 32768.0f);
+            channelAux.oscPhase += pitch >> 1;
+            return s;
+        });
+        break;
+    }
+    case OscType::EVOLVING_HARMONIC: {
+        std::generate(buf.begin(), buf.end(), [&] {
+            f32 s = gEvolvingHarmonic[channelAux.oscPhase >> 10] / 32768.0f;
+            channelAux.oscPhase += pitch >> 1;
+            return s;
+        });
+        break;
+    }
+    default:
+        DuskLog.error("RenderOscChannel: unimplemented oscillator type {}", channel.mBytesPerBlock);
+        break;
+    }
+
+    auto samples = std::span(buf).subspan(0, DSP_SUBFRAME_SIZE);
+    RenderOutputChannel(channel, channelAux, OutputChannel::LEFT,  samples, subframe);
+    RenderOutputChannel(channel, channelAux, OutputChannel::RIGHT, samples, subframe);
+}
+
+
 void dusk::audio::DspRender(OutputSubframe& subframe) {
     ZoneScoped;
     if (DumpAudio != sDumpWasActive) {
@@ -152,6 +275,8 @@ void dusk::audio::DspRender(OutputSubframe& subframe) {
         }
     }
 
+    GenerateEvolvingHarmonic();
+
     std::span channels(JASDsp::CH_BUF, DSP_CHANNELS);
 
     DspSubframe reverbInputL = {};
@@ -174,17 +299,14 @@ void dusk::audio::DspRender(OutputSubframe& subframe) {
             channel.mIsFinished = true;
             continue;
         }
-        else if (channel.mWaveAramAddress == 0) {
-            // I think these are oscillator channels? Not backed by audio.
-            // No idea how to implement these yet, so skip them.
-            channel.mIsFinished = true;
-            continue;
-        }
-
-        ValidateChannel(channel);
 
         OutputSubframe channelSubframe = {};
-        RenderChannel(channel, channelAux, channelSubframe);
+        if (channel.mWaveAramAddress == 0) {
+            RenderOscChannel(channel, channelAux, channelSubframe);
+        } else {
+            ValidateChannel(channel);
+            RenderChannel(channel, channelAux, channelSubframe);
+        }
 
         if (EnableReverb) {
             // scale the input to the reverb rather than using wet/dry on the output.

src/dusk/audio/DuskDsp.hpp

@@ -53,6 +53,9 @@ namespace dusk::audio {
         // last consumed sample from decodeBuf
         s16 resamplePrev;
 
+        // phase of oscillator channels
+        u16 oscPhase;
+
         // low pass previous state
         f32 prev_lp_out;  // out[n-1]
         f32 prev_lp_in;   // in[n-1]

src/dusk/autosave.cpp

@@ -0,0 +1,85 @@
+#include "dusk/autosave.h"
+#include "imgui/ImGuiConsole.hpp"
+
+u8 mSaveBuffer[QUEST_LOG_SIZE * 3];
+u8 mAutoSaveProc = 0;
+int autoSaveWriteState = 0;
+
+typedef void (*AutoSaveFuncs)();
+static AutoSaveFuncs AutoSaveFuncsProc[] = {
+    noAutoSave, enterAutoSave, autoSaving, waitingForWrite, endAutoSave,
+};
+
+void noAutoSave() {}
+
+void triggerAutoSave() {
+    if (dusk::getSettings().game.autoSave && mAutoSaveProc == 0 &&
+        strcmp(dComIfGp_getStartStageName(), "F_SP102") != 0 && dComIfGp_getStartStageLayer() != 0)
+    {
+        mAutoSaveProc = 1;
+    }
+}
+
+void updateAutoSave() {
+    (AutoSaveFuncsProc[mAutoSaveProc])();
+}
+
+void writeAutoSave() {
+    dComIfGs_setMemoryToCard(mSaveBuffer, dComIfGs_getDataNum());
+    mDoMemCdRWm_SetCheckSumGameData(mSaveBuffer, dComIfGs_getDataNum());
+
+    u8* save = mSaveBuffer;
+    for (int i = 0; i < 3; i++) {
+        mDoMemCdRWm_TestCheckSumGameData(save);
+        save += QUEST_LOG_SIZE;
+    }
+
+    g_mDoMemCd_control.save(mSaveBuffer, sizeof(mSaveBuffer), 0);
+}
+
+void autoSaving() {
+    int cardState = g_mDoMemCd_control.LoadSync(mSaveBuffer, sizeof(mSaveBuffer), 0);
+    if (cardState != 0) {
+        if (cardState == 2) {
+            mAutoSaveProc = 1;
+        } else if (cardState == 1) {
+            writeAutoSave();
+            mAutoSaveProc = 3;
+        }
+    }
+}
+
+void enterAutoSave() {
+    u32 cardStatus = g_mDoMemCd_control.getStatus(0);
+
+    if (cardStatus != 14) {
+        switch (cardStatus) {
+        case 2:
+            g_mDoMemCd_control.load();
+            mAutoSaveProc = 2;
+            break;
+        case 3:
+        case 4:
+        case 5:
+            break;
+        default:
+            mAutoSaveProc = 0;
+            break;
+        }
+    }
+}
+
+void waitingForWrite() {
+    autoSaveWriteState = g_mDoMemCd_control.SaveSync();
+
+    if (autoSaveWriteState == 2) {
+        mAutoSaveProc = 0;
+    } else if (autoSaveWriteState == 1) {
+        mAutoSaveProc = 4;
+    }
+}
+
+void endAutoSave() {
+    dusk::g_imguiConsole.ShowToast("Saving...", 2.0f);
+    mAutoSaveProc = 0;
+}

src/dusk/config.cpp

@@ -10,7 +10,7 @@
 #include <limits>
 #include <string>
 
-#include "dusk/dusk.h"
+#include "dusk/main.h"
 
 using namespace dusk::config;
 
@@ -24,7 +24,7 @@ static absl::flat_hash_map<std::string_view, ConfigVarBase*> RegisteredConfigVar
 static bool RegistrationDone = false;
 
 static std::string GetConfigJsonPath() {
-    return fmt::format("{}{}", configPath, ConfigFileName);
+    return (dusk::ConfigPath / ConfigFileName).string();
 }
 
 ConfigVarBase::ConfigVarBase(const char* name, const ConfigImplBase* impl) : name(name), registered(false), layer(ConfigVarLayer::Default), impl(impl) {

src/dusk/crash_reporting.cpp

@@ -3,6 +3,7 @@
 #include "dusk/app_info.hpp"
 #include "dusk/dusk.h"
 #include "dusk/logging.h"
+#include "dusk/main.h"
 #include "dusk/settings.h"
 #include "version.h"
 
@@ -66,7 +67,7 @@ std::string GetReleaseName() {
 }
 
 std::filesystem::path GetSentryDatabasePath() {
-    return std::filesystem::path(configPath) / "sentry";
+    return dusk::ConfigPath / "sentry";
 }
 
 std::filesystem::path GetLogAttachmentPath() {

src/dusk/extras.c

@@ -3,6 +3,27 @@
 #include <string.h>
 #include <stdint.h>
 
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+void __dcbz(void* addr, int offset) {
+    // Gekko cache lines are 32 bytes.
+    // dcbz usually requires addr to be 32-byte aligned.
+    memset((char*)addr + offset, 0, 32);
+}
+
+int __cntlzw(unsigned int val) {
+    if (val == 0) return 32; // PowerPC returns 32 if the input is 0
+#ifdef _MSC_VER
+    unsigned long idx;
+    _BitScanReverse(&idx, val);
+    return 31 - (int)idx;
+#else
+    return __builtin_clz(val);
+#endif
+}
+
 #ifndef _MSC_VER
 int stricmp(const char* str1, const char* str2) {
 	char a_var;
@@ -48,11 +69,6 @@ int strnicmp(const char* str1, const char* str2, int n) {
 }
 #endif
 
-
-void *_memcpy(void* dest, void const* src, int n) {
-    return memcpy(dest, src, n);
-}
-
 void DCZeroRange(void* addr, uint32_t nBytes) {
 #if defined(_MSC_VER) || TARGET_ANDROID
     memset(addr, 0, nBytes);

src/dusk/extras.cpp

@@ -1,27 +0,0 @@
-// C++ Mangled version of extras.c
-#include <cstring>
-#include <cstdint>
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-void *__memcpy(void* dest, void const* src, int n) {
-    return memcpy(dest, src, n);
-}
-
-void __dcbz(void* addr, int offset) {
-    // Gekko cache lines are 32 bytes.
-    // dcbz usually requires addr to be 32-byte aligned.
-    memset((char*)addr + offset, 0, 32); 
-}
-
-int __cntlzw(unsigned int val) {
-    if (val == 0) return 32; // PowerPC returns 32 if the input is 0
-#ifdef _MSC_VER
-    unsigned long idx;
-    _BitScanReverse(&idx, val);
-    return 31 - (int)idx;
-#else
-    return __builtin_clz(val);
-#endif
-}

src/dusk/frame_interpolation.cpp

@@ -127,14 +127,20 @@ void ensure_initialized() {
     s_initialized = true;
 }
 
+void begin_sim_tick() {
+    ensure_initialized();
+    if (!g_enabled) {
+        return;
+    }
+
+    s_interpolationCallBackWork.clear();
+    s_cam_prev = std::move(s_cam_curr);
+}
+
 void begin_frame(bool enabled, bool is_sim_frame, float step) {
     g_enabled = enabled;
     g_is_sim_frame = is_sim_frame;
     g_step = std::clamp(step, 0.0f, 1.0f);
-    if (is_sim_frame) {
-        s_interpolationCallBackWork.clear();
-        s_cam_prev = std::move(s_cam_curr);
-    }
 }
 
 bool is_enabled() {
@@ -408,10 +414,8 @@ void begin_presentation_camera() {
     }
 
     mDoLib_clipper::setup(view->fovy, view->aspect, view->near_, far_);
-    
-#if WIDESCREEN_SUPPORT
-    mDoGph_gInf_c::offWideZoom();
-#endif
+
+    // FRAME INTERP NOTE: Removed the call to offWideZoom that was here, it causes problems with presentation during cutscenes.
 
     s_presentation_depth = 1;
 

src/dusk/game_clock.cpp

@@ -5,62 +5,84 @@
 #include <cmath>
 #include <unordered_map>
 
-namespace dusk {
-namespace game_clock {
+namespace dusk::game_clock {
 
 using clock = std::chrono::steady_clock;
 
 bool s_initialized = false;
 clock::time_point s_previous_sample{};
-float s_sim_accumulator = 0.0f;
+clock::time_point s_current_snapshot_time{};
 
 std::unordered_map<uintptr_t, clock::time_point> s_interval_last_sample;
 
+constexpr clock::duration kSimPeriodDuration =
+    std::chrono::duration_cast<clock::duration>(std::chrono::duration<float>(sim_pace()));
+constexpr clock::duration kAbnormalGapResetThreshold = std::chrono::milliseconds(250);
+constexpr int kMaxSimTicksPerFrame = 2;
+
 void ensure_initialized() {
     if (s_initialized) {
         return;
     }
     s_previous_sample = clock::now();
-    s_sim_accumulator = sim_pace();
+    s_current_snapshot_time = s_previous_sample;
     s_initialized = true;
 }
 
-void reset_accumulator() {
-    ensure_initialized();
-    s_sim_accumulator = fmodf(s_sim_accumulator, sim_pace());
-}
-
 void reset_frame_timer() {
     s_previous_sample = clock::now();
-    s_sim_accumulator = 0.0f;
+    s_current_snapshot_time = s_previous_sample - kSimPeriodDuration;
 }
 
 MainLoopPacer advance_main_loop() {
     ensure_initialized();
 
     const clock::time_point now = clock::now();
-    const float presentation_dt = std::chrono::duration<float>(now - s_previous_sample).count();
+    const clock::duration frame_gap = now - s_previous_sample;
+    const float presentation_dt = std::chrono::duration<float>(frame_gap).count();
     s_previous_sample = now;
 
-    s_sim_accumulator += presentation_dt;
-
     MainLoopPacer out{};
     out.presentation_dt_seconds = presentation_dt;
 
-    const bool should_interpolate = dusk::getSettings().game.enableFrameInterpolation && !dusk::getTransientSettings().skipFrameRateLimit;
+    const bool should_interpolate = dusk::getSettings().game.enableFrameInterpolation &&
+                                    !dusk::getTransientSettings().skipFrameRateLimit;
     out.is_interpolating = should_interpolate;
     out.sim_pace = sim_pace();
 
     if (!should_interpolate) {
-        s_sim_accumulator = 0.0f;
-        out.do_sim_tick = true;
-        out.interpolation_step = 0.0f;
-        return out;
-    } else {
-        out.do_sim_tick = s_sim_accumulator >= sim_pace();
-        out.interpolation_step = out.do_sim_tick ? 0.0f : s_sim_accumulator / sim_pace();
+        s_current_snapshot_time = now;
+        out.sim_ticks_to_run = 1;
         return out;
     }
+
+    if (frame_gap > kAbnormalGapResetThreshold) {
+        s_current_snapshot_time = now - kSimPeriodDuration;
+        out.sim_ticks_to_run = 0;
+        return out;
+    }
+
+    int sim_ticks_to_run = 0;
+    clock::time_point projected_snapshot_time = s_current_snapshot_time;
+    const clock::time_point render_time = now - kSimPeriodDuration;
+    while (sim_ticks_to_run < kMaxSimTicksPerFrame && projected_snapshot_time < render_time) {
+        projected_snapshot_time += kSimPeriodDuration;
+        sim_ticks_to_run++;
+    }
+    out.sim_ticks_to_run = sim_ticks_to_run;
+    return out;
+}
+
+void commit_sim_tick() {
+    ensure_initialized();
+    s_current_snapshot_time += kSimPeriodDuration;
+}
+
+float sample_interpolation_step() {
+    ensure_initialized();
+    const float step =
+        std::chrono::duration<float>(clock::now() - s_current_snapshot_time).count() / sim_pace();
+    return std::clamp(step, 0.0f, 1.0f);
 }
 
 float consume_interval(const void* consumer) {
@@ -78,5 +100,4 @@ float consume_interval(const void* consumer) {
     return dt;
 }
 
-}  // namespace game_clock
-}  // namespace dusk
+}  // namespace dusk::game_clock

src/dusk/gamepad_color.cpp

@@ -0,0 +1,106 @@
+#include <cmath>
+#include <SSystem/SComponent/c_xyz.h>
+#include <d/d_com_inf_game.h>
+#include <d/actor/d_a_player.h>
+#include <d/actor/d_a_alink.h>
+#include <dusk/gamepad_color.h>
+
+cXyz currentGamepadColor = {0, 0, 0};
+cXyz finalGamepadColor = {0, 0, 0};
+cXyz additionalGamepadColor = {0, 0, 0};
+
+float lerpSpeed = 0.0f;
+
+const cXyz duskColor = {50, 50, -50};
+const cXyz noColor = {0, 0, 0};
+
+cXyz LerpColor(cXyz a, cXyz b, float t) {
+    return {std::lerp(a.x, b.x, t), std::lerp(a.y, b.y, t), std::lerp(a.z, b.z, t)};
+}
+
+void FadeLED(cXyz newColor, float speed) {
+    finalGamepadColor = newColor;
+    lerpSpeed = speed / 30.0f;
+}
+
+void SetLED(cXyz newColor) {
+    currentGamepadColor = newColor;
+    finalGamepadColor = newColor;
+}
+
+void SetGamepadAdditionalColor(cXyz addColor) {
+    additionalGamepadColor.x = addColor.x;
+    additionalGamepadColor.y = addColor.y;
+    additionalGamepadColor.z = addColor.z;
+}
+
+void handleGamepadColor() {
+    bool setColor = false;
+
+    fopAc_ac_c* zhint = dComIfGp_att_getZHint();
+    if (zhint != NULL) {
+        FadeLED({50, 50, 175}, 2.0f);
+        setColor = true;
+    }
+
+    daPy_py_c* player = daPy_getPlayerActorClass();
+    daAlink_c* link = daAlink_getAlinkActorClass();
+
+    if (link != nullptr && !setColor) {
+        if (link->checkWolf()) {
+            FadeLED({115, 115, 75}, 5.0f);
+            setColor = true;
+        } else {
+            switch (dComIfGs_getSelectEquipClothes()) {
+            case dItemNo_WEAR_KOKIRI_e:
+                FadeLED({0, 100, 0}, 5.0f);
+                setColor = true;
+                break;
+            case dItemNo_WEAR_ZORA_e:
+                FadeLED({0, 0, 100}, 5.0f);
+                setColor = true;
+                break;
+            case dItemNo_ARMOR_e:
+                if (link->checkMagicArmorHeavy()) {
+                    FadeLED({5, 100, 100}, 5.0f);
+                } else {
+                    FadeLED({100, 0, 5}, 5.0f);
+                }
+                setColor = true;
+                break;
+            case dItemNo_WEAR_CASUAL_e:
+                FadeLED({235, 230, 115}, 5.0f);
+                setColor = true;
+                break;
+            }
+        }
+    }
+
+    if (dKy_darkworld_check()) {
+        SetGamepadAdditionalColor(duskColor);
+    } else {
+        SetGamepadAdditionalColor(noColor);
+    }
+
+    f32 finalRed = finalGamepadColor.x + additionalGamepadColor.x;
+    f32 finalGreen = finalGamepadColor.y + additionalGamepadColor.y;
+    f32 finalBlue = finalGamepadColor.z + additionalGamepadColor.z;
+
+    if (finalRed > 255)
+        finalRed = 255;
+    if (finalRed < 0)
+        finalRed = 0;
+
+    if (finalGreen > 255)
+        finalGreen = 255;
+    if (finalGreen < 0)
+        finalGreen = 0;
+
+    if (finalBlue > 255)
+        finalBlue = 255;
+    if (finalBlue < 0)
+        finalBlue = 0;
+
+    currentGamepadColor = LerpColor(currentGamepadColor, cXyz{finalRed, finalGreen, finalBlue}, lerpSpeed);
+    PADSetColor(PAD_CHAN0, (u8)currentGamepadColor.x, (u8)currentGamepadColor.y, (u8)currentGamepadColor.z);
+}

src/dusk/gyro.cpp

@@ -1,16 +1,29 @@
 #include "dusk/gyro.h"
 #include "d/actor/d_a_alink.h"
+#include <cmath>
 
 namespace dusk::gyro {
 namespace {
-constexpr s32   kRollgoalTableMaxOffset = 12000;
+constexpr s32   kRollgoalTableMaxOffset = 6500;
 constexpr float kGyroEmaAlphaMin = 0.05f;
 constexpr float kGyroEmaAlphaMax = 1.0f;
+// Smooth gravity separately so the yaw/roll blend doesn't twitch with raw accel noise.
+constexpr float kGravityEmaAlpha = 0.1f;
+constexpr float kMinGravityProjection = 0.2f;
+// Let roll contribute more strongly as the pad approaches an upright posture.
+constexpr float kRollAimBoostMax = 2.0f;
 
 bool  s_sensor_enabled        = false;
+bool  s_accel_enabled         = false;
+bool  s_was_aiming            = false;
+bool  s_have_gravity_baseline = false;
 float s_smooth_gx             = 0.0f;
 float s_smooth_gy             = 0.0f;
 float s_smooth_gz             = 0.0f;
+float s_gravity_y             = 0.0f;
+float s_gravity_z             = 0.0f;
+float s_baseline_gravity_y    = 0.0f;
+float s_baseline_gravity_z    = 0.0f;
 float s_yaw_rad               = 0.0f;
 float s_pitch_rad             = 0.0f;
 float s_roll_rad              = 0.0f;
@@ -19,6 +32,10 @@ s32   s_rollgoal_az           = 0;
 
 void reset_filter_state() {
     s_smooth_gx = s_smooth_gy = s_smooth_gz = 0.0f;
+    s_gravity_y = s_gravity_z = 0.0f;
+    s_baseline_gravity_y = s_baseline_gravity_z = 0.0f;
+    s_was_aiming = false;
+    s_have_gravity_baseline = false;
     s_yaw_rad = s_pitch_rad = s_roll_rad = 0.0f;
     s_rollgoal_ax = s_rollgoal_az = 0;
 }
@@ -49,15 +66,30 @@ bool queryGyroAimContext() {
 }
 
 void read(float dt) {
-    if (!s_sensor_keep_alive && !queryGyroAimContext()) {
+    const bool aim_active = queryGyroAimContext();
+    const bool aim_just_started = aim_active && !s_was_aiming;
+    const bool aim_just_ended = !aim_active && s_was_aiming;
+    s_was_aiming = aim_active;
+
+    if (!s_sensor_keep_alive && !aim_active) {
         if (s_sensor_enabled) {
             PADSetSensorEnabled(PAD_CHAN0, PAD_SENSOR_GYRO, FALSE);
             s_sensor_enabled = false;
         }
+        if (s_accel_enabled) {
+            PADSetSensorEnabled(PAD_CHAN0, PAD_SENSOR_ACCEL, FALSE);
+            s_accel_enabled = false;
+        }
         reset_filter_state();
         return;
     }
 
+    if (aim_just_started || aim_just_ended) {
+        s_gravity_y = s_gravity_z = 0.0f;
+        s_baseline_gravity_y = s_baseline_gravity_z = 0.0f;
+        s_have_gravity_baseline = false;
+    }
+
     if (!s_sensor_enabled) {
         if (!PADHasSensor(PAD_CHAN0, PAD_SENSOR_GYRO)) {
             return;
@@ -68,6 +100,13 @@ void read(float dt) {
         s_sensor_enabled = true;
     }
 
+    if (!s_accel_enabled && PADHasSensor(PAD_CHAN0, PAD_SENSOR_ACCEL) &&
+        PADSetSensorEnabled(PAD_CHAN0, PAD_SENSOR_ACCEL, TRUE))
+    {
+        // We only need accel for the gravity-aware yaw/roll mix.
+        s_accel_enabled = true;
+    }
+
     f32 gyro[3];
     if (!PADGetSensorData(PAD_CHAN0, PAD_SENSOR_GYRO, gyro, 3)) {
         return;
@@ -80,9 +119,50 @@ void read(float dt) {
     s_smooth_gy += smooth_alpha * (gyro[1] - s_smooth_gy);
     s_smooth_gz += smooth_alpha * (gyro[2] - s_smooth_gz);
 
-    s_pitch_rad = -apply_deadband(s_smooth_gx, deadband) * dt * dusk::getSettings().game.gyroSensitivityX;
-    s_yaw_rad   = apply_deadband(s_smooth_gy, deadband) * dt * dusk::getSettings().game.gyroSensitivityY;
-    s_roll_rad  = apply_deadband(s_smooth_gz, deadband) * dt * dusk::getSettings().game.gyroSensitivityX; // GYRO NOTE: Exposing Z sensitivity seems unusual, so I'm just using X
+    const float pitch_rate = apply_deadband(s_smooth_gx, deadband);
+    const float yaw_rate = apply_deadband(s_smooth_gy, deadband);
+    const float roll_rate = apply_deadband(s_smooth_gz, deadband);
+
+    s_pitch_rad = -pitch_rate * dt * dusk::getSettings().game.gyroSensitivityX;
+    s_roll_rad  = roll_rate * dt * dusk::getSettings().game.gyroSensitivityX; // GYRO NOTE: Exposing Z sensitivity seems unusual, so I'm just using X
+
+    float horizontal_rate = yaw_rate;
+    if (aim_active && s_accel_enabled) {
+        f32 accel[3];
+        if (PADGetSensorData(PAD_CHAN0, PAD_SENSOR_ACCEL, accel, 3)) {
+            if (!s_have_gravity_baseline) {
+                s_gravity_y = accel[1];
+                s_gravity_z = accel[2];
+            } else {
+                s_gravity_y += kGravityEmaAlpha * (accel[1] - s_gravity_y);
+                s_gravity_z += kGravityEmaAlpha * (accel[2] - s_gravity_z);
+            }
+
+            // Compare the current gravity projection against the gravity vector from
+            // aim start so the user's resting hold angle becomes the neutral baseline.
+            const float gravity_yz_len = std::sqrt((s_gravity_y * s_gravity_y) + (s_gravity_z * s_gravity_z));
+            if (gravity_yz_len >= kMinGravityProjection) {
+                const float current_gravity_y = s_gravity_y / gravity_yz_len;
+                const float current_gravity_z = s_gravity_z / gravity_yz_len;
+
+                if (!s_have_gravity_baseline) {
+                    s_baseline_gravity_y = current_gravity_y;
+                    s_baseline_gravity_z = current_gravity_z;
+                    s_have_gravity_baseline = true;
+                }
+
+                const float yaw_weight =
+                    (s_baseline_gravity_y * current_gravity_y) + (s_baseline_gravity_z * current_gravity_z);
+                const float roll_weight =
+                    (s_baseline_gravity_y * current_gravity_z) - (s_baseline_gravity_z * current_gravity_y);
+                const float roll_mix = std::fabs(roll_weight);
+                const float roll_boost = 1.0f + (roll_mix * (kRollAimBoostMax - 1.0f));
+                horizontal_rate = (yaw_rate * yaw_weight) + (roll_rate * roll_weight * roll_boost);
+            }
+        }
+    }
+
+    s_yaw_rad = horizontal_rate * dt * dusk::getSettings().game.gyroSensitivityY;
 
     s_pitch_rad = dusk::getSettings().game.gyroInvertPitch ? -s_pitch_rad : s_pitch_rad;
     s_yaw_rad = dusk::getSettings().game.gyroInvertYaw ? -s_yaw_rad : s_yaw_rad;

src/dusk/imgui/ImGuiConsole.cpp

@@ -305,6 +305,10 @@ namespace dusk {
             ImGuiMenuGame::ToggleFullscreen();
         }
 
+        if (ImGui::IsKeyPressed(ImGuiKey_Escape) && getSettings().video.enableFullscreen) {
+            ImGuiMenuGame::ToggleFullscreen();
+        }
+
         if (!dusk::IsGameLaunched) {
             m_preLaunchWindow.draw();
         }
@@ -319,9 +323,11 @@ namespace dusk {
             }
         }
 
+        // The menu bar renders with ImGuiCol_WindowBg behind it. We just want ImGuiCol_MenuBarBg,
+        // so make the window bg fully transparent temporarily
+        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
         if (showMenu && ImGui::BeginMainMenuBar()) {
             m_menuGame.draw();
-            m_menuEnhancements.draw();
             m_menuTools.draw();
 
             const auto fpsLabel =
@@ -336,6 +342,7 @@ namespace dusk {
 
             ImGui::EndMainMenuBar();
         }
+        ImGui::PopStyleColor();
 
         if (!getSettings().backend.wasPresetChosen) {
             m_firstRunPreset.draw();

src/dusk/imgui/ImGuiConsole.hpp

@@ -9,7 +9,6 @@
 #include <SDL3/SDL_touch.h>
 
 #include "ImGuiFirstRunPreset.hpp"
-#include "ImGuiMenuEnhancements.hpp"
 #include "ImGuiMenuGame.hpp"
 #include "ImGuiMenuTools.hpp"
 #include "ImGuiPreLaunchWindow.hpp"
@@ -54,7 +53,6 @@ private:
 
     ImGuiFirstRunPreset m_firstRunPreset;
     ImGuiMenuGame m_menuGame;
-    ImGuiMenuEnhancements m_menuEnhancements;
     ImGuiPreLaunchWindow m_preLaunchWindow;
 
     // Keep always last

src/dusk/imgui/ImGuiEngine.cpp

@@ -126,7 +126,7 @@ void ImGuiEngine_Initialize(float scale) {
     auto* colors = style.Colors;
     colors[ImGuiCol_Text] = ImVec4(0.95f, 0.96f, 0.98f, 1.00f);
     colors[ImGuiCol_TextDisabled] = ImVec4(0.36f, 0.42f, 0.47f, 1.00f);
-    colors[ImGuiCol_WindowBg] = ImVec4(0.11f, 0.15f, 0.17f, 1.00f);
+    colors[ImGuiCol_WindowBg] = ImVec4(0.11f, 0.15f, 0.17f, 0.98f);
     colors[ImGuiCol_ChildBg] = ImVec4(0.15f, 0.18f, 0.22f, 1.00f);
     colors[ImGuiCol_PopupBg] = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
     colors[ImGuiCol_Border] = ImVec4(0.08f, 0.10f, 0.12f, 1.00f);
@@ -137,7 +137,7 @@ void ImGuiEngine_Initialize(float scale) {
     colors[ImGuiCol_TitleBg] = ImVec4(0.09f, 0.12f, 0.14f, 0.65f);
     colors[ImGuiCol_TitleBgActive] = ImVec4(0.08f, 0.10f, 0.12f, 1.00f);
     colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.00f, 0.00f, 0.00f, 0.51f);
-    colors[ImGuiCol_MenuBarBg] = ImVec4(0.15f, 0.18f, 0.22f, 1.00f);
+    colors[ImGuiCol_MenuBarBg] = ImVec4(0.15f, 0.18f, 0.22f, 0.80f);
     colors[ImGuiCol_ScrollbarBg] = ImVec4(0.02f, 0.02f, 0.02f, 0.39f);
     colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f);
     colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.18f, 0.22f, 0.25f, 1.00f);

src/dusk/imgui/ImGuiMenuEnhancements.cpp

@@ -1,260 +0,0 @@
-#include "imgui.h"
-
-#include "ImGuiMenuEnhancements.hpp"
-#include "ImGuiConfig.hpp"
-#include "dusk/settings.h"
-
-namespace dusk {
-    ImGuiMenuEnhancements::ImGuiMenuEnhancements() {}
-
-    void ImGuiMenuEnhancements::draw() {
-        if (ImGui::BeginMenu("Enhancements")) {
-            if (ImGui::BeginMenu("Gameplay")) {
-                ImGui::SeparatorText("Preferences");
-
-                config::ImGuiCheckbox("Mirror Mode", getSettings().game.enableMirrorMode);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Mirrors the world horizontally, matching the Wii version of the game.");
-                }
-
-                config::ImGuiCheckbox("Disable Main HUD", getSettings().game.disableMainHUD);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Disables the main HUD of the game.\n"
-                                      "Useful for recording or a more immersive experience!");
-                }
-
-                ImGui::SeparatorText("Difficulty");
-
-                config::ImGuiSliderInt("Damage Multiplier", getSettings().game.damageMultiplier, 1, 8, "x%d");
-
-                config::ImGuiCheckbox("Instant Death", getSettings().game.instantDeath);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Any hit will instantly kill you.");
-                }
-
-                config::ImGuiCheckbox("No Heart Drops", getSettings().game.noHeartDrops);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Hearts will never drop from enemies,\n"
-                                      "pots and various other places.");
-                }
-
-                ImGui::SeparatorText("Quality of Life");
-
-                config::ImGuiCheckbox("Bigger Wallets", getSettings().game.biggerWallets);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Wallet sizes are like in the HD version. (500, 1000, 2000)");
-                }
-
-                config::ImGuiCheckbox("Disable Rupee Cutscenes", getSettings().game.disableRupeeCutscenes);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Rupees won't play cutscenes after you've collected them the first time.");
-                }
-
-                config::ImGuiCheckbox("Faster Climbing", getSettings().game.fastClimbing);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Quicker climbing on ladders and vines like the HD version.");
-                }
-
-                config::ImGuiCheckbox("Faster Tears of Light", getSettings().game.fastTears);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Tears of Light dropped by Shadow Insects pop out faster like the HD version.");
-                }
-
-                config::ImGuiCheckbox("Instant Saves", getSettings().game.instantSaves);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Skip the delay when writing to the Memory Card.");
-                }
-
-                config::ImGuiCheckbox("Autosave", getSettings().game.autoSave);
-                const bool autoSaveHovered = ImGui::IsItemHovered();
-                ImGui::SameLine();
-                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.72f, 0.2f, 1.0f));
-                ImGui::TextUnformatted("[EXPERIMENTAL]");
-                ImGui::PopStyleColor();
-                if (autoSaveHovered || ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip(
-                        "Automatically saves the game when going to new areas,\n"
-                        "getting an item, or opening a dungeon door.");
-                }
-
-                config::ImGuiCheckbox("Hold B for Instant Text", getSettings().game.instantText);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Make text scroll immediately by holding B.");
-                }
-
-                config::ImGuiCheckbox("No Climbing Miss Animation", getSettings().game.noMissClimbing);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Prevents Link from playing a struggle animation\n"
-                                      "when grabbing ledges or climbing on vines.");
-                }
-
-                config::ImGuiCheckbox("No Rupee Returns", getSettings().game.noReturnRupees);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Always collect Rupees even if your Wallet is too full.");
-                }
-
-                config::ImGuiCheckbox("No Sword Recoil", getSettings().game.noSwordRecoil);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Link won't recoil when his sword hits walls.");
-                }
-
-                config::ImGuiCheckbox("Skip TV Settings Screen", getSettings().game.hideTvSettingsScreen);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Skip the TV calibration screen shown when loading a save.");
-                }
-
-                config::ImGuiCheckbox("Skip Warning Screen", getSettings().game.skipWarningScreen);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Skip the warning screen shown when starting the game.");
-                }
-
-                config::ImGuiCheckbox("Sun's Song (R+X)", getSettings().game.sunsSong);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Allows Wolf Link to howl and change the time of day.");
-                }
-
-                config::ImGuiCheckbox("Quick Transform (R+Y)", getSettings().game.enableQuickTransform);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Transform instantly by pressing R and Y simultaneously.");
-                }
-
-                ImGui::EndMenu();
-            }
-
-            if (ImGui::BeginMenu("Graphics")) {
-                config::ImGuiSliderInt("Shadow Resolution", getSettings().game.shadowResolutionMultiplier, 1, 8, "x%d");
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Improves the shadow resolution, making them higher quality.");
-                }
-
-                config::ImGuiCheckbox("Unlock Framerate", getSettings().game.enableFrameInterpolation);
-                const bool frameInterpolationHovered = ImGui::IsItemHovered();
-                ImGui::SameLine();
-                ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.72f, 0.2f, 1.0f));
-                ImGui::TextUnformatted("[EXPERIMENTAL]");
-                ImGui::PopStyleColor();
-                if (frameInterpolationHovered || ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Uses inter-frame interpolation to enable higher frame rates.\nVisual artifacts, animation glitches, or instability may occur.");
-                }
-
-                ImGui::EndMenu();
-            }
-
-            if (ImGui::BeginMenu("Audio")) {
-                config::ImGuiCheckbox("No Low HP Sound", getSettings().game.noLowHpSound);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Disable the beeping sound when having low health.");
-                }
-
-                config::ImGuiCheckbox("Non-Stop Midna's Lament", getSettings().game.midnasLamentNonStop);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Prevents enemy music while Midna's Lament is playing.");
-                }
-
-                ImGui::EndMenu();
-            }
-
-            if (ImGui::BeginMenu("Input")) {
-                config::ImGuiCheckbox("Invert Camera X Axis", getSettings().game.invertCameraXAxis);
-
-                ImGui::SeparatorText("Gyro");
-
-                config::ImGuiCheckbox("Gyro Aim", getSettings().game.enableGyroAim);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Enables the gyroscope on supported controllers\n"
-                                      "while in look mode (C-Up) and while aiming the\n"
-                                      "Slingshot, Gale Boomerang, Hero's Bow, Clawshot(s),\n"
-                                      "Ball and Chain, and Dominion Rod.");
-                }
-
-                config::ImGuiCheckbox("Gyro Rollgoal", getSettings().game.enableGyroRollgoal);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Enables the gyroscope on supported controllers to\n"
-                                      "tilt the Rollgoal table in Hena's Cabin.");
-                }
-
-                if (getSettings().game.enableGyroAim || getSettings().game.enableGyroRollgoal) {
-                    config::ImGuiSliderFloat("Gyro Pitch Sensitivity", getSettings().game.gyroSensitivityY, 0.25f, 4.0f, "%.2f");
-                    config::ImGuiSliderFloat("Gyro Yaw Sensitivity", getSettings().game.gyroSensitivityX, 0.25f, 4.0f, "%.2f");
-
-                    if (getSettings().game.enableGyroRollgoal) {
-                        config::ImGuiSliderFloat("Rollgoal Sensitivity", getSettings().game.gyroSensitivityRollgoal, 0.25f, 4.0f, "%.2f");
-                        if (ImGui::IsItemHovered()) {
-                            ImGui::SetTooltip("Additional multiplier for scaling how strongly\n"
-                                              "the gyroscope affects the Rollgoal table.");
-                        }
-                    }
-
-                    config::ImGuiSliderFloat("Gyro Deadband", getSettings().game.gyroDeadband, 0.0f, 0.5f, "%.3f");
-                    if (ImGui::IsItemHovered()) {
-                        ImGui::SetTooltip("Angular rates below this magnitude are treated as zero,\n"
-                                          "reducing drift and jitter when the controller is still.");
-                    }
-
-                    config::ImGuiSliderFloat("Gyro Smoothing", getSettings().game.gyroSmoothing, 0.0f, 1.0f, "%.2f");
-                    if (ImGui::IsItemHovered()) {
-                        ImGui::SetTooltip("Low values track raw gyro input more closely,\n"
-                                          "while higher values smooth out input over time.");
-                    }
-
-                    config::ImGuiCheckbox("Invert Gyro Pitch", getSettings().game.gyroInvertPitch);
-                    config::ImGuiCheckbox("Invert Gyro Yaw", getSettings().game.gyroInvertYaw);
-                }
-
-                ImGui::SeparatorText("Tools");
-
-                config::ImGuiCheckbox("Turbo Key", getSettings().game.enableTurboKeybind);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Hold TAB to increase game speed by up to 4x.");
-                }
-
-                ImGui::EndMenu();
-            }
-
-            ImGui::Separator();
-
-            if (ImGui::BeginMenu("Cheats")) {
-                config::ImGuiCheckbox("Infinite Hearts", getSettings().game.infiniteHearts);
-                config::ImGuiCheckbox("Infinite Arrows", getSettings().game.infiniteArrows);
-                config::ImGuiCheckbox("Infinite Bombs", getSettings().game.infiniteBombs);
-                config::ImGuiCheckbox("Infinite Oil", getSettings().game.infiniteOil);
-                config::ImGuiCheckbox("Infinite Oxygen", getSettings().game.infiniteOxygen);
-                config::ImGuiCheckbox("Infinite Rupees", getSettings().game.infiniteRupees);
-                config::ImGuiCheckbox("Moon Jump (R+A)", getSettings().game.moonJump);
-                config::ImGuiCheckbox("Super Clawshot", getSettings().game.superClawshot);
-                config::ImGuiCheckbox("Always Greatspin", getSettings().game.alwaysGreatspin);
-
-                config::ImGuiCheckbox("Fast Iron Boots", getSettings().game.enableFastIronBoots);
-
-                config::ImGuiCheckbox("Can Transform Anywhere", getSettings().game.canTransformAnywhere);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Allows you to transform even if NPCs are looking.");
-                }
-
-                config::ImGuiCheckbox("Fast Spinner", getSettings().game.fastSpinner);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Speeds up Spinner movement when holding R.");
-                }
-
-                config::ImGuiCheckbox("Free Magic Armor", getSettings().game.freeMagicArmor);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Makes the magic armor work without rupees.");
-                }
-
-                ImGui::EndMenu();
-            }
-
-            if (ImGui::BeginMenu("Technical")) {
-                config::ImGuiCheckbox("Restore Wii 1.0 Glitches", getSettings().game.restoreWiiGlitches);
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Restores patched glitches from Wii USA 1.0,\n"
-                                      "the first released version.");
-                }
-
-                ImGui::EndMenu();
-            }
-
-            ImGui::EndMenu();
-        }
-    }
-}

src/dusk/imgui/ImGuiMenuEnhancements.hpp

@@ -1,18 +0,0 @@
-#ifndef DUSK_IMGUI_MENUENHANCEMENTS_HPP
-#define DUSK_IMGUI_MENUENHANCEMENTS_HPP
-
-#include <aurora/aurora.h>
-#include <pad.h>
-#include <string>
-
-#include "imgui.h"
-
-namespace dusk {
-    class ImGuiMenuEnhancements {
-    public:
-        ImGuiMenuEnhancements();
-        void draw();
-    };
-}
-
-#endif  // DUSK_IMGUI_MENUENHANCEMENTS_HPP

src/dusk/imgui/ImGuiMenuGame.cpp

@@ -5,45 +5,18 @@
 #include "ImGuiConsole.hpp"
 #include "ImGuiMenuGame.hpp"
 #include "ImGuiConfig.hpp"
-#include <imgui_internal.h>
 
 #include "JSystem/JUtility/JUTGamePad.h"
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/audio/DuskDsp.hpp"
-#include "dusk/dusk.h"
+#include "dusk/main.h"
 #include "dusk/hotkeys.h"
 #include "dusk/settings.h"
 #include "m_Do/m_Do_controller_pad.h"
 #include "m_Do/m_Do_graphic.h"
 
 #include <aurora/gfx.h>
-#include <aurora/lib/logging.hpp>
 #include <SDL3/SDL_gamepad.h>
-#include <SDL3/SDL_misc.h>
-
-#include "dusk/main.h"
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-#if defined(_WIN32) || (defined(__APPLE__) && !TARGET_OS_IOS && !TARGET_OS_MACCATALYST) || (defined(__linux__) && !defined(__ANDROID__))
-#define DUSK_CAN_OPEN_DATA_FOLDER 1
-
-namespace fs = std::filesystem;
-
-static void OpenDataFolder() {
-    const std::string path = fs::absolute(fs::path(aurora::g_config.configPath)).generic_string();
-#if defined(_WIN32)
-    const std::string url = std::string("file:///") + path;
-#else
-    const std::string url = std::string("file://") + path;
-#endif
-    (void)SDL_OpenURL(url.c_str());
-}
-#else
-#define DUSK_CAN_OPEN_DATA_FOLDER 0
-#endif
 
 namespace {
 constexpr int kInternalResolutionScaleMax = 12;
@@ -63,149 +36,13 @@ namespace dusk {
     ImGuiMenuGame::ImGuiMenuGame() {}
 
     void ImGuiMenuGame::draw() {
-        if (ImGui::BeginMenu("Game")) {
-            if (ImGui::BeginMenu("Graphics")) {
-                if (!IsMobile) {
-                    if (ImGui::MenuItem("Toggle Fullscreen", hotkeys::TOGGLE_FULLSCREEN)) {
-                        ToggleFullscreen();
-                    }
-
-                    if (ImGui::MenuItem("Default Window Size")) {
-                        getSettings().video.enableFullscreen.setValue(false);
-                        VISetWindowFullscreen(false);
-                        VISetWindowSize(FB_WIDTH * 2, FB_HEIGHT * 2);
-                        VICenterWindow();
-                    }
-                }
-
-                bool vsync = getSettings().video.enableVsync;
-                if (ImGui::Checkbox("Enable Vsync", &vsync)) {
-                    getSettings().video.enableVsync.setValue(vsync);
-                    aurora_enable_vsync(vsync);
-                    config::Save();
-                }
-
-                bool lockAspect = getSettings().video.lockAspectRatio;
-                if (ImGui::Checkbox("Force 4:3 Aspect Ratio", &lockAspect)) {
-                    getSettings().video.lockAspectRatio.setValue(lockAspect);
-
-                    if (lockAspect) {
-                        AuroraSetViewportPolicy(AURORA_VIEWPORT_FIT);
-                    } else {
-                        AuroraSetViewportPolicy(AURORA_VIEWPORT_STRETCH);
-                    }
-
-                    config::Save();
-                }
-
-                u32 internalResolutionWidth = 0;
-                u32 internalResolutionHeight = 0;
-                AuroraGetRenderSize(&internalResolutionWidth, &internalResolutionHeight);
-                ImGui::TextDisabled("Current internal resolution: %ux%u", internalResolutionWidth,
-                                    internalResolutionHeight);
-
-                int scale = std::clamp(getSettings().game.internalResolutionScale.getValue(), 0,
-                                       kInternalResolutionScaleMax);
-                if (ImGui::SliderInt("Internal Resolution", &scale, 0, kInternalResolutionScaleMax,
-                                     scale == 0 ? "Auto" : "%dx"))
-                {
-                    getSettings().game.internalResolutionScale.setValue(scale);
-                    VISetFrameBufferScale(static_cast<float>(scale));
-                    config::Save();
-                }
-                if (ImGui::IsItemHovered()) {
-                    ImGui::SetTooltip("Auto renders at the native window resolution.\n"
-                                      "Higher values scale the game's internal framebuffer.");
-                }
-
-                constexpr const char* bloomModeNames[] = {"Off", "Classic", "Dusk"};
-                int bloomMode = static_cast<int>(getSettings().game.bloomMode.getValue());
-                if (ImGui::BeginCombo("Bloom", bloomModeNames[bloomMode])) {
-                    for (int i = 0; i < IM_ARRAYSIZE(bloomModeNames); i++) {
-                        const bool selected = bloomMode == i;
-                        if (ImGui::Selectable(bloomModeNames[i], selected)) {
-                            getSettings().game.bloomMode.setValue(static_cast<BloomMode>(i));
-                            config::Save();
-                        }
-                        if (selected) {
-                            ImGui::SetItemDefaultFocus();
-                        }
-                    }
-                    ImGui::EndCombo();
-                }
-
-                bool bloomOff = bloomMode == static_cast<int>(BloomMode::Off);
-                if (bloomOff) ImGui::BeginDisabled();
-                float mult = getSettings().game.bloomMultiplier.getValue();
-                if (ImGui::SliderFloat("Bloom Brightness", &mult, 0.0f, 1.0f, "%.2f")) {
-                    getSettings().game.bloomMultiplier.setValue(mult);
-                    config::Save();
-                }
-                if (bloomOff) ImGui::EndDisabled();
-
-                ImGui::Checkbox("Enable LOD Bias", &aurora::gx::enableLodBias);
-
-                ImGui::EndMenu();
-            }
-
-            if (ImGui::BeginMenu("Audio")) {
-                ImGui::Text("Master Volume");
-                if (config::ImGuiSliderInt("##masterVolume", getSettings().audio.masterVolume, 0, 100)) {
-                    dusk::audio::SetMasterVolume(getSettings().audio.masterVolume / 100.0f);
-                }
-
-                if (config::ImGuiCheckbox("Enable Reverb", getSettings().audio.enableReverb)) {
-                    dusk::audio::SetEnableReverb(getSettings().audio.enableReverb);
-                }
-                /*
-                // TODO: Implement additional settings
-                ImGui::Text("Main Music Volume");
-                ImGui::SliderFloat("##mainMusicVolume", &getSettings().audio.mainMusicVolume, 0, 100);
-
-                ImGui::Text("Sub Music Volume");
-                ImGui::SliderFloat("##subMusicVolume", &getSettings().audio.subMusicVolume, 0, 100);
-
-                ImGui::Text("Sound Effects Volume");
-                ImGui::SliderFloat("##soundEffectsVolume", &getSettings().audio.soundEffectsVolume, 0, 100);
-
-                ImGui::Text("Fanfare Volume");
-                ImGui::SliderFloat("##fanfareVolume", &getSettings().audio.fanfareVolume, 0, 100);
-
-                Z2AudioMgr* audioMgr = Z2AudioMgr::getInterface();
-                if (audioMgr != nullptr) {
-                }
-                */
-
-                ImGui::EndMenu();
-            }
-
-            if (ImGui::BeginMenu("Controller")) {
-                ImGui::MenuItem("Configure Controller", nullptr, &m_showControllerConfig);
-                ImGui::Checkbox("Show Input Viewer", &m_showInputViewer);
-
-                ImGui::EndMenu();
-            }
-
-            if (ImGui::BeginMenu("Interface")) {
-                config::ImGuiCheckbox("Skip Pre-Launch UI", getSettings().backend.skipPreLaunchUI);
-                config::ImGuiCheckbox("Show Pipeline Compilation", getSettings().backend.showPipelineCompilation);
-#if DUSK_ENABLE_SENTRY_NATIVE
-                config::ImGuiCheckbox("Enable Crash Reporting", getSettings().backend.enableCrashReporting);
-#endif
-                if (!IsMobile) {
-                    config::ImGuiCheckbox("Pause on Focus Lost", getSettings().game.pauseOnFocusLost);
-                }
-
-                ImGui::EndMenu();
-            }
-
-            ImGui::Separator();
-
-#if DUSK_CAN_OPEN_DATA_FOLDER
-            if (ImGui::MenuItem("Open Data Folder")) {
-                OpenDataFolder();
-            }
-#endif
+        if (ImGui::BeginMenu("Settings")) {
+            drawAudioMenu();
+            drawCheatsMenu();
+            drawGameplayMenu();
+            drawGraphicsMenu();
+            drawInputMenu();
+            drawInterfaceMenu();
 
             ImGui::Separator();
 
@@ -221,6 +58,416 @@ namespace dusk {
         }
     }
 
+    void ImGuiMenuGame::drawGraphicsMenu() {
+        if (ImGui::BeginMenu("Graphics")) {
+            ImGui::SeparatorText("Display");
+
+            if (!IsMobile) {
+                if (ImGui::MenuItem("Toggle Fullscreen", hotkeys::TOGGLE_FULLSCREEN)) {
+                    ToggleFullscreen();
+                }
+
+                if (ImGui::Button("Restore Default Window Size")) {
+                    getSettings().video.enableFullscreen.setValue(false);
+                    VISetWindowFullscreen(false);
+                    VISetWindowSize(FB_WIDTH * 2, FB_HEIGHT * 2);
+                    VICenterWindow();
+                }
+            }
+
+            ImGui::Separator();
+
+            bool vsync = getSettings().video.enableVsync;
+            if (ImGui::Checkbox("Enable VSync", &vsync)) {
+                getSettings().video.enableVsync.setValue(vsync);
+                aurora_enable_vsync(vsync);
+                config::Save();
+            }
+
+            bool lockAspect = getSettings().video.lockAspectRatio;
+            if (ImGui::Checkbox("Force 4:3 Aspect Ratio", &lockAspect)) {
+                getSettings().video.lockAspectRatio.setValue(lockAspect);
+
+                if (lockAspect) {
+                    AuroraSetViewportPolicy(AURORA_VIEWPORT_FIT);
+                } else {
+                    AuroraSetViewportPolicy(AURORA_VIEWPORT_STRETCH);
+                }
+
+                config::Save();
+            }
+
+            ImGui::SeparatorText("Resolution");
+
+            u32 internalResolutionWidth = 0;
+            u32 internalResolutionHeight = 0;
+            AuroraGetRenderSize(&internalResolutionWidth, &internalResolutionHeight);
+            ImGui::TextDisabled("Current internal resolution: %ux%u", internalResolutionWidth,
+                                internalResolutionHeight);
+
+            int scale = std::clamp(getSettings().game.internalResolutionScale.getValue(), 0,
+                                   kInternalResolutionScaleMax);
+            if (ImGui::SliderInt("Internal Resolution", &scale, 0, kInternalResolutionScaleMax,
+                                 scale == 0 ? "Auto" : "%dx"))
+            {
+                getSettings().game.internalResolutionScale.setValue(scale);
+                VISetFrameBufferScale(static_cast<float>(scale));
+                config::Save();
+            }
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Auto renders at the native window resolution.\n"
+                                  "Higher values scale the game's internal framebuffer.");
+            }
+
+            config::ImGuiSliderInt("Shadow Resolution", getSettings().game.shadowResolutionMultiplier, 1, 8, "x%d");
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Improves the shadow resolution, making them higher quality.");
+            }
+
+            ImGui::SeparatorText("Post-Processing");
+
+            constexpr const char* bloomModeNames[] = {"Off", "Classic", "Dusk"};
+            int bloomMode = static_cast<int>(getSettings().game.bloomMode.getValue());
+            if (ImGui::BeginCombo("Bloom", bloomModeNames[bloomMode])) {
+                for (int i = 0; i < IM_ARRAYSIZE(bloomModeNames); i++) {
+                    const bool selected = bloomMode == i;
+                    if (ImGui::Selectable(bloomModeNames[i], selected)) {
+                        getSettings().game.bloomMode.setValue(static_cast<BloomMode>(i));
+                        config::Save();
+                    }
+                    if (selected) {
+                        ImGui::SetItemDefaultFocus();
+                    }
+                }
+                ImGui::EndCombo();
+            }
+
+            bool bloomOff = bloomMode == static_cast<int>(BloomMode::Off);
+            if (bloomOff) ImGui::BeginDisabled();
+            float mult = getSettings().game.bloomMultiplier.getValue();
+            if (ImGui::SliderFloat("Bloom Brightness", &mult, 0.0f, 1.0f, "%.2f")) {
+                getSettings().game.bloomMultiplier.setValue(mult);
+                config::Save();
+            }
+            if (bloomOff) ImGui::EndDisabled();
+
+            ImGui::SeparatorText("Rendering");
+
+            config::ImGuiCheckbox("Unlock Framerate", getSettings().game.enableFrameInterpolation);
+            const bool frameInterpolationHovered = ImGui::IsItemHovered();
+            ImGui::SameLine();
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.72f, 0.2f, 1.0f));
+            ImGui::TextUnformatted("[EXPERIMENTAL]");
+            ImGui::PopStyleColor();
+            if (frameInterpolationHovered || ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Uses inter-frame interpolation to enable higher frame rates.\nVisual artifacts, animation glitches, or instability may occur.");
+            }
+
+            ImGui::Checkbox("Enable LOD Bias", &aurora::gx::enableLodBias);
+
+            config::ImGuiCheckbox("Enable Depth of Field", getSettings().game.enableDepthOfField);
+
+            ImGui::EndMenu();
+        }
+    }
+
+    void ImGuiMenuGame::drawGameplayMenu() {
+        if (ImGui::BeginMenu("Gameplay")) {
+            ImGui::SeparatorText("General");
+
+            config::ImGuiCheckbox("Mirror Mode", getSettings().game.enableMirrorMode);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Mirrors the world horizontally, matching the Wii version of the game.");
+            }
+
+            config::ImGuiCheckbox("Disable Main HUD", getSettings().game.disableMainHUD);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Disables the main HUD of the game.\n"
+                                  "Useful for recording or a more immersive experience!");
+            }
+
+            config::ImGuiCheckbox("Restore Wii 1.0 Glitches", getSettings().game.restoreWiiGlitches);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Restores patched glitches from Wii USA 1.0,\n"
+                                  "the first released version.");
+            }
+            
+            config::ImGuiCheckbox("Enable Rotating Link Doll", getSettings().game.enableLinkDollRotation);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Enables rotating Link in the collection menu with the C-Stick");
+            }
+
+            ImGui::SeparatorText("Difficulty");
+
+            config::ImGuiSliderInt("Damage Multiplier", getSettings().game.damageMultiplier, 1, 8, "x%d");
+
+            config::ImGuiCheckbox("Instant Death", getSettings().game.instantDeath);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Any hit will instantly kill you.");
+            }
+
+            config::ImGuiCheckbox("No Heart Drops", getSettings().game.noHeartDrops);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Hearts will never drop from enemies,\n"
+                                  "pots and various other places.");
+            }
+
+            ImGui::SeparatorText("Quality of Life");
+
+            config::ImGuiCheckbox("Bigger Wallets", getSettings().game.biggerWallets);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Wallet sizes are like in the HD version. (500, 1000, 2000)");
+            }
+
+            config::ImGuiCheckbox("Disable Rupee Cutscenes", getSettings().game.disableRupeeCutscenes);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Rupees won't play cutscenes after you've collected them the first time.");
+            }
+
+            config::ImGuiCheckbox("Faster Climbing", getSettings().game.fastClimbing);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Quicker climbing on ladders and vines like the HD version.");
+            }
+
+            config::ImGuiCheckbox("Faster Tears of Light", getSettings().game.fastTears);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Tears of Light dropped by Shadow Insects pop out faster like the HD version.");
+            }
+
+            config::ImGuiCheckbox("Autosave", getSettings().game.autoSave);
+            const bool autoSaveHovered = ImGui::IsItemHovered();
+            ImGui::SameLine();
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.72f, 0.2f, 1.0f));
+            ImGui::TextUnformatted("[EXPERIMENTAL]");
+            ImGui::PopStyleColor();
+            if (autoSaveHovered || ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Autosaves the game when going to a new area,\n"
+                                  "opening a dungeon door, or getting a new item.");
+            }
+
+            config::ImGuiCheckbox("Instant Saves", getSettings().game.instantSaves);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Skip the delay when writing to the Memory Card.");
+            }
+
+            config::ImGuiCheckbox("Hold B for Instant Text", getSettings().game.instantText);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Make text scroll immediately by holding B.");
+            }
+
+            config::ImGuiCheckbox("No Climbing Miss Animation", getSettings().game.noMissClimbing);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Prevents Link from playing a struggle animation\n"
+                                  "when grabbing ledges or climbing on vines.");
+            }
+
+            config::ImGuiCheckbox("No Rupee Returns", getSettings().game.noReturnRupees);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Always collect Rupees even if your Wallet is too full.");
+            }
+
+            config::ImGuiCheckbox("No Sword Recoil", getSettings().game.noSwordRecoil);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Link won't recoil when his sword hits walls.");
+            }
+
+            config::ImGuiCheckbox("Skip TV Settings Screen", getSettings().game.hideTvSettingsScreen);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Skip the TV calibration screen shown when loading a save.");
+            }
+
+            config::ImGuiCheckbox("Skip Warning Screen", getSettings().game.skipWarningScreen);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Skip the warning screen shown when starting the game.");
+            }
+
+            config::ImGuiCheckbox("Sun's Song (R+X)", getSettings().game.sunsSong);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Allows Wolf Link to howl and change the time of day.");
+            }
+
+            config::ImGuiCheckbox("Quick Transform (R+Y)", getSettings().game.enableQuickTransform);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Transform instantly by pressing R and Y simultaneously.");
+            }
+
+            ImGui::EndMenu();
+        }
+    }
+
+    void ImGuiMenuGame::drawCheatsMenu() {
+        if (ImGui::BeginMenu("Cheats")) {
+            ImGui::SeparatorText("Resources");
+            config::ImGuiCheckbox("Infinite Hearts", getSettings().game.infiniteHearts);
+            config::ImGuiCheckbox("Infinite Arrows", getSettings().game.infiniteArrows);
+            config::ImGuiCheckbox("Infinite Bombs", getSettings().game.infiniteBombs);
+            config::ImGuiCheckbox("Infinite Oil", getSettings().game.infiniteOil);
+            config::ImGuiCheckbox("Infinite Oxygen", getSettings().game.infiniteOxygen);
+            config::ImGuiCheckbox("Infinite Rupees", getSettings().game.infiniteRupees);
+            config::ImGuiCheckbox("Items Don't Despawn", getSettings().game.enableIndefiniteItemDrops);
+            ImGui::SetItemTooltip("Items Don't Despawn Unless You Load A Different Room In Which Case They Do But Even Under Some Circumstances They Don't, It Is Quite Rare Though");
+
+            ImGui::SeparatorText("Abilities");
+            config::ImGuiCheckbox("Moon Jump (R+A)", getSettings().game.moonJump);
+            config::ImGuiCheckbox("Super Clawshot", getSettings().game.superClawshot);
+            config::ImGuiCheckbox("Always Greatspin", getSettings().game.alwaysGreatspin);
+            config::ImGuiCheckbox("Fast Iron Boots", getSettings().game.enableFastIronBoots);
+
+            config::ImGuiCheckbox("Can Transform Anywhere", getSettings().game.canTransformAnywhere);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Allows you to transform even if NPCs are looking.");
+            }
+
+            config::ImGuiCheckbox("Fast Spinner", getSettings().game.fastSpinner);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Speeds up Spinner movement when holding R.");
+            }
+
+            config::ImGuiCheckbox("Free Magic Armor", getSettings().game.freeMagicArmor);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Makes the magic armor work without rupees.");
+            }
+
+            ImGui::EndMenu();
+        }
+    }
+
+    void ImGuiMenuGame::drawAudioMenu() {
+        if (ImGui::BeginMenu("Audio")) {
+
+            ImGui::SeparatorText("Volume");
+
+            ImGui::Text("Master Volume");
+            if (config::ImGuiSliderInt("##masterVolume", getSettings().audio.masterVolume, 0, 100)) {
+                dusk::audio::SetMasterVolume(getSettings().audio.masterVolume / 100.0f);
+            }
+
+            /*
+            // TODO: Implement additional settings
+            ImGui::Text("Main Music Volume");
+            ImGui::SliderFloat("##mainMusicVolume", &getSettings().audio.mainMusicVolume, 0, 100);
+
+            ImGui::Text("Sub Music Volume");
+            ImGui::SliderFloat("##subMusicVolume", &getSettings().audio.subMusicVolume, 0, 100);
+
+            ImGui::Text("Sound Effects Volume");
+            ImGui::SliderFloat("##soundEffectsVolume", &getSettings().audio.soundEffectsVolume, 0, 100);
+
+            ImGui::Text("Fanfare Volume");
+            ImGui::SliderFloat("##fanfareVolume", &getSettings().audio.fanfareVolume, 0, 100);
+
+            Z2AudioMgr* audioMgr = Z2AudioMgr::getInterface();
+            if (audioMgr != nullptr) {
+            }
+            */
+
+            ImGui::SeparatorText("Effects");
+
+            if (config::ImGuiCheckbox("Enable Reverb", getSettings().audio.enableReverb)) {
+                dusk::audio::SetEnableReverb(getSettings().audio.enableReverb);
+            }
+
+
+            ImGui::SeparatorText("Tweaks");
+
+            config::ImGuiCheckbox("No Low HP Sound", getSettings().game.noLowHpSound);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Disable the beeping sound when having low health.");
+            }
+
+            config::ImGuiCheckbox("Non-Stop Midna's Lament", getSettings().game.midnasLamentNonStop);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Prevents enemy music while Midna's Lament is playing.");
+            }
+
+            ImGui::EndMenu();
+        }
+    }
+
+    void ImGuiMenuGame::drawInputMenu() {
+        if (ImGui::BeginMenu("Input")) {
+            ImGui::SeparatorText("Controller");
+
+            if (ImGui::Button("Configure Controller")){
+                m_showControllerConfig = !m_showControllerConfig;
+            }
+
+            ImGui::SeparatorText("Camera");
+
+            config::ImGuiCheckbox("Invert Camera X Axis", getSettings().game.invertCameraXAxis);
+
+            ImGui::SeparatorText("Gyro");
+
+            config::ImGuiCheckbox("Gyro Aim", getSettings().game.enableGyroAim);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Enables the gyroscope on supported controllers\n"
+                                  "while in look mode (C-Up) and while aiming the\n"
+                                  "Slingshot, Gale Boomerang, Hero's Bow, Clawshot(s),\n"
+                                  "Ball and Chain, and Dominion Rod.");
+            }
+
+            config::ImGuiCheckbox("Gyro Rollgoal", getSettings().game.enableGyroRollgoal);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Enables the gyroscope on supported controllers to\n"
+                                  "tilt the Rollgoal table in Hena's Cabin.");
+            }
+
+            if (getSettings().game.enableGyroAim || getSettings().game.enableGyroRollgoal) {
+                config::ImGuiSliderFloat("Gyro Pitch Sensitivity", getSettings().game.gyroSensitivityY, 0.25f, 4.0f, "%.2f");
+                config::ImGuiSliderFloat("Gyro Yaw Sensitivity", getSettings().game.gyroSensitivityX, 0.25f, 4.0f, "%.2f");
+
+                if (getSettings().game.enableGyroRollgoal) {
+                    config::ImGuiSliderFloat("Rollgoal Sensitivity", getSettings().game.gyroSensitivityRollgoal, 0.25f, 4.0f, "%.2f");
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::SetTooltip("Additional multiplier for scaling how strongly\n"
+                                          "the gyroscope affects the Rollgoal table.");
+                    }
+                }
+
+                config::ImGuiSliderFloat("Gyro Deadband", getSettings().game.gyroDeadband, 0.0f, 0.5f, "%.3f");
+                if (ImGui::IsItemHovered()) {
+                    ImGui::SetTooltip("Angular rates below this magnitude are treated as zero,\n"
+                                      "reducing drift and jitter when the controller is still.");
+                }
+
+                config::ImGuiSliderFloat("Gyro Smoothing", getSettings().game.gyroSmoothing, 0.0f, 1.0f, "%.2f");
+                if (ImGui::IsItemHovered()) {
+                    ImGui::SetTooltip("Low values track raw gyro input more closely,\n"
+                                      "while higher values smooth out input over time.");
+                }
+
+                config::ImGuiCheckbox("Invert Gyro Pitch", getSettings().game.gyroInvertPitch);
+                config::ImGuiCheckbox("Invert Gyro Yaw", getSettings().game.gyroInvertYaw);
+            }
+
+            ImGui::SeparatorText("Tools");
+
+            config::ImGuiCheckbox("Turbo Key", getSettings().game.enableTurboKeybind);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Hold TAB to increase game speed by up to 4x.");
+            }
+
+            ImGui::Checkbox("Show Input Viewer", &m_showInputViewer);
+
+            ImGui::EndMenu();
+        }
+    }
+
+    void ImGuiMenuGame::drawInterfaceMenu() {
+        if (ImGui::BeginMenu("Interface")) {
+            config::ImGuiCheckbox("Skip Pre-Launch UI", getSettings().backend.skipPreLaunchUI);
+            config::ImGuiCheckbox("Show Pipeline Compilation", getSettings().backend.showPipelineCompilation);
+#if DUSK_ENABLE_SENTRY_NATIVE
+            config::ImGuiCheckbox("Enable Crash Reporting", getSettings().backend.enableCrashReporting);
+#endif
+            if (!IsMobile) {
+                config::ImGuiCheckbox("Pause on Focus Lost", getSettings().game.pauseOnFocusLost);
+            }
+
+            ImGui::EndMenu();
+        }
+    }
+
     static void drawVirtualStick(const char* id, const ImVec2& stick) {
         float scale = ImGuiScale();
         ImGui::SetCursorPos(ImVec2(ImGui::GetCursorPos().x + 45 * scale, ImGui::GetCursorPos().y + 10));

src/dusk/imgui/ImGuiMenuGame.hpp

@@ -19,6 +19,13 @@ namespace dusk {
         static void ToggleFullscreen();
 
     private:
+        void drawAudioMenu();
+        void drawInputMenu();
+        void drawGraphicsMenu();
+        void drawGameplayMenu();
+        void drawCheatsMenu();
+        void drawInterfaceMenu();
+
         struct {
             int m_selectedPort = 0;
             bool m_isReading = false;

src/dusk/imgui/ImGuiMenuTools.cpp

@@ -16,10 +16,58 @@
 #include "dusk/main.h"
 #include "m_Do/m_Do_main.h"
 
+#include <aurora/lib/internal.hpp>
+#include <SDL3/SDL_misc.h>
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#if defined(_WIN32) || (defined(__APPLE__) && !TARGET_OS_IOS && !TARGET_OS_MACCATALYST) || (defined(__linux__) && !defined(__ANDROID__))
+#define DUSK_CAN_OPEN_DATA_FOLDER 1
+
+namespace fs = std::filesystem;
+
+static void OpenDataFolder() {
+    const std::string path = fs::absolute(dusk::ConfigPath).generic_string();
+#if defined(_WIN32)
+    const std::string url = std::string("file:///") + path;
+#else
+    const std::string url = std::string("file://") + path;
+#endif
+    (void)SDL_OpenURL(url.c_str());
+}
+#else
+#define DUSK_CAN_OPEN_DATA_FOLDER 0
+#endif
+
 namespace dusk {
     ImGuiMenuTools::ImGuiMenuTools() {}
 
     void ImGuiMenuTools::draw() {
+        if (ImGui::BeginMenu("Tools")) {
+            if (!dusk::IsGameLaunched) {
+                ImGui::BeginDisabled();
+            }
+
+            ImGui::MenuItem("Save Editor", hotkeys::SHOW_SAVE_EDITOR, &m_showSaveEditor);
+            ImGui::MenuItem("Map Loader", hotkeys::SHOW_MAP_LOADER, &m_showMapLoader);
+            ImGui::MenuItem("State Share", hotkeys::SHOW_STATE_SHARE, &m_showStateShare);
+
+            if (!dusk::IsGameLaunched) {
+                ImGui::EndDisabled();
+            }
+
+#if DUSK_CAN_OPEN_DATA_FOLDER
+            ImGui::Separator();
+            if (ImGui::MenuItem("Open Data Folder")) {
+                OpenDataFolder();
+            }
+#endif
+
+            ImGui::EndMenu();
+        }
+
         if (ImGui::BeginMenu("Debug")) {
             bool developmentMode = mDoMain::developmentMode == 1;
             if (ImGui::Checkbox("Development Mode", &developmentMode)) {
@@ -59,9 +107,6 @@ namespace dusk {
             ImGui::MenuItem("Debug Overlay", hotkeys::SHOW_DEBUG_OVERLAY, &m_showDebugOverlay);
             ImGui::MenuItem("Heap Viewer", hotkeys::SHOW_HEAP_VIEWER, &m_showHeapOverlay);
             ImGui::MenuItem("Player Info", hotkeys::SHOW_PLAYER_INFO, &m_showPlayerInfo);
-            ImGui::MenuItem("Save Editor", hotkeys::SHOW_SAVE_EDITOR, &m_showSaveEditor);     
-            ImGui::MenuItem("Map Loader", hotkeys::SHOW_MAP_LOADER, &m_showMapLoader);
-            ImGui::MenuItem("State Share", hotkeys::SHOW_STATE_SHARE, &m_showStateShare);
             ImGui::MenuItem("Debug Camera", hotkeys::SHOW_DEBUG_CAMERA, &m_showCameraOverlay);
             ImGui::MenuItem("Audio Debug", hotkeys::SHOW_AUDIO_DEBUG, &m_showAudioDebug);
             ImGui::MenuItem("Bloom", nullptr, &m_showBloomWindow);
@@ -96,7 +141,9 @@ namespace dusk {
         ImGui::SetNextWindowBgAlpha(0.65f);
         if (ImGui::Begin("Debug Overlay", nullptr, windowFlags)) {
             ImGuiStringViewText(fmt::format(FMT_STRING("FPS: {:.2f}\n"), io.Framerate));
-            ImGuiStringViewText(fmt::format(FMT_STRING("Frame usage: {:.1f}%\n"), frameUsagePct));
+            if (frameUsagePct > 0.f) {
+                ImGuiStringViewText(fmt::format(FMT_STRING("Frame usage: {:.1f}%\n"), frameUsagePct));
+            }
 
             ImGui::Separator();
 
@@ -163,7 +210,7 @@ namespace dusk {
             ImGui::Text("Link");
             ImGuiStringViewText(
                 player != nullptr
-                ? fmt::format("Position: {: .2f}, {: .2f}, {: .2f}\n", player->current.pos.x, player->current.pos.y, player->current.pos.z)
+                ? fmt::format("Position: {: .4f}, {: .4f}, {: .4f}\n", player->current.pos.x, player->current.pos.y, player->current.pos.z)
                 : "Position: ?, ?, ?\n"
             );
 
@@ -175,7 +222,7 @@ namespace dusk {
 
             ImGuiStringViewText(
                 player != nullptr
-                ? fmt::format("Speed: {0}\n", player->speedF)
+                ? fmt::format("Speed: {: .4f}\n", player->speedF)
                 : "Speed: ?\n"
             );
 
@@ -183,7 +230,7 @@ namespace dusk {
             ImGui::Text("Epona");
             ImGuiStringViewText(
                 horse != nullptr
-                ? fmt::format("Position: {: .2f}, {: .2f}, {: .2f}\n", horse->current.pos.x, horse->current.pos.y, horse->current.pos.z)
+                ? fmt::format("Position: {: .4f}, {: .4f}, {: .4f}\n", horse->current.pos.x, horse->current.pos.y, horse->current.pos.z)
                 : "Position: ?, ?, ?\n"
             );
 
@@ -195,7 +242,7 @@ namespace dusk {
 
             ImGuiStringViewText(
                 horse != nullptr
-                ? fmt::format("Speed: {0}\n", horse->speedF)
+                ? fmt::format("Speed: {: .4f}\n", horse->speedF)
                 : "Speed: ?\n"
             );
 

src/dusk/imgui/ImGuiPreLaunchWindow.cpp

@@ -46,6 +46,17 @@ static std::string ShowIsoInvalidError(const iso::ValidationError code) {
     }
 }
 
+static std::string_view card_type_name(CARDFileType type) {
+    switch (type) {
+    case CARD_GCIFOLDER:
+        return "GCI Folder"sv;
+    case CARD_RAWIMAGE:
+        return "Card Image"sv;
+    default:
+        return ""sv;
+    }
+}
+
 void fileDialogCallback(void* userdata, const char* path, const char* error) {
     auto* self = static_cast<ImGuiPreLaunchWindow*>(userdata);
     if (error != nullptr) {
@@ -216,6 +227,23 @@ void ImGuiPreLaunchWindow::drawOptions() {
         if (configuredBackendId != m_initialGraphicsBackend) {
             ImGui::TextDisabled("Restart Required");
         }
+        auto curFileType = (CARDFileType)getSettings().backend.cardFileType.getValue();
+
+        if (ImGui::BeginCombo("Save File Type", card_type_name(curFileType).data())) {
+
+            if (ImGui::Selectable("GCI Folder", curFileType == CARD_GCIFOLDER)) {
+                getSettings().backend.cardFileType.setValue(CARD_GCIFOLDER);
+                config::Save();
+            }
+
+            if (ImGui::Selectable("Card Image", curFileType == CARD_RAWIMAGE)) {
+                getSettings().backend.cardFileType.setValue(CARD_RAWIMAGE);
+                config::Save();
+            }
+
+            ImGui::EndCombo();
+        }
+
         ImGui::EndChild();
     }
 

src/dusk/imgui/ImGuiSaveEditor.cpp

@@ -10,6 +10,7 @@
 #include "d/d_item_data.h"
 #include "d/d_meter2_info.h"
 #include "d/d_save.h"
+#include "d/actor/d_a_player.h"
 
 #include <map>
 
@@ -579,20 +580,21 @@ namespace dusk {
 
 
         if (ImGui::BeginCombo("Clothes", itemMap.find(statusA.mSelectEquip[0])->second.m_name.c_str())) {
-            if (ImGui::Selectable("None")) {
-                statusA.mSelectEquip[0] = dItemNo_NONE_e;
-            }
             if (ImGui::Selectable("Ordon Clothes")) {
-                statusA.mSelectEquip[0] = dItemNo_WEAR_CASUAL_e;
+                dMeter2Info_setCloth(dItemNo_WEAR_CASUAL_e, false);
+                daPy_getPlayerActorClass()->setClothesChange(0);
             }
             if (ImGui::Selectable("Hero's Clothes")) {
-                statusA.mSelectEquip[0] = dItemNo_WEAR_KOKIRI_e;
+                dMeter2Info_setCloth(dItemNo_WEAR_KOKIRI_e, false);
+                daPy_getPlayerActorClass()->setClothesChange(0);
             }
             if (ImGui::Selectable("Zora Armor")) {
-                statusA.mSelectEquip[0] = dItemNo_WEAR_ZORA_e;
+                dMeter2Info_setCloth(dItemNo_WEAR_ZORA_e, false);
+                daPy_getPlayerActorClass()->setClothesChange(0);
             }
             if (ImGui::Selectable("Magic Armor")) {
-                statusA.mSelectEquip[0] = dItemNo_ARMOR_e;
+                dMeter2Info_setCloth(dItemNo_ARMOR_e, false);
+                daPy_getPlayerActorClass()->setClothesChange(0);
             }
             ImGui::EndCombo();
         }
@@ -1489,11 +1491,11 @@ namespace dusk {
                     }
 
                     ImGui::TableNextColumn();
-                    ImGui::Text(e.flagName.c_str());
+                    ImGuiStringViewText(e.flagName);
                     ImGui::TableNextColumn();
-                    ImGui::Text(e.location.c_str());
+                    ImGuiStringViewText(e.location);
                     ImGui::TableNextColumn();
-                    ImGui::Text(e.description.c_str());
+                    ImGuiStringViewText(e.description);
                 }
                 ImGui::EndTable();
             }

src/dusk/imgui/ImGuiStateShare.cpp

@@ -5,14 +5,24 @@
 #include "imgui.h"
 #include "fmt/format.h"
 #include "absl/strings/escaping.h"
+#include "nlohmann/json.hpp"
 
 #include "d/d_com_inf_game.h"
 #include "dusk/main.h"
+#include "dusk/io.hpp"
+#include "dusk/logging.h"
+#include "dusk/settings.h"
+#include "f_op/f_op_overlap_mng.h"
+#include "../file_select.hpp"
+#include "aurora/lib/window.hpp"
 
+#include <unordered_set>
 #include <zstd.h>
 
 namespace dusk {
 
+using json = nlohmann::json;
+
 #pragma pack(push, 1)
 struct StateSharePacket {
     char    stageName[8];
@@ -23,9 +33,65 @@ struct StateSharePacket {
 };
 #pragma pack(pop)
 
-static constexpr size_t PACKET_TOTAL = sizeof(StateSharePacket) + sizeof(dSv_info_c);
+static constexpr size_t PACKET_TOTAL     = sizeof(StateSharePacket) + sizeof(dSv_info_c);
+static constexpr size_t PACKET_SAVE_ONLY = sizeof(StateSharePacket) + sizeof(dSv_save_c);
+static constexpr auto STATES_FILENAME = "states.json";
 
-void ImGuiStateShare::copyState() {
+static bool ValidateEncodedState(const std::string&);
+
+void ImGuiStateShare::onMergeFileSelected(void* userdata, const char* path, const char* /*error*/) {
+    auto* self = static_cast<ImGuiStateShare*>(userdata);
+    if (path != nullptr) {
+        self->m_pendingMergePath = path;
+    }
+}
+
+
+
+static std::string GetStatesFilePath() {
+    return (dusk::ConfigPath / STATES_FILENAME).string();
+}
+
+void ImGuiStateShare::loadStatesFile() {
+    m_loaded = true;
+    const std::filesystem::path filePath = dusk::ConfigPath / STATES_FILENAME;
+    if (!std::filesystem::exists(filePath)) {
+        return;
+    }
+    try {
+        const std::string pathStr = filePath.string();
+        auto data = io::FileStream::ReadAllBytes(pathStr.c_str());
+        auto j = json::parse(data);
+        if (!j.is_array()) {
+            return;
+        }
+        for (const auto& entry : j) {
+            if (!entry.contains("name") || !entry.contains("data")) {
+                continue;
+            }
+            SavedStateEntry s;
+            s.name    = entry["name"].get<std::string>();
+            s.encoded = entry["data"].get<std::string>();
+            m_states.push_back(std::move(s));
+        }
+    } catch (const std::exception& e) {
+        m_statusMsg = fmt::format("Failed to load states: {}", e.what());
+    }
+}
+
+void ImGuiStateShare::saveStatesFile() {
+    json j = json::array();
+    for (const auto& s : m_states) {
+        j.push_back(json{{"name", s.name}, {"data", s.encoded}});
+    }
+    try {
+        io::FileStream::WriteAllText(GetStatesFilePath().c_str(), j.dump(2));
+    } catch (const std::exception& e) {
+        m_statusMsg = fmt::format("Failed to save states: {}", e.what());
+    }
+}
+
+std::string ImGuiStateShare::encodeCurrentState() {
     StateSharePacket pkt = {};
     strncpy(pkt.stageName, dComIfGp_getStartStageName(), 7);
     pkt.roomNo     = dComIfGp_getStartStageRoomNo();
@@ -40,26 +106,25 @@ void ImGuiStateShare::copyState() {
     std::string compressed(bound, '\0');
     compressed.resize(ZSTD_compress(compressed.data(), bound, raw.data(), raw.size(), 1));
 
-    std::string encoded = absl::Base64Escape(compressed);
-    ImGui::SetClipboardText(encoded.c_str());
-    m_statusMsg = "Copied to clipboard.";
+    return absl::Base64Escape(compressed);
 }
 
-bool ImGuiStateShare::pasteState() {
-    const char* clip = ImGui::GetClipboardText();
-    if (!clip || clip[0] == '\0') {
-        m_statusMsg = "Clipboard is empty.";
-        return false;
-    }
-
+bool ImGuiStateShare::applyEncodedState(const std::string& encoded, const std::string& name) {
     std::string decoded;
-    if (!absl::Base64Unescape(clip, &decoded)) {
+    if (!absl::Base64Unescape(encoded, &decoded)) {
         m_statusMsg = "Invalid base64.";
         return false;
     }
 
     unsigned long long dSize = ZSTD_getFrameContentSize(decoded.data(), decoded.size());
-    if (dSize == ZSTD_CONTENTSIZE_ERROR || dSize == ZSTD_CONTENTSIZE_UNKNOWN || dSize < PACKET_TOTAL) {
+    if (dSize == ZSTD_CONTENTSIZE_ERROR || dSize == ZSTD_CONTENTSIZE_UNKNOWN) {
+        m_statusMsg = "Not a valid state string.";
+        return false;
+    }
+
+    const bool isFull    = (dSize == PACKET_TOTAL);
+    const bool isPartial = (dSize == PACKET_SAVE_ONLY);
+    if (!isFull && !isPartial) {
         m_statusMsg = "Not a valid state string.";
         return false;
     }
@@ -75,45 +140,272 @@ bool ImGuiStateShare::pasteState() {
     memcpy(&pkt, raw.data(), sizeof(pkt));
     pkt.stageName[7] = '\0';
 
-    memcpy(&g_dComIfG_gameInfo.info, raw.data() + sizeof(pkt), sizeof(dSv_info_c));
+    if (isFull) {
+        memcpy(&g_dComIfG_gameInfo.info, raw.data() + sizeof(pkt), sizeof(dSv_info_c));
+        m_pendingInfo = g_dComIfG_gameInfo.info;
+        m_pendingSavedata.reset();
+    } else {
+        memcpy(&g_dComIfG_gameInfo.info.mSavedata, raw.data() + sizeof(pkt), sizeof(dSv_save_c));
+        m_pendingSavedata = g_dComIfG_gameInfo.info.mSavedata;
+        m_pendingInfo.reset();
+    }
 
     s16 spawnPoint = pkt.startPoint == -4 ? -1 : pkt.startPoint;
-    
     if (spawnPoint == -1) {
         dComIfGs_setRestartRoomParam(pkt.roomNo & 0x3F);
     }
 
-    dComIfGp_setNextStage(pkt.stageName, spawnPoint, pkt.roomNo, pkt.layer);
-    m_pendingInfo = g_dComIfG_gameInfo.info;
+    dusk::getTransientSettings().stateShareLoadActive = true;
+    m_stateSharePeekSeen = false;
+    dComIfGp_setNextStage(pkt.stageName, spawnPoint, pkt.roomNo, pkt.layer, 0.0f, 0, 1, 0, 0, 1, 3);
 
-    m_statusMsg = fmt::format("Warping to {} room {} layer {}.", pkt.stageName, (int)pkt.roomNo, (int)pkt.layer);
+    if (name.empty()) {
+        m_statusMsg = fmt::format("{} room {} layer {}.", pkt.stageName, (int)pkt.roomNo, (int)pkt.layer);
+    } else {
+        m_statusMsg = fmt::format("{}: {} room {} layer {}.", name, pkt.stageName, (int)pkt.roomNo, (int)pkt.layer);
+    }
     return true;
 }
 
 void ImGuiStateShare::tickPendingApply() {
-    if (!m_pendingInfo.has_value() || dComIfGp_isEnableNextStage())
+    if (!m_pendingInfo.has_value() && !m_pendingSavedata.has_value()) {
         return;
-    g_dComIfG_gameInfo.info = *m_pendingInfo;
-    m_pendingInfo.reset();
+    }
+    if (dComIfGp_isEnableNextStage()) {
+        return;
+    }
+    if (m_pendingInfo.has_value()) {
+        g_dComIfG_gameInfo.info = *m_pendingInfo;
+        m_pendingInfo.reset();
+    } else {
+        g_dComIfG_gameInfo.info.mSavedata = *m_pendingSavedata;
+        m_pendingSavedata.reset();
+    }
+    dComIfGp_offOxygenShowFlag();
+    dComIfGp_setMaxOxygen(600);
+    dComIfGp_setOxygen(600);
+}
+
+static bool ValidateEncodedState(const std::string& encoded) {
+    std::string decoded;
+    if (!absl::Base64Unescape(encoded, &decoded)) {
+        return false;
+    }
+    unsigned long long dSize = ZSTD_getFrameContentSize(decoded.data(), decoded.size());
+    return dSize == PACKET_TOTAL || dSize == PACKET_SAVE_ONLY;
+}
+
+void ImGuiStateShare::mergeFromFile(const std::string& path) {
+    try {
+        auto data = io::FileStream::ReadAllBytes(path.c_str());
+        auto j = json::parse(data);
+        if (!j.is_array()) {
+            m_statusMsg = "File does not contain a JSON array.";
+            return;
+        }
+
+        std::unordered_set<std::string> existingNames;
+        for (const auto& s : m_states) {
+            existingNames.insert(s.name);
+        }
+
+        int added   = 0;
+        int skipped = 0;
+        for (const auto& entry : j) {
+            if (!entry.contains("name") || !entry.contains("data")) {
+                ++skipped;
+                continue;
+            }
+            const std::string name    = entry["name"].get<std::string>();
+            const std::string encoded = entry["data"].get<std::string>();
+            if (!ValidateEncodedState(encoded)) {
+                ++skipped;
+                continue;
+            }
+            if (existingNames.count(name)) {
+                ++skipped;
+                continue;
+            }
+            SavedStateEntry s;
+            s.name    = name;
+            s.encoded = encoded;
+            existingNames.insert(s.name);
+            m_states.push_back(std::move(s));
+            ++added;
+        }
+
+        if (added > 0) {
+            saveStatesFile();
+        }
+        m_statusMsg = fmt::format("Merged: {} added, {} skipped.", added, skipped);
+    } catch (const std::exception& e) {
+        m_statusMsg = fmt::format("Failed to load file: {}", e.what());
+    }
 }
 
 void ImGuiStateShare::draw(bool& open) {
-    if (dusk::IsGameLaunched)
+    if (dusk::IsGameLaunched) {
         tickPendingApply();
+        if (dusk::getTransientSettings().stateShareLoadActive) {
+            if (fopOvlpM_IsPeek()) {
+                m_stateSharePeekSeen = true;
+            } else if (m_stateSharePeekSeen) {
+                dusk::getTransientSettings().stateShareLoadActive = false;
+                m_stateSharePeekSeen = false;
+            }
+        }
+    }
 
-    if (!open)
+    if (!m_loaded) {
+        loadStatesFile();
+    }
+
+    if (!m_pendingMergePath.empty()) {
+        mergeFromFile(m_pendingMergePath);
+        m_pendingMergePath.clear();
+    }
+
+    if (!open) {
         return;
+    }
 
-    if (!ImGui::Begin("State Share", &open, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav)) {
+    ImGui::SetNextWindowSizeConstraints(ImVec2(400, 0), ImVec2(FLT_MAX, FLT_MAX));
+    if (!ImGui::Begin("State Manager", &open, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav)) {
         ImGui::End();
         return;
     }
 
-    if (!dusk::IsGameLaunched) ImGui::BeginDisabled();
-    if (ImGui::Button("Copy State"))    copyState();
+    const bool gameRunning = dusk::IsGameLaunched;
+    const bool loadInProgress = dusk::getTransientSettings().stateShareLoadActive;
+
+    const float rowH  = ImGui::GetTextLineHeightWithSpacing();
+    const float listH = rowH * 8 + ImGui::GetStyle().FramePadding.y * 2;
+    ImGui::BeginChild("##states", ImVec2(0, listH), true);
+
+    if (m_states.empty()) {
+        ImGui::TextDisabled("No saved states. Save or import one below.");
+    }
+
+    int toDelete = -1;
+    for (int i = 0; i < (int)m_states.size(); ++i) {
+        ImGui::PushID(i);
+
+        if (m_renamingIndex == i) {
+            ImGui::SetNextItemWidth(150);
+            bool done = ImGui::InputText("##rename", m_renameBuffer, sizeof(m_renameBuffer),
+                                         ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll);
+            if (done) {
+                if (m_renameBuffer[0] != '\0') {
+                    m_states[i].name = m_renameBuffer;
+                }
+                m_renamingIndex = -1;
+                saveStatesFile();
+            } else if (ImGui::IsItemDeactivated()) {
+                m_renamingIndex = -1;
+            }
+        } else {
+            ImGui::Selectable(m_states[i].name.c_str(), false, ImGuiSelectableFlags_None, ImVec2(150, 0));
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Double-click to rename");
+                if (ImGui::IsMouseDoubleClicked(0)) {
+                    m_renamingIndex = i;
+                    strncpy(m_renameBuffer, m_states[i].name.c_str(), sizeof(m_renameBuffer) - 1);
+                    m_renameBuffer[sizeof(m_renameBuffer) - 1] = '\0';
+                    ImGui::SetKeyboardFocusHere(-1);
+                }
+            }
+        }
+
+        ImGui::SameLine();
+        if (!gameRunning || loadInProgress) { ImGui::BeginDisabled(); }
+        if (ImGui::Button("Load")) {
+            applyEncodedState(m_states[i].encoded, m_states[i].name);
+        }
+        if (!gameRunning || loadInProgress) { ImGui::EndDisabled(); }
+
+        ImGui::SameLine();
+        if (ImGui::Button("Copy")) {
+            ImGui::SetClipboardText(m_states[i].encoded.c_str());
+            m_statusMsg = fmt::format("'{}' copied to clipboard.", m_states[i].name);
+        }
+
+        ImGui::SameLine();
+        if (ImGui::Button("Del")) {
+            toDelete = i;
+        }
+
+        ImGui::PopID();
+    }
+
+    if (toDelete >= 0) {
+        if (m_renamingIndex == toDelete) { m_renamingIndex = -1; }
+        m_states.erase(m_states.begin() + toDelete);
+        saveStatesFile();
+    }
+
+    ImGui::EndChild();
+
+    // Toolbar
+    if (!gameRunning) { ImGui::BeginDisabled(); }
+    if (ImGui::Button("Save")) {
+        SavedStateEntry entry;
+        entry.name    = fmt::format("State {}", m_states.size() + 1);
+        entry.encoded = encodeCurrentState();
+        m_states.push_back(std::move(entry));
+        saveStatesFile();
+        m_statusMsg = fmt::format("Saved as '{}'.", m_states.back().name);
+    }
+    if (!gameRunning) { ImGui::EndDisabled(); }
+
     ImGui::SameLine();
-    if (ImGui::Button("Import State"))  pasteState();
-    if (!dusk::IsGameLaunched) ImGui::EndDisabled();
+    if (ImGui::Button("Import Clipboard")) {
+        const char* clip = ImGui::GetClipboardText();
+        if (!clip || clip[0] == '\0') {
+            m_statusMsg = "Clipboard is empty.";
+        } else {
+            std::string clipStr = clip;
+            if (!ValidateEncodedState(clipStr)) {
+                m_statusMsg = "Clipboard does not contain a valid state.";
+            } else {
+                SavedStateEntry entry;
+                entry.name    = fmt::format("Imported {}", m_states.size() + 1);
+                entry.encoded = std::move(clipStr);
+                m_states.push_back(std::move(entry));
+                saveStatesFile();
+                m_statusMsg = fmt::format("Imported as '{}'.", m_states.back().name);
+            }
+        }
+    }
+
+    ImGui::SameLine();
+    if (ImGui::Button("Load Pack")) {
+        static constexpr SDL_DialogFileFilter filter = {"State pack", "json"};
+        ShowFileSelect(&onMergeFileSelected, this, aurora::window::get_sdl_window(), &filter, 1, nullptr, false);
+    }
+
+    if (!m_states.empty()) {
+        ImGui::SameLine();
+        if (ImGui::Button("Clear All")) {
+            ImGui::OpenPopup("##clearall");
+        }
+
+        if (ImGui::BeginPopup("##clearall")) {
+            ImGui::Text("Delete all saved states?");
+            ImGui::Spacing();
+            if (ImGui::Button("Yes, clear all")) {
+                m_states.clear();
+                m_renamingIndex = -1;
+                saveStatesFile();
+                m_statusMsg = "All states cleared.";
+                ImGui::CloseCurrentPopup();
+            }
+            ImGui::SameLine();
+            if (ImGui::Button("Cancel")) {
+                ImGui::CloseCurrentPopup();
+            }
+            ImGui::EndPopup();
+        }
+    }
 
     if (!m_statusMsg.empty()) {
         ImGui::Spacing();
@@ -125,8 +417,9 @@ void ImGuiStateShare::draw(bool& open) {
 }
 
 void ImGuiMenuTools::ShowStateShare() {
-    if (!ImGuiConsole::CheckMenuViewToggle(ImGuiKey_F8, m_showStateShare))
+    if (!ImGuiConsole::CheckMenuViewToggle(ImGuiKey_F8, m_showStateShare)) {
         return;
+    }
     m_stateShare.draw(m_showStateShare);
 }
 

src/dusk/imgui/ImGuiStateShare.hpp

@@ -4,21 +4,39 @@
 #include "d/d_save.h"
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace dusk {
-    class ImGuiStateShare {
-    public:
-        void draw(bool& open);
 
-    private:
-        void copyState();
-        bool pasteState();
-        void tickPendingApply();
+struct SavedStateEntry {
+    std::string name;
+    std::string encoded;
+};
+
+class ImGuiStateShare {
+public:
+    void draw(bool& open);
+
+private:
+    std::string encodeCurrentState();
+    bool applyEncodedState(const std::string& encoded, const std::string& name = {});
+    void tickPendingApply();
+    void loadStatesFile();
+    void saveStatesFile();
+    void mergeFromFile(const std::string& path);
+    static void onMergeFileSelected(void* userdata, const char* path, const char* error);
+
+    std::vector<SavedStateEntry> m_states;
+    std::string m_statusMsg;
+    std::optional<dSv_info_c>  m_pendingInfo;
+    std::optional<dSv_save_c>  m_pendingSavedata;
+    int m_renamingIndex = -1;
+    char m_renameBuffer[128] = {};
+    bool m_loaded = false;
+    bool m_stateSharePeekSeen = false;
+    std::string m_pendingMergePath;
+};
 
-        std::string m_statusMsg;
-        std::optional<dSv_info_c> m_pendingInfo;
-    };
 }
 
 #endif
-                                                        

src/dusk/logging.cpp

@@ -168,14 +168,14 @@ void aurora_log_callback(AuroraLogLevel level, const char* module, const char* m
 
 aurora::Module DuskLog("dusk");
 
-void dusk::InitializeFileLogging(const char* configDir, AuroraLogLevel logLevel) {
+void dusk::InitializeFileLogging(const std::filesystem::path& configDir, AuroraLogLevel logLevel) {
     std::lock_guard lock(g_logMutex);
-    if (g_logFile != nullptr || configDir == nullptr) {
+    if (g_logFile != nullptr || configDir.empty()) {
         return;
     }
 
     std::error_code ec;
-    const std::filesystem::path logsDir = std::filesystem::path(configDir) / "logs";
+    const std::filesystem::path logsDir = configDir / "logs";
     std::filesystem::create_directories(logsDir, ec);
     if (ec) {
         std::fprintf(stderr, "[WARNING | dusk] Failed to create log directory '%s': %s\n",

src/dusk/settings.cpp

@@ -44,6 +44,7 @@ UserSettings g_userSettings = {
         .invertCameraXAxis {"game.invertCameraXAxis", false},
         .disableMainHUD {"game.disableMainHUD", false},
         .pauseOnFocusLost {"game.pauseOnFocusLost", false},
+        .enableLinkDollRotation = {"game.enableLinkDollRotation", false },
 
         // Graphics
         .bloomMode {"game.bloomMode", BloomMode::Classic},
@@ -52,6 +53,7 @@ UserSettings g_userSettings = {
         .enableFrameInterpolation {"game.enableFrameInterpolation", false},
         .internalResolutionScale {"game.internalResolutionScale", 0},
         .shadowResolutionMultiplier {"game.shadowResolutionMultiplier", 1},
+        .enableDepthOfField {"game.enableDepthOfField", true},
 
         // Audio
         .noLowHpSound {"game.noLowHpSound", false},
@@ -70,14 +72,15 @@ UserSettings g_userSettings = {
 
         // Cheats
         .infiniteHearts {"game.infiniteHearts", false},
-        .infiniteArrows {"game.infiniteArrows", false},
-        .infiniteBombs {"game.infiniteBombs", false},
-        .infiniteOil {"game.infiniteOil", false},
-        .infiniteOxygen {"game.infiniteOxygen", false},
-        .infiniteRupees {"game.infiniteRupees", false},
-        .moonJump {"game.moonJump", false},
-        .superClawshot {"game.superClawshot", false},
-        .alwaysGreatspin {"game.alwaysGreatspin", false},
+        .infiniteArrows{"game.infiniteArrows", false},
+        .infiniteBombs{"game.infiniteBombs", false},
+        .infiniteOil{"game.infiniteOil", false},
+        .infiniteOxygen{"game.infiniteOxygen", false},
+        .infiniteRupees{"game.infiniteRupees", false},
+        .enableIndefiniteItemDrops {"game.enableIndefiniteItemDrops", false},
+        .moonJump{"game.moonJump", false},
+        .superClawshot{"game.superClawshot", false},
+        .alwaysGreatspin{"game.alwaysGreatspin", false},
         .enableFastIronBoots {"game.enableFastIronBoots", false},
         .canTransformAnywhere {"game.canTransformAnywhere", false},
         .fastSpinner {"game.fastSpinner", false},
@@ -97,7 +100,8 @@ UserSettings g_userSettings = {
         .showPipelineCompilation {"backend.showPipelineCompilation", false},
         .wasPresetChosen {"backend.wasPresetChosen", false},
         .enableCrashReporting {"backend.enableCrashReporting", true},
-        .duskMenuOpen {"backend.duskMenuOpen", false}
+        .duskMenuOpen {"backend.duskMenuOpen", false},
+        .cardFileType {"backend.cardFileType", static_cast<int>(CARD_GCIFOLDER)}
     }
 };
 
@@ -145,10 +149,12 @@ void registerSettings() {
     Register(g_userSettings.game.disableWaterRefraction);
     Register(g_userSettings.game.internalResolutionScale);
     Register(g_userSettings.game.shadowResolutionMultiplier);
+    Register(g_userSettings.game.enableDepthOfField);
     Register(g_userSettings.game.enableFastIronBoots);
     Register(g_userSettings.game.canTransformAnywhere);
     Register(g_userSettings.game.freeMagicArmor);
     Register(g_userSettings.game.restoreWiiGlitches);
+    Register(g_userSettings.game.enableLinkDollRotation);
     Register(g_userSettings.game.noMissClimbing);
     Register(g_userSettings.game.noLowHpSound);
     Register(g_userSettings.game.midnasLamentNonStop);
@@ -160,6 +166,7 @@ void registerSettings() {
     Register(g_userSettings.game.infiniteOil);
     Register(g_userSettings.game.infiniteOxygen);
     Register(g_userSettings.game.infiniteRupees);
+    Register(g_userSettings.game.enableIndefiniteItemDrops);
     Register(g_userSettings.game.moonJump);
     Register(g_userSettings.game.superClawshot);
     Register(g_userSettings.game.alwaysGreatspin);
@@ -181,6 +188,7 @@ void registerSettings() {
     Register(g_userSettings.backend.wasPresetChosen);
     Register(g_userSettings.backend.enableCrashReporting);
     Register(g_userSettings.backend.duskMenuOpen);
+    Register(g_userSettings.backend.cardFileType);
 }
 
 // Transient settings