Always disable cursor if Gyro is set to Mouse mode and the menu is not open (#736)

Co-authored-by: MelonSpeedruns <melonspeedruns@stratobox.net>

CMakeLists.txt

@@ -115,10 +115,6 @@ option(DUSK_ENABLE_UPDATE_CHECKER "Enable update checking support" ON)
 
 if(ANDROID)
     set(DUSK_MOVIE_SUPPORT OFF)
-    set(NOD_COMPRESS_BZIP2 OFF CACHE BOOL "" FORCE)
-    set(NOD_COMPRESS_LZMA OFF CACHE BOOL "" FORCE)
-    set(NOD_COMPRESS_ZLIB OFF CACHE BOOL "" FORCE)
-    set(NOD_COMPRESS_ZSTD OFF CACHE BOOL "" FORCE)
 endif ()
 
 option(DUSK_ENABLE_SENTRY_NATIVE "Enable sentry-native crash reporting support" OFF)

README.md

@@ -4,7 +4,7 @@
   <p align="center">
     <a href="https://twilitrealm.dev">Official Website</a>
     •
-    <a href="https://discord.gg/QACynxeyna">Discord</a>
+    <a href="https://discord.gg/dusktp">Discord</a>
   </p>
 </div>
 
@@ -28,13 +28,24 @@ First, make sure your dump of the game is clean and supported by Dusk. You can d
 | GameCube USA | `75edd3ddff41f125d1b4ce1a40378f1b565519e7` |
 | GameCube EUR | `2601822a488eeb86fb89db16ca8f29c2c953e1ca` |
 
+*Support for other versions of the game is planned in the future.
+
 ### 2. Download [Dusk](https://github.com/TwilitRealm/dusk/releases)
 
 ### 3. Setup the game
-
+**Windows / macOS / Linux**
 - Extract the .zip file
 - Launch Dusk
-- Press **Select Disc Image** and provide the path to your supported game dump.
+- Press **Select Disc Image** and provide the path to your supported game dump
+- Press **Play**!
+
+**iOS**
+- Follow the [iOS setup guide](docs/ios-install-altstore.md)
+
+**Android**
+- Install the Dusk apk
+- Launch Dusk
+- Press **Select Disc Image** and provide the path to your supported game dump
 - Press **Play**!
 
 # Building

docs/ios-install-altstore.md

@@ -0,0 +1,46 @@
+# Installing Dusk on iOS via AltStore
+
+## Prerequisites
+
+- Mac with Homebrew installed
+- iPhone connected via USB
+- Dusk IPA file (download the latest `Dusk-vX.X.X-ios-arm64.ipa` from the [releases page](https://github.com/TwilitRealm/dusk/releases))
+- Game disc - `GZ2E01` (Gamecube USA) or `GZ2PE01` (Gamecube PAL)
+
+## 1. Install AltServer
+
+```sh
+brew install altserver
+open -a AltServer
+```
+
+AltServer will appear in your menu bar.
+
+## 2. Enable Developer Mode (iOS 16+)
+
+- On your iPhone, go to **Settings > Privacy & Security > Developer Mode**
+- Toggle it on and restart when prompted
+
+## 3. Install AltStore on Your iPhone
+
+- Click AltServer in the menu bar
+- Click **Install AltStore > [Your iPhone]**
+- Enter your Apple ID credentials when prompted
+- On your iPhone, go to **Settings > General > VPN & Device Management**
+- Tap your Apple ID under "Developer App" and tap **Trust**
+
+## 4. Copy Files to Your iPhone
+
+Transfer the IPA and game disc to your iPhone so they're accessible in the Files app. A few ways to do this:
+
+- **AirDrop** - Right-click the files on your Mac and choose Share > AirDrop
+- **iCloud Drive** - Place files in iCloud Drive on your Mac and they'll sync to Files on your iPhone
+- **USB transfer** - Connect your iPhone and drag files via Finder's sidebar
+- **Cloud storage** - Upload to Google Drive, Dropbox, etc. and download on your iPhone
+
+## 5. Install via AltStore
+
+- Open **AltStore** on your iPhone
+- Go to the **My Apps** tab
+- Tap the **+** button (top left)
+- Open the **Files** app and select the `.ipa` file

include/d/actor/d_a_e_db.h

@@ -80,6 +80,12 @@ public:
     /* 0x125C */ u32 field_0x125c;
     /* 0x1260 */ u8 field_0x1260[0x126C - 0x1260];
     /* 0x126C */ u8 HIOInit;
+#if TARGET_PC
+    cXyz mStalkLineInterpPrev[12];
+    cXyz mStalkLineInterpCurr[12];
+    bool mStalkLineInterpPrevValid;
+    bool mStalkLineInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_db_class) == 0x1270);

include/d/actor/d_a_e_hb.h

@@ -73,6 +73,12 @@ public:
     /* 0x124C */ f32 field_0x124c;
     /* 0x1250 */ u8 field_0x1250[0x1264 - 0x1250];
     /* 0x1264 */ u8 HIOInit;
+#if TARGET_PC
+    cXyz mStalkLineInterpPrev[12];
+    cXyz mStalkLineInterpCurr[12];
+    bool mStalkLineInterpPrevValid;
+    bool mStalkLineInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_hb_class) == 0x1268);

include/d/actor/d_a_e_s1.h

@@ -81,6 +81,15 @@ public:
     /* 0x306D */ u8 field_0x306D[0x307C - 0x306D];
     /* 0x307C */ u32 mBodyEffEmtrID;
     /* 0x3080 */ u8 mInitHIO;
+
+#if TARGET_PC
+    static const int HAIR_STRAND_COUNT = 22;
+    static const int HAIR_SEGMENT_COUNT = 16;
+    cXyz mHairInterpPrev[HAIR_STRAND_COUNT * HAIR_SEGMENT_COUNT];
+    cXyz mHairInterpCurr[HAIR_STRAND_COUNT * HAIR_SEGMENT_COUNT];
+    bool mHairInterpPrevValid;
+    bool mHairInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_s1_class) == 0x3084);

include/d/actor/d_a_e_yd.h

@@ -74,6 +74,12 @@ public:
     /* 0x1250 */ f32 field_0x1250;
     /* 0x1254 */ u8 field_0x1254[0x1268 - 0x1254];
     /* 0x1268 */ u8 field_0x1268;
+#if TARGET_PC
+    cXyz mLineMatInterpPrev[12];
+    cXyz mLineMatInterpCurr[12];
+    bool mLineMatInterpPrevValid;
+    bool mLineMatInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_yd_class) == 0x126c);

include/d/actor/d_a_e_yg.h

@@ -63,6 +63,15 @@ public:
     /* 0x0BB4 */ yg_ke_s mYgKes[13];
     /* 0x1880 */ mDoExt_3DlineMat0_c mLineMat;
     /* 0x189C */ u8 mIsFirstSpawn;
+
+#if TARGET_PC
+    static const int TENTACLE_STRAND_COUNT = 13;
+    static const int TENTACLE_SEGMENT_COUNT = 10;
+    cXyz mTentacleInterpPrev[TENTACLE_STRAND_COUNT * TENTACLE_SEGMENT_COUNT];
+    cXyz mTentacleInterpCurr[TENTACLE_STRAND_COUNT * TENTACLE_SEGMENT_COUNT];
+    bool mTentacleInterpPrevValid;
+    bool mTentacleInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_yg_class) == 0x18a0);

include/d/actor/d_a_e_yh.h

@@ -77,6 +77,12 @@ public:
     /* 0x1260 */ u32 field_0x1260;
     /* 0x1260 */ u8 field_0x1264[0x1270 - 0x1264];
     /* 0x1270 */ bool mIsHIOOwner;
+#if TARGET_PC
+    cXyz mLineInterpPrev[12];
+    cXyz mLineInterpCurr[12];
+    bool mLineInterpPrevValid;
+    bool mLineInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_yh_class) == 0x1274);

include/d/actor/d_a_obj_fchain.h

@@ -31,6 +31,10 @@ public:
     csXyz* getAngle() { return field_0x8a4; }
     J3DModelData* getModelData() { return mModelData; }
 
+#if TARGET_PC
+    void onInterpCallback();
+#endif
+
 private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModelData* mModelData;
@@ -42,6 +46,14 @@ private:
     /* 0x694 */ cXyz field_0x694[22];
     /* 0x79C */ cXyz field_0x79c[22];
     /* 0x8A4 */ csXyz field_0x8a4[22];
+
+#if TARGET_PC
+    static const int CHAIN_COUNT = 22;
+    cXyz mChainInterpPrev[CHAIN_COUNT];
+    cXyz mChainInterpCurr[CHAIN_COUNT];
+    bool mChainInterpPrevValid;
+    bool mChainInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(daObjFchain_c) == 0x928);

platforms/android/README.md

@@ -66,12 +66,11 @@ Output APK:
 You can pass command-line args through the activity intent:
 
 ```bash
-adb shell am start -n com.twilitrealm.dusk/.DuskActivity \
-  --es dusk_args "'/sdcard/Download/The Legend of Zelda: Twilight Princess (USA).iso'"
+adb shell am start -n dev.twilitrealm.dusk/.DuskActivity \
+  --es dusk_args "--backend vulkan"
 ```
 
 Supported extras:
 
 - `dusk_args`: single shell-like argument string
 - `dusk_argv`: string-array argv
-- `dusk_disc`: compatibility shortcut (single ISO path)

platforms/android/app/build.gradle

@@ -13,11 +13,11 @@ def syncDuskAssets = tasks.register('syncDuskAssets', Sync) {
 }
 
 android {
-    namespace 'com.twilitrealm.dusk'
+    namespace 'dev.twilitrealm.dusk'
     compileSdk 36
 
     defaultConfig {
-        applicationId 'com.twilitrealm.dusk'
+        applicationId 'dev.twilitrealm.dusk'
         minSdk 26
         targetSdk 36
         versionCode 1
@@ -60,7 +60,8 @@ dependencies {
 }
 
 tasks.configureEach { task ->
-    if (task.name.startsWith('merge') && task.name.endsWith('Assets')) {
+    if ((task.name.startsWith('merge') && task.name.endsWith('Assets')) ||
+        task.name.toLowerCase().contains('lint')) {
         task.dependsOn(syncDuskAssets)
     }
 }

platforms/android/app/proguard-rules.pro

@@ -1,4 +1,4 @@
 # Keep SDL activity and related JNI bridge methods.
 -keep class org.libsdl.app.** { *; }
--keep class com.twilitrealm.dusk.DuskHttpClient { *; }
--keep class com.twilitrealm.dusk.DuskHttpClient$Response { *; }
+-keep class dev.twilitrealm.dusk.DuskHttpClient { *; }
+-keep class dev.twilitrealm.dusk.DuskHttpClient$Response { *; }

platforms/android/app/src/main/AndroidManifest.xml

@@ -25,7 +25,7 @@
             android:resource="@xml/game_mode_config" />
 
         <activity
-            android:name="com.twilitrealm.dusk.DuskActivity"
+            android:name="dev.twilitrealm.dusk.DuskActivity"
             android:alwaysRetainTaskState="true"
             android:configChanges="layoutDirection|locale|grammaticalGender|fontScale|fontWeightAdjustment|orientation|uiMode|screenLayout|screenSize|smallestScreenSize|keyboard|keyboardHidden|navigation"
             android:exported="true"

platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskActivity.java

@@ -1,4 +1,4 @@
-package com.twilitrealm.dusk;
+package dev.twilitrealm.dusk;
 
 import android.app.ActionBar;
 import android.content.ClipData;
@@ -10,6 +10,7 @@ import android.os.Bundle;
 import android.provider.OpenableColumns;
 import android.util.Log;
 import android.view.View;
+import android.view.Window;
 import android.view.WindowInsets;
 import android.view.WindowInsetsController;
 
@@ -70,19 +71,42 @@ public class DuskActivity extends SDLActivity {
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        hideSystemBars();
+    }
 
+    @Override
+    protected void onResume() {
+        super.onResume();
+        hideSystemBars();
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        if (hasFocus) {
+            hideSystemBars();
+        }
+    }
+
+    private void hideSystemBars() {
+        Window window = getWindow();
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            WindowInsetsController ctrl = getWindow().getDecorView().getWindowInsetsController();
+            window.setDecorFitsSystemWindows(false);
+            WindowInsetsController ctrl = window.getDecorView().getWindowInsetsController();
             if (ctrl != null) {
+                ctrl.setSystemBarsBehavior(
+                    WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
                 ctrl.hide(WindowInsets.Type.systemBars());
             }
-        }else {
-            View decorView = getWindow().getDecorView();
-            // Hide the status bar.
-            int uiOptions = View.SYSTEM_UI_FLAG_FULLSCREEN;
+        } else {
+            View decorView = window.getDecorView();
+            int uiOptions = View.SYSTEM_UI_FLAG_FULLSCREEN |
+                View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
+                View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
+                View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
+                View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
+                View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
             decorView.setSystemUiVisibility(uiOptions);
-            // Remember that you should never show the action bar if the
-            // status bar is hidden, so hide that too if necessary.
             ActionBar actionBar = getActionBar();
             if (actionBar != null) {
                 actionBar.hide();
@@ -114,11 +138,6 @@ public class DuskActivity extends SDLActivity {
                     return splitArgs(trimmed);
                 }
             }
-
-            String discPath = intent.getStringExtra("dusk_disc");
-            if (discPath != null && !discPath.isEmpty()) {
-                return new String[] { discPath };
-            }
         }
         return new String[0];
     }

platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskHttpClient.java

@@ -1,4 +1,4 @@
-package com.twilitrealm.dusk;
+package dev.twilitrealm.dusk;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;

platforms/android/app/src/main/java/org/libsdl/app/SDLSurface.java

@@ -35,6 +35,8 @@ public class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
     View.OnApplyWindowInsetsListener, View.OnKeyListener, View.OnTouchListener,
     SensorEventListener, ScaleGestureDetector.OnScaleGestureListener {
 
+    private static native void auroraNativeSetSurfaceReady(boolean ready);
+
     // Sensors
     protected SensorManager mSensorManager;
     protected Display mDisplay;
@@ -96,6 +98,7 @@ public class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
     @Override
     public void surfaceCreated(SurfaceHolder holder) {
         Log.v("SDL", "surfaceCreated()");
+        auroraNativeSetSurfaceReady(false);
         SDLActivity.onNativeSurfaceCreated();
     }
 
@@ -103,6 +106,7 @@ public class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         Log.v("SDL", "surfaceDestroyed()");
+        auroraNativeSetSurfaceReady(false);
 
         // Transition to pause, if needed
         SDLActivity.mNextNativeState = SDLActivity.NativeState.PAUSED;
@@ -192,6 +196,7 @@ public class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
 
         /* Surface is ready */
         mIsSurfaceReady = true;
+        auroraNativeSetSurfaceReady(true);
 
         SDLActivity.mNextNativeState = SDLActivity.NativeState.RESUMED;
         SDLActivity.handleNativeState();

res/rml/window.rcss

@@ -498,7 +498,6 @@ progress.verification-progress-bar {
     display: flex;
     flex-direction: row;
     flex-wrap: nowrap;
-    justify-content: stretch;
     align-items: stretch;
     gap: 12dp;
     width: 100%;

src/d/actor/d_a_e_db.cpp

@@ -10,6 +10,10 @@
 #include "f_op/f_op_kankyo_mng.h"
 #include "f_op/f_op_actor_enemy.h"
 
+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
+
 class daE_DB_HIO_c : public JORReflexible {
 public:
     daE_DB_HIO_c();
@@ -66,6 +70,22 @@ static BOOL leaf_anm_init(e_db_class* i_this, int i_anm, f32 i_morf, u8 i_mode,
     return FALSE;
 }
 
+#if TARGET_PC
+static void daE_DB_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_db_class* i_this = (e_db_class*)pUserWork;
+    if (!i_this->mStalkLineInterpPrevValid || !i_this->mStalkLineInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    cXyz* dst = i_this->stalkLine.getPos(0);
+    for (int i = 0; i < 12; i++) {
+        const cXyz& p0 = i_this->mStalkLineInterpPrev[i];
+        const cXyz& p1 = i_this->mStalkLineInterpCurr[i];
+        dst[i] = p0 + (p1 - p0) * alpha;
+    }
+}
+#endif
+
 static int daE_DB_Draw(e_db_class* i_this) {
     fopAc_ac_c* actor = &i_this->enemy;
 
@@ -95,6 +115,17 @@ static int daE_DB_Draw(e_db_class* i_this) {
     static GXColor l_color = {0x14, 0x0F, 0x00, 0xFF};
     i_this->stalkLine.update(12, l_color, &actor->tevStr);
     dComIfGd_set3DlineMat(&i_this->stalkLine);
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (i_this->mStalkLineInterpCurrValid) {
+            memcpy(i_this->mStalkLineInterpPrev, i_this->mStalkLineInterpCurr, sizeof(i_this->mStalkLineInterpCurr));
+            i_this->mStalkLineInterpPrevValid = true;
+        }
+        memcpy(i_this->mStalkLineInterpCurr, i_this->stalkLine.getPos(0), 12 * sizeof(cXyz));
+        i_this->mStalkLineInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&daE_DB_interp_callback, i_this);
+    }
+#endif
 
     for (int i = 1; i < 11; i++) {
         if (i_this->thornModel[i] != NULL) {

src/d/actor/d_a_e_hb.cpp

@@ -9,6 +9,10 @@
 #include "d/actor/d_a_e_hb_leaf.h"
 #include "f_op/f_op_actor_enemy.h"
 
+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
+
 enum daE_HB_ACTION {
     ACTION_STAY,
     ACTION_APPEAR,
@@ -64,6 +68,22 @@ static BOOL leaf_anm_init(e_hb_class* i_this, int i_anm, f32 i_morf, u8 i_mode,
     return FALSE;
 }
 
+#if TARGET_PC
+static void daE_HB_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_hb_class* i_this = (e_hb_class*)pUserWork;
+    if (!i_this->mStalkLineInterpPrevValid || !i_this->mStalkLineInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    cXyz* dst = i_this->stalkLine.getPos(0);
+    for (int i = 0; i < 12; i++) {
+        const cXyz& p0 = i_this->mStalkLineInterpPrev[i];
+        const cXyz& p1 = i_this->mStalkLineInterpCurr[i];
+        dst[i] = p0 + (p1 - p0) * alpha;
+    }
+}
+#endif
+
 static int daE_HB_Draw(e_hb_class* i_this) {
     fopAc_ac_c* actor = &i_this->enemy;
 
@@ -82,6 +102,17 @@ static int daE_HB_Draw(e_hb_class* i_this) {
     static GXColor l_color = {0x14, 0x0F, 0x00, 0xFF};
     i_this->stalkLine.update(12, l_color, &actor->tevStr);
     dComIfGd_set3DlineMat(&i_this->stalkLine);
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (i_this->mStalkLineInterpCurrValid) {
+            memcpy(i_this->mStalkLineInterpPrev, i_this->mStalkLineInterpCurr, sizeof(i_this->mStalkLineInterpCurr));
+            i_this->mStalkLineInterpPrevValid = true;
+        }
+        memcpy(i_this->mStalkLineInterpCurr, i_this->stalkLine.getPos(0), 12 * sizeof(cXyz));
+        i_this->mStalkLineInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&daE_HB_interp_callback, i_this);
+    }
+#endif
 
     for (int i = 1; i < 11; i++) {
         if (i_this->thornModel[i] != NULL) {

src/d/actor/d_a_e_s1.cpp

@@ -14,6 +14,8 @@
 #include "d/d_s_play.h"
 #include "f_op/f_op_actor_enemy.h"
 #include "f_op/f_op_camera_mng.h"
+#include "dusk/frame_interpolation.h"
+#include "dusk/settings.h"
 #include <cstring>
 
 class daE_S1_HIO_c {
@@ -99,6 +101,25 @@ static void anm_init(e_s1_class* i_this, int i_resNo, f32 i_morf, u8 i_attr, f32
     i_this->mAnm = i_resNo;
 }
 
+#if TARGET_PC
+static void daE_S1_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_s1_class* i_this = (e_s1_class*)pUserWork;
+    if (!i_this->mHairInterpPrevValid || !i_this->mHairInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    for (int s = 0; s < e_s1_class::HAIR_STRAND_COUNT; s++) {
+        cXyz* dst = i_this->mLineMat.getPos(s);
+        for (int i = 0; i < e_s1_class::HAIR_SEGMENT_COUNT; i++) {
+            int idx = s * e_s1_class::HAIR_SEGMENT_COUNT + i;
+            const cXyz& p0 = i_this->mHairInterpPrev[idx];
+            const cXyz& p1 = i_this->mHairInterpCurr[idx];
+            dst[i] = p0 + (p1 - p0) * alpha;
+        }
+    }
+}
+#endif
+
 static int daE_S1_Draw(e_s1_class* i_this) {
     if (i_this->field_0x306c != 0) {
         return 1;
@@ -132,6 +153,22 @@ static int daE_S1_Draw(e_s1_class* i_this) {
     i_this->mLineMat.update(16, line_color, &i_this->tevStr);
     dComIfGd_set3DlineMatDark(&i_this->mLineMat);
 
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (i_this->mHairInterpCurrValid) {
+            memcpy(i_this->mHairInterpPrev, i_this->mHairInterpCurr, sizeof(i_this->mHairInterpCurr));
+            i_this->mHairInterpPrevValid = true;
+        }
+        for (int s = 0; s < e_s1_class::HAIR_STRAND_COUNT; s++) {
+            cXyz* src = i_this->mLineMat.getPos(s);
+            memcpy(&i_this->mHairInterpCurr[s * e_s1_class::HAIR_SEGMENT_COUNT], src,
+                   e_s1_class::HAIR_SEGMENT_COUNT * sizeof(cXyz));
+        }
+        i_this->mHairInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&daE_S1_interp_callback, i_this);
+    }
+#endif
+
     dComIfGd_setList();
     return 1;
 }
@@ -2149,6 +2186,11 @@ static int daE_S1_Create(fopAc_ac_c* i_this) {
             return cPhs_ERROR_e;
         }
 
+#if TARGET_PC
+        a_this->mHairInterpPrevValid = false;
+        a_this->mHairInterpCurrValid = false;
+#endif
+
         OS_REPORT("//////////////E_S1 SET 2 !!\n");
 
         if (path_no != 0xFF) {

src/d/actor/d_a_e_yd.cpp

@@ -12,6 +12,10 @@
 #include "d/d_cc_uty.h"
 #include "f_op/f_op_actor_enemy.h"
 
+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
+
 class daE_YD_HIO_c {
 public:
     daE_YD_HIO_c();
@@ -73,6 +77,22 @@ static s32 leaf_anm_init(e_yd_class* i_this, int param_1, f32 param_2, u8 param_
     return false;
 }
 
+#if TARGET_PC
+static void daE_YD_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_yd_class* i_this = (e_yd_class*)pUserWork;
+    if (!i_this->mLineMatInterpPrevValid || !i_this->mLineMatInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    cXyz* dst = i_this->mLineMat.getPos(0);
+    for (int i = 0; i < 12; i++) {
+        const cXyz& p0 = i_this->mLineMatInterpPrev[i];
+        const cXyz& p1 = i_this->mLineMatInterpCurr[i];
+        dst[i] = p0 + (p1 - p0) * alpha;
+    }
+}
+#endif
+
 static s32 daE_YD_Draw(e_yd_class* i_this) {
     static GXColor l_color = { 0x14, 0x0F, 0x00, 0xFF };
 
@@ -86,6 +106,17 @@ static s32 daE_YD_Draw(e_yd_class* i_this) {
     i_this->mpMorf->entryDL();
     i_this->mLineMat.update(12, l_color, &i_this->actor.tevStr);
     dComIfGd_set3DlineMat(&i_this->mLineMat);
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (i_this->mLineMatInterpCurrValid) {
+            memcpy(i_this->mLineMatInterpPrev, i_this->mLineMatInterpCurr, sizeof(i_this->mLineMatInterpCurr));
+            i_this->mLineMatInterpPrevValid = true;
+        }
+        memcpy(i_this->mLineMatInterpCurr, i_this->mLineMat.getPos(0), 12 * sizeof(cXyz));
+        i_this->mLineMatInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&daE_YD_interp_callback, i_this);
+    }
+#endif
     for (s32 i = 1; i < 11; i++) {
         if (i_this->field_0x77c[i] != 0) {
             g_env_light.setLightTevColorType_MAJI(i_this->field_0x77c[i], &i_this->actor.tevStr);

src/d/actor/d_a_e_yg.cpp

@@ -10,6 +10,8 @@
 #include "f_op/f_op_kankyo_mng.h"
 #include "d/actor/d_a_obj_carry.h"
 #include "Z2AudioLib/Z2Instances.h"
+#include "dusk/frame_interpolation.h"
+#include "dusk/settings.h"
 #include "f_op/f_op_actor_enemy.h"
 
 enum E_yg_RES_File_ID {
@@ -134,7 +136,26 @@ static BOOL pl_check(e_yg_class* i_this, f32 i_dist) {
     return FALSE;
 }
 
-static int daE_YG_Draw(e_yg_class* i_this) {    
+#if TARGET_PC
+static void daE_YG_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_yg_class* i_this = (e_yg_class*)pUserWork;
+    if (!i_this->mTentacleInterpPrevValid || !i_this->mTentacleInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    for (int s = 0; s < e_yg_class::TENTACLE_STRAND_COUNT; s++) {
+        cXyz* dst = i_this->mLineMat.getPos(s);
+        for (int i = 0; i < e_yg_class::TENTACLE_SEGMENT_COUNT; i++) {
+            int idx = s * e_yg_class::TENTACLE_SEGMENT_COUNT + i;
+            const cXyz& p0 = i_this->mTentacleInterpPrev[idx];
+            const cXyz& p1 = i_this->mTentacleInterpCurr[idx];
+            dst[i] = p0 + (p1 - p0) * alpha;
+        }
+    }
+}
+#endif
+
+static int daE_YG_Draw(e_yg_class* i_this) {
     if (i_this->mDispFlag) {
         return 1;
     }
@@ -160,6 +181,23 @@ static int daE_YG_Draw(e_yg_class* i_this) {
     color.a = 0xFF;
     i_this->mLineMat.update(10, color, &actor->tevStr);
     dComIfGd_set3DlineMatDark(&i_this->mLineMat);
+
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (i_this->mTentacleInterpCurrValid) {
+            memcpy(i_this->mTentacleInterpPrev, i_this->mTentacleInterpCurr, sizeof(i_this->mTentacleInterpCurr));
+            i_this->mTentacleInterpPrevValid = true;
+        }
+        for (int s = 0; s < e_yg_class::TENTACLE_STRAND_COUNT; s++) {
+            cXyz* src = i_this->mLineMat.getPos(s);
+            memcpy(&i_this->mTentacleInterpCurr[s * e_yg_class::TENTACLE_SEGMENT_COUNT], src,
+                   e_yg_class::TENTACLE_SEGMENT_COUNT * sizeof(cXyz));
+        }
+        i_this->mTentacleInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&daE_YG_interp_callback, i_this);
+    }
+#endif
+
     dComIfGd_setList();
 
     return 1;
@@ -1378,6 +1416,11 @@ static cPhs_Step daE_YG_Create(fopAc_ac_c* actor) {
             return cPhs_ERROR_e;
         }
 
+#if TARGET_PC
+        i_this->mTentacleInterpPrevValid = false;
+        i_this->mTentacleInterpCurrValid = false;
+#endif
+
         if (!hio_set) {
             i_this->mIsFirstSpawn = 1;
             hio_set = true;

src/d/actor/d_a_e_yh.cpp

@@ -12,6 +12,10 @@
 #include "f_op/f_op_actor_enemy.h"
 #include "f_op/f_op_kankyo_mng.h"
 
+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
+
 class daE_YH_HIO_c : public JORReflexible {
 public:
     daE_YH_HIO_c();
@@ -85,6 +89,22 @@ static BOOL leaf_anm_init(e_yh_class* i_this, int param_2, f32 param_3, u8 param
     return FALSE;
 }
 
+#if TARGET_PC
+static void daE_YH_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_yh_class* i_this = (e_yh_class*)pUserWork;
+    if (!i_this->mLineInterpPrevValid || !i_this->mLineInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    cXyz* dst = i_this->mLine.getPos(0);
+    for (int i = 0; i < 12; i++) {
+        const cXyz& p0 = i_this->mLineInterpPrev[i];
+        const cXyz& p1 = i_this->mLineInterpCurr[i];
+        dst[i] = p0 + (p1 - p0) * alpha;
+    }
+}
+#endif
+
 static int daE_YH_Draw(e_yh_class* i_this) {
     fopAc_ac_c* a_this = (fopAc_ac_c*)i_this;
 
@@ -114,6 +134,17 @@ static int daE_YH_Draw(e_yh_class* i_this) {
 
     i_this->mLine.update(12, l_color, &a_this->tevStr);
     dComIfGd_set3DlineMat(&i_this->mLine);
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (i_this->mLineInterpCurrValid) {
+            memcpy(i_this->mLineInterpPrev, i_this->mLineInterpCurr, sizeof(i_this->mLineInterpCurr));
+            i_this->mLineInterpPrevValid = true;
+        }
+        memcpy(i_this->mLineInterpCurr, i_this->mLine.getPos(0), 12 * sizeof(cXyz));
+        i_this->mLineInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&daE_YH_interp_callback, i_this);
+    }
+#endif
 
     for (int i = 1; i < 11; i++) {
         if (i_this->mModels[i] != NULL) {

src/d/actor/d_a_midna.cpp

@@ -419,9 +419,30 @@ int daMidna_c::createHeap() {
             return 0;
         }
 
+#if TARGET_PC
+        if (mpDemoFCTongueBmd != NULL) {
+            if(!daAlink_c::initDemoBck(&mpDemoFCTmpBck, "demo00_Midna_cut00_FC_tmp.bck")) {
+                return 0;
+            }
+
+            // Update Midna's eye maxLOD to prevent the eyes from disappearing
+            J3DTexture* tex = mpDemoFCTongueBmd->getModelData()->getTexture();
+            JUTNameTab* nametable = mpDemoFCTongueBmd->getModelData()->getTextureName();
+            if (tex != nullptr && nametable != nullptr) {
+                for (u16 i = 0; i < tex->getNum(); i++) {
+                    const char* tex_name = nametable->getName(i);
+                    if (tex_name != NULL && strcmp(tex_name, "midona_eyeball") == 0) {
+                        ResTIMG* timg = tex->getResTIMG(i);
+                        timg->maxLOD = 0;
+                    }
+                }
+            }
+        }
+#else
         if (mpDemoFCTongueBmd != NULL && !daAlink_c::initDemoBck(&mpDemoFCTmpBck, "demo00_Midna_cut00_FC_tmp.bck")) {
             return 0;
         }
+#endif
 
         modelData =
             (J3DModelData*)dComIfG_getObjectRes(dStage_roomControl_c::getDemoArcName(), "demo00_Midna_cut00_BD_tmp.bmd");
@@ -433,6 +454,21 @@ int daMidna_c::createHeap() {
 
             modelData->getMaterialNodePointer(2)->setMaterialAnm(mpEyeMatAnm[0]);
             modelData->getMaterialNodePointer(3)->setMaterialAnm(mpEyeMatAnm[1]);
+
+#if TARGET_PC
+            // Update Midna's eye maxLOD to prevent the eyes from disappearing
+            J3DTexture* tex = modelData->getTexture();
+            JUTNameTab* nametable = modelData->getTextureName();
+            if (tex != nullptr && nametable != nullptr) {
+                for (u16 i = 0; i < tex->getNum(); i++) {
+                    const char* tex_name = nametable->getName(i);
+                    if (tex_name != NULL && strcmp(tex_name, "midona_eyeball") == 0) {
+                        ResTIMG* timg = tex->getResTIMG(i);
+                        timg->maxLOD = 0;
+                    }
+                }
+            }
+#endif
         }
 
         if (!initDemoModel(&mpDemoBDMaskBmd, "demo00_Midna_cut00_BD_mask.bmd", 0)) {

src/d/actor/d_a_obj_fchain.cpp

@@ -10,6 +10,8 @@
 #include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
 #include "SSystem/SComponent/c_math.h"
 #include "d/d_com_inf_game.h"
+#include "dusk/frame_interpolation.h"
+#include "dusk/settings.h"
 #include <cstring>
 
 static char const l_arcName[] = "Fchain";
@@ -65,6 +67,10 @@ int daObjFchain_c::create() {
             local_48++;
         }
         rv = cPhs_COMPLEATE_e;
+#if TARGET_PC
+        mChainInterpPrevValid = false;
+        mChainInterpCurrValid = false;
+#endif
         break;
     }
     return rv;
@@ -289,6 +295,26 @@ void daObjFchain_shape_c::draw() {
     }
 }
 
+#if TARGET_PC
+static void fchain_interp_callback(bool isSimFrame, void* pUserWork) {
+    static_cast<daObjFchain_c*>(pUserWork)->onInterpCallback();
+}
+
+void daObjFchain_c::onInterpCallback() {
+    if (!mChainInterpPrevValid || !mChainInterpCurrValid) {
+        return;
+    }
+
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+
+    for (int i = 0; i < CHAIN_COUNT; i++) {
+        const cXyz& p0 = mChainInterpPrev[i];
+        const cXyz& p1 = mChainInterpCurr[i];
+        field_0x694[i] = p0 + (p1 - p0) * alpha;
+    }
+}
+#endif
+
 int daObjFchain_c::draw() {
     if (field_0x584 != 0) {
         g_env_light.settingTevStruct(0, &current.pos, &tevStr);
@@ -297,6 +323,19 @@ int daObjFchain_c::draw() {
             return 1;
         }
         dComIfGd_getOpaListDark()->entryImm(&mShape, 0);
+
+#if TARGET_PC
+        if (dusk::getSettings().game.enableFrameInterpolation) {
+            if (mChainInterpCurrValid) {
+                memcpy(mChainInterpPrev, mChainInterpCurr, sizeof(mChainInterpCurr));
+                mChainInterpPrevValid = true;
+            }
+
+            memcpy(mChainInterpCurr, field_0x694, sizeof(mChainInterpCurr));
+            mChainInterpCurrValid = true;
+            dusk::frame_interp::add_interpolation_callback(&fchain_interp_callback, this);
+        }
+#endif
     }
     return 1;
 }

src/d/d_msg_object.cpp

@@ -427,14 +427,15 @@ static void dummyStrings() {
 dMsgObject_HIO_c g_MsgObject_HIO_c;
 
 int dMsgObject_c::_execute() {
-#if TARGET_PC
+// TODO: enabling wii message overrides fixes direction text, but gives wrong item control text
+/*#if TARGET_PC
     if (dusk::getSettings().game.enableMirrorMode) {
         // enable wii message index override
         g_MsgObject_HIO_c.mMessageDisplay = 1;
     } else if (!dusk::getSettings().game.enableMirrorMode && g_MsgObject_HIO_c.mMessageDisplay == 1) {
         g_MsgObject_HIO_c.mMessageDisplay = 0;
     }
-#endif
+#endif*/
 
 
     field_0x4c7 = 0;

src/dusk/http/android.cpp

@@ -337,7 +337,7 @@ Result get(const Request& request) {
     }
 
     jclass clientClass =
-        load_dusk_class(env, activity, "com.twilitrealm.dusk.DuskHttpClient");
+        load_dusk_class(env, activity, "dev.twilitrealm.dusk.DuskHttpClient");
     env->DeleteLocalRef(activity);
     if (clientClass == nullptr) {
         return {
@@ -348,7 +348,7 @@ Result get(const Request& request) {
 
     jmethodID getMethod = env->GetStaticMethodID(clientClass, "get",
         "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;IJ)"
-        "Lcom/twilitrealm/dusk/DuskHttpClient$Response;");
+        "Ldev/twilitrealm/dusk/DuskHttpClient$Response;");
     if (getMethod == nullptr || clear_pending_exception(env)) {
         env->DeleteLocalRef(clientClass);
         return {

src/dusk/imgui/ImGuiConsole.cpp

@@ -376,18 +376,18 @@ namespace dusk {
         }
 
         // Hide mouse cursor if the F1 menu is not open and the cursor is idle for 3 seconds.
-        ImGuiIO& io = ImGui::GetIO();
-        if (showMenu) {
-            mouseHideTimer = 0.0f;
-            ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NoMouseCursorChange; // Imgui will re-show cursor.
-        } else if (io.MouseDelta.x != 0.0f || io.MouseDelta.y != 0.0f) {
-            mouseHideTimer = 0.0f;
-            ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NoMouseCursorChange; // Imgui will re-show cursor.
-        } else if (mouseHideTimer <= 3.0f) {
-            mouseHideTimer += ImGui::GetIO().DeltaTime;
-        } else {
-            ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
-            SDL_HideCursor();
+        if (dusk::getSettings().game.gyroMode.getValue() != GyroMode::Mouse)
+        {
+            ImGuiIO& io = ImGui::GetIO();
+            if (io.MouseDelta.x != 0.0f || io.MouseDelta.y != 0.0f) {
+                mouseHideTimer = 0.0f;
+                ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NoMouseCursorChange;  // Imgui will re-show cursor.
+            } else if (mouseHideTimer <= 3.0f) {
+                mouseHideTimer += ImGui::GetIO().DeltaTime;
+            } else {
+                ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
+                SDL_HideCursor();
+            }
         }
 
         ShowToasts();

src/dusk/ui/document.cpp

@@ -5,6 +5,7 @@
 
 #include "Z2AudioLib/Z2SeMgr.h"
 #include "m_Do/m_Do_audio.h"
+#include <imgui.h>
 
 namespace dusk::ui {
 namespace {
@@ -106,6 +107,7 @@ bool Document::visible() const {
 
 bool Document::handle_nav_command(Rml::Event& event, NavCommand cmd) {
     if (cmd == NavCommand::Menu) {
+        toggle_cursor_if_gyro(!visible());
         mDoAud_seStartMenu(visible() ? kSoundMenuClose : kSoundMenuOpen);
         toggle();
         return true;
@@ -113,4 +115,17 @@ bool Document::handle_nav_command(Rml::Event& event, NavCommand cmd) {
     return false;
 }
 
+void Document::toggle_cursor_if_gyro(bool cursor_enabled) {
+    if (dusk::getSettings().game.gyroMode.getValue() == GyroMode::Mouse)
+    {
+        if (cursor_enabled) {
+            ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NoMouseCursorChange;
+            SDL_ShowCursor();
+        } else {
+            ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
+            SDL_HideCursor();
+        }
+    }
+}
+
 }  // namespace dusk::ui

src/dusk/ui/document.hpp

@@ -43,6 +43,8 @@ public:
     bool pending_close() const { return mPendingClose; }
     bool closed() const { return mClosed; }
 
+    void toggle_cursor_if_gyro(bool);
+
 protected:
     virtual bool handle_nav_command(Rml::Event& event, NavCommand cmd);
 

src/dusk/ui/editor.cpp

@@ -1881,9 +1881,9 @@ EditorWindow::EditorWindow() {
         }
     });
 
-    add_tab("Flags", [this](Rml::Element* content) {
-        // TODO
-    });
+    //add_tab("Flags", [this](Rml::Element* content) {
+    //    // TODO
+    //});
 
     add_tab("Minigame", [this](Rml::Element* content) {
         auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);

src/dusk/ui/graphics_tuner.cpp

@@ -193,9 +193,9 @@ Rml::String format_graphics_setting_value(GraphicsOption option, int value) {
     return "";
 }
 
-GraphicsTuner::GraphicsTuner(GraphicsTunerProps props)
+GraphicsTuner::GraphicsTuner(GraphicsTunerProps props, bool prelaunch)
     : Document(kDocumentSource), mOption(props.option), mValueMin(props.valueMin),
-      mValueMax(props.valueMax), mDefaultValue(props.defaultValue) {
+      mValueMax(props.valueMax), mDefaultValue(props.defaultValue), mPrelaunch(prelaunch) {
     if (mDocument == nullptr) {
         return;
     }
@@ -207,7 +207,7 @@ GraphicsTuner::GraphicsTuner(GraphicsTunerProps props)
         description->SetInnerRML(escape(props.helpText));
     }
     if (auto* carouselParent = mDocument->GetElementById("carousel-container")) {
-        add_component<SteppedCarousel>(carouselParent,
+        mCarousel = &add_component<SteppedCarousel>(carouselParent,
             SteppedCarousel::Props{
                 .min = mValueMin,
                 .max = mValueMax,
@@ -281,7 +281,12 @@ bool GraphicsTuner::handle_nav_command(Rml::Event& event, NavCommand cmd) {
         pop();
         return true;
     }
-    return Document::handle_nav_command(event, cmd);
+
+    if (mCarousel && mCarousel->handle_nav_command(cmd)) {
+        return true;
+    }
+
+    return mPrelaunch ? false : Document::handle_nav_command(event, cmd);
 }
 
 void GraphicsTuner::reset_default() {

src/dusk/ui/graphics_tuner.hpp

@@ -28,9 +28,9 @@ public:
 
     bool focus() override;
     void update() override;
+    bool handle_nav_command(NavCommand cmd);
 
 private:
-    bool handle_nav_command(NavCommand cmd);
     void apply(int value);
 
     Props mProps;
@@ -59,7 +59,7 @@ struct GraphicsTunerProps {
 
 class GraphicsTuner : public Document {
 public:
-    explicit GraphicsTuner(GraphicsTunerProps props);
+    explicit GraphicsTuner(GraphicsTunerProps props, bool prelaunch);
 
     void show() override;
     void hide(bool close) override;
@@ -86,7 +86,9 @@ private:
     int mValueMax = 0;
     int mDefaultValue = 0;
     std::vector<std::unique_ptr<Component> > mComponents;
+    SteppedCarousel* mCarousel;
     Rml::Element* mRoot;
+    bool mPrelaunch;
 };
 
 }  // namespace dusk::ui

src/dusk/ui/menu_bar.cpp

@@ -42,6 +42,7 @@ MenuBar::MenuBar() : Document(kDocumentSource), mRoot(mDocument->GetElementById(
     mTabBar = std::make_unique<TabBar>(mRoot, TabBar::Props{
                                                   .onClose =
                                                       [this] {
+                                                          toggle_cursor_if_gyro(false);
                                                           mDoAud_seStartMenu(kSoundMenuClose);
                                                           hide(false);
                                                       },
@@ -203,6 +204,7 @@ bool MenuBar::handle_nav_command(Rml::Event& event, NavCommand cmd) {
         return true;
     }
     if (cmd == NavCommand::Cancel && visible()) {
+        toggle_cursor_if_gyro(false);
         mDoAud_seStartMenu(kSoundMenuClose);
         hide(false);
         return true;

src/dusk/ui/number_button.cpp

@@ -54,7 +54,7 @@ void NumberButton::set_value(Rml::String value) {
 }
 
 bool NumberButton::handle_nav_command(NavCommand cmd) {
-    if (cmd == NavCommand::Left || cmd == NavCommand::Right) {
+    if (!is_editing() && (cmd == NavCommand::Left || cmd == NavCommand::Right)) {
         const int newValue = std::clamp(
             mGetValue() + (cmd == NavCommand::Right ? mStep : -mStep), mMin, mMax);
         if (newValue != mGetValue()) {
@@ -66,4 +66,4 @@ bool NumberButton::handle_nav_command(NavCommand cmd) {
     return BaseStringButton::handle_nav_command(cmd);
 }
 
-}  // namespace dusk::ui
+}  // namespace dusk::ui

src/dusk/ui/overlay.cpp

@@ -10,6 +10,10 @@
 #include <algorithm>
 #include <dolphin/pad.h>
 
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
 namespace dusk::ui {
 namespace {
 aurora::Module Log{"dusk::ui::overlay"};
@@ -33,7 +37,7 @@ constexpr std::array<std::pair<const char*, const char*>, 3> kAutoSaveLayers{{
 
 constexpr auto kMenuNotificationDuration = std::chrono::milliseconds(2500);
 
-constexpr std::array<const char*, 4> kFpsCorners = { "tl", "tr", "bl", "br" };
+constexpr std::array<const char*, 4> kFpsCorners = {"tl", "tr", "bl", "br"};
 
 Rml::Element* create_toast(Rml::Element* parent, const Toast& toast) {
     if (toast.type == "autosave") {
@@ -130,13 +134,19 @@ Rml::String back_button_name() {
     return "Back";
 }
 
+#if defined(TARGET_ANDROID) || (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST)
+constexpr auto kMenuNotificationPrefix = "3-finger tap or";
+#else
+constexpr auto kMenuNotificationPrefix = "Press F1 or";
+#endif
+
 Rml::Element* create_menu_notification(Rml::Element* parent) {
     auto* elem = append(parent, "toast");
     elem->SetClass("menu-notification", true);
 
     auto* message = append(elem, "message");
     auto* row = append(message, "row");
-    append(row, "span")->SetInnerRML("Press F1 or");
+    append(row, "span")->SetInnerRML(kMenuNotificationPrefix);
     auto* icon = append(row, "icon");
     icon->SetClass("controller", true);
     append(row, "span")->SetInnerRML(escape(back_button_name()));
@@ -242,7 +252,8 @@ void Overlay::update() {
 
             const Uint64 now = SDL_GetPerformanceCounter();
             // Limit updates to twice per second
-            const bool refreshLabel = perfFreq == 0 || mFpsLastUpdate == 0 ||
+            const bool refreshLabel =
+                perfFreq == 0 || mFpsLastUpdate == 0 ||
                 static_cast<double>(now - mFpsLastUpdate) >= 0.5 * static_cast<double>(perfFreq);
             if (refreshLabel) {
                 mFpsLastUpdate = now;

src/dusk/ui/prelaunch.cpp

@@ -687,6 +687,8 @@ Prelaunch::Prelaunch() : Document(kDocumentSource), mRoot(mDocument->GetElementB
                 return;
             }
 
+            toggle_cursor_if_gyro(false);
+
             mDoAud_seStartMenu(kSoundPlay);
             show_menu_notification();
 

src/dusk/ui/settings.cpp

@@ -274,7 +274,7 @@ SelectButton& config_percent_select(Pane& leftPane, Pane& rightPane, ConfigVar<f
 
 template <typename T>
 void graphics_tuner_control(Window& window, Pane& leftPane, Pane& rightPane, ConfigVar<T>& var,
-    const GraphicsTunerProps& props) {
+    const GraphicsTunerProps& props, bool prelaunch) {
     leftPane.register_control(
         leftPane
             .add_select_button({
@@ -292,10 +292,10 @@ void graphics_tuner_control(Window& window, Pane& leftPane, Pane& rightPane, Con
                 .isModified = [&var] { return var.getValue() != var.getDefaultValue(); },
                 .submit = false,
             })
-            .on_nav_command([&window, props](Rml::Event&, NavCommand cmd) {
+            .on_nav_command([&window, props, prelaunch](Rml::Event&, NavCommand cmd) {
                 if (cmd == NavCommand::Confirm || cmd == NavCommand::Left ||
                     cmd == NavCommand::Right) {
-                    window.push(std::make_unique<GraphicsTuner>(props));
+                    window.push(std::make_unique<GraphicsTuner>(props, prelaunch));
                     return true;
                 }
                 return false;
@@ -551,7 +551,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .valueMin = 0,
                 .valueMax = 12,
                 .defaultValue = 0,
-            });
+            }, mPrelaunch);
         graphics_tuner_control(*this, leftPane, rightPane,
             getSettings().game.shadowResolutionMultiplier,
             GraphicsTunerProps{
@@ -561,7 +561,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .valueMin = 1,
                 .valueMax = 8,
                 .defaultValue = 1,
-            });
+            }, mPrelaunch);
 
         leftPane.add_section("Post-Processing");
         graphics_tuner_control(*this, leftPane, rightPane, getSettings().game.bloomMode,
@@ -572,7 +572,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .valueMin = static_cast<int>(BloomMode::Off),
                 .valueMax = static_cast<int>(BloomMode::Dusk),
                 .defaultValue = static_cast<int>(BloomMode::Classic),
-            });
+            }, mPrelaunch);
         graphics_tuner_control(*this, leftPane, rightPane, getSettings().game.bloomMultiplier,
             GraphicsTunerProps{
                 .option = GraphicsOption::BloomMultiplier,
@@ -581,7 +581,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .valueMin = 0,
                 .valueMax = 100,
                 .defaultValue = 100,
-            });
+            }, mPrelaunch);
 
         leftPane.add_section("Rendering");
         config_bool_select(leftPane, rightPane, getSettings().game.enableFrameInterpolation,

src/dusk/ui/string_button.cpp

@@ -24,7 +24,7 @@ void BaseStringButton::update() {
 }
 
 void BaseStringButton::start_editing() {
-    if (mInputElem != nullptr) {
+    if (is_editing()) {
         return;
     }
 
@@ -79,14 +79,14 @@ void BaseStringButton::request_stop_editing(bool commit, bool refocusRoot) {
 
 bool BaseStringButton::handle_nav_command(NavCommand cmd) {
     if (cmd == NavCommand::Confirm) {
-        if (mInputElem == nullptr) {
+        if (!is_editing()) {
             start_editing();
         } else {
             request_stop_editing(true, true);
         }
         return true;
     } else if (cmd == NavCommand::Cancel) {
-        if (mInputElem != nullptr) {
+        if (is_editing()) {
             request_stop_editing(false, true);
             return true;
         }
@@ -95,7 +95,7 @@ bool BaseStringButton::handle_nav_command(NavCommand cmd) {
 }
 
 void BaseStringButton::focus_input() {
-    if (mInputElem == nullptr) {
+    if (!is_editing()) {
         return;
     }
 
@@ -111,7 +111,7 @@ void BaseStringButton::focus_input() {
 void BaseStringButton::stop_editing(bool commit, bool refocusRoot) {
     mPendingStopEditing = false;
     mPendingInputFocusFrames = 0;
-    if (mInputElem == nullptr) {
+    if (!is_editing()) {
         return;
     }
     if (commit) {

src/dusk/ui/string_button.hpp

@@ -20,6 +20,7 @@ public:
     void request_stop_editing(bool commit, bool refocusRoot);
 
 protected:
+    bool is_editing() { return mInputElem != nullptr; }
     bool handle_nav_command(NavCommand cmd) override;
     virtual void set_value(Rml::String value) = 0;
     virtual Rml::String input_value() { return format_value(); }

src/f_ap/f_ap_game.cpp

@@ -745,7 +745,8 @@ static void duskExecute() {
     updateAutoSave();
 
     if (dusk::getSettings().game.recordingMode) {
-        Z2GetSeqMgr()->bgmAllMute(0, 0);
+        Z2GetSoundMgr()->getSeqMgr()->getParams()->moveVolume(0.0f, 0);
+        Z2GetSoundMgr()->getStreamMgr()->getParams()->moveVolume(0.0f, 0);
     }
 
     if (mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getTrigX(PAD_1)) {

src/m_Do/m_Do_graphic.cpp

@@ -1194,8 +1194,13 @@ static void trimming(view_class* param_0, view_port_class* param_1) {
     if ((y_orig_pos == 0) && (param_1->scissor.y_orig != param_1->y_orig ||
                               (param_1->scissor.height != param_1->height)))
     {
+        #if TARGET_PC
+        f32 sc_top = param_1->scissor.y_orig;
+        f32 sc_bottom = param_1->scissor.y_orig + param_1->scissor.height;
+        #else
         s32 sc_top = (int)param_1->scissor.y_orig;
         s32 sc_bottom = param_1->scissor.y_orig + param_1->scissor.height;
+        #endif
         GXSetNumChans(1);
         GXSetChanCtrl(GX_ALPHA0, GX_FALSE, GX_SRC_REG, GX_SRC_REG, 0, GX_DF_NONE, GX_AF_NONE);
         GXSetNumTexGens(0);
@@ -1224,20 +1229,20 @@ static void trimming(view_class* param_0, view_port_class* param_1) {
         GXLoadPosMtxImm(cMtx_getIdentity(), 0);
         GXClearVtxDesc();
         GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
-        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
+        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, DUSK_IF_ELSE(GX_F32, GX_RGBA4), 0);
         GXSetProjection(ortho, GX_ORTHOGRAPHIC);
         GXSetCurrentMtx(0);
         GXBegin(GX_QUADS, GX_VTXFMT0, 8);
 
         #if TARGET_PC
-        GXPosition3s16(0, 0, -5);
-        GXPosition3s16(param_1->width, 0, -5);
-        GXPosition3s16(param_1->width, sc_top, -5);
-        GXPosition3s16(0, sc_top, -5);
-        GXPosition3s16(0, sc_bottom, -5);
-        GXPosition3s16(param_1->width, sc_bottom, -5);
-        GXPosition3s16(param_1->width, param_1->height, -5);
-        GXPosition3s16(0, param_1->height, -5);
+        GXPosition3f32(0, 0, -5);
+        GXPosition3f32(param_1->width, 0, -5);
+        GXPosition3f32(param_1->width, sc_top, -5);
+        GXPosition3f32(0, sc_top, -5);
+        GXPosition3f32(0, sc_bottom, -5);
+        GXPosition3f32(param_1->width, sc_bottom, -5);
+        GXPosition3f32(param_1->width, param_1->height, -5);
+        GXPosition3f32(0, param_1->height, -5);
         #else
         GXPosition3s16(0, 0, -5);
         GXPosition3s16(FB_WIDTH, 0, -5);

src/m_Do/m_Do_main.cpp

@@ -544,7 +544,8 @@ int game_main(int argc, char* argv[]) {
     ApplyCVarOverrides(parsed_arg_options["cvar"]);
     dusk::InitializeCrashReporting();
     EnsureInitialPipelineCache(dusk::ConfigPath);
-    PADSetDefaultMapping(&defaultPadMapping);
+    // TODO: How to handle this?
+    //PADSetDefaultMapping(&defaultPadMapping, PAD_TYPE_STANDARD);
 
     {
         const auto configPathString = dusk::ConfigPath.string();