Invert First Person Aiming (#870 )

- Inverts first person aiming on either axis, for both stick and gyro controls Could be separated from gyro if desirable, but I think it makes the most sense to have it apply to both
fix going into first person with orbital cam (#923 )
2026-07-04 03:12:48 -04:00 · 2026-05-10 19:00:20 -06:00 · 2026-05-10 19:00:09 -06:00 · 2026-05-10 18:42:31 -06:00 · 2026-05-10 18:37:22 -06:00 · 2026-05-10 17:35:29 -06:00
84 changed files with 1986 additions and 299 deletions
@@ -8,7 +8,7 @@ on:
  pull_request:

 env:
-  # SCCACHE_GHA_ENABLED: "true"
+  SCCACHE_GHA_ENABLED: "true"
  RUSTC_WRAPPER: "sccache"
  SENTRY_DSN: ${{ secrets.SENTRY_DSN }}

@@ -22,7 +22,7 @@ jobs:
      matrix:
        include:
          - name: GCC x86_64
-            runner: [self-hosted, Linux]
+            runner: ubuntu-latest
            preset: gcc
            artifact_arch: x86_64
          # - name: GCC aarch64
@@ -41,7 +41,6 @@ jobs:
          submodules: recursive

      - name: Install dependencies
-        if: 'false' # disabled for self-hosted
        run: |
          sudo apt-get update
          sudo apt-get -y install ninja-build clang lld openssl libcurl4-openssl-dev \
@@ -51,8 +50,7 @@ jobs:
            libxss-dev libfuse2 libusb-1.0-0-dev libdecor-0-dev libpipewire-0.3-dev libunwind-dev

      - name: Setup sccache
-        if: 'false' # disabled for self-hosted
-        uses: mozilla-actions/sccache-action@v0.0.9
+        uses: mozilla-actions/sccache-action@v0.0.10

      - name: Print sccache stats
        run: sccache --show-stats
@@ -67,7 +65,6 @@ jobs:
        run: ci/build-appimage.sh

      - name: Upload artifacts
-        if: startsWith(github.event.ref, 'refs/tags/v')
        uses: actions/upload-artifact@v7
        with:
          name: dusk-${{env.DUSK_VERSION}}-linux-${{matrix.preset}}-${{matrix.artifact_arch}}
@@ -77,7 +74,7 @@ jobs:

  build-apple:
    name: Build Apple (${{matrix.name}})
-    runs-on: [self-hosted, macOS]
+    runs-on: macos-latest
    strategy:
      fail-fast: false
      matrix:
@@ -86,14 +83,14 @@ jobs:
            platform: macos
            preset: x-macos-ci-arm64
            artifact_name: macos-appleclang-arm64
-          # - name: AppleClang macOS x86_64
-          #   platform: macos
-          #   preset: x-macos-ci-x86_64
-          #   artifact_name: macos-appleclang-x86_64
-          # - name: AppleClang iOS arm64
-          #   platform: ios
-          #   preset: x-ios-ci
-          #   artifact_name: ios-appleclang-arm64
+          - name: AppleClang macOS x86_64
+            platform: macos
+            preset: x-macos-ci-x86_64
+            artifact_name: macos-appleclang-x86_64
+          - name: AppleClang iOS arm64
+            platform: ios
+            preset: x-ios-ci
+            artifact_name: ios-appleclang-arm64
          # - name: AppleClang tvOS arm64
          #   platform: tvos
          #   preset: x-tvos-ci
@@ -106,7 +103,6 @@ jobs:
          submodules: recursive

      - name: Install dependencies
-        if: 'false'
        run: brew install cmake ninja

      - name: Install Rust iOS target
@@ -128,7 +124,7 @@ jobs:
          rustup target add x86_64-apple-darwin

      - name: Setup sccache
-        uses: mozilla-actions/sccache-action@v0.0.9
+        uses: mozilla-actions/sccache-action@v0.0.10

      - name: Configure CMake
        run: cmake --preset ${{matrix.preset}}
@@ -137,7 +133,6 @@ jobs:
        run: cmake --build --preset ${{matrix.preset}}

      - name: Upload artifacts
-        if: startsWith(github.event.ref, 'refs/tags/v')
        uses: actions/upload-artifact@v7
        with:
          name: dusk-${{env.DUSK_VERSION}}-${{matrix.artifact_name}}
@@ -145,6 +140,73 @@ jobs:
            build/install/Dusk.app
            build/install/debug.tar.*

+  build-android:
+    name: Build Android (${{matrix.name}})
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Clang arm64-v8a
+            preset: x-android-ci-arm64
+            abi: arm64-v8a
+            artifact_arch: arm64
+            rust_target: aarch64-linux-android
+
+    env:
+      ANDROID_NDK_VERSION: "29.0.14206865"
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ninja-build
+
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v4
+
+      - name: Install Android SDK packages
+        run: sdkmanager "platforms;android-36" "build-tools;36.1.0" "ndk;${ANDROID_NDK_VERSION}"
+
+      - name: Install Rust Android target
+        run: |
+          rustup toolchain install stable
+          rustup target add ${{matrix.rust_target}}
+
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.10
+
+      - name: Configure CMake
+        run: cmake --preset ${{matrix.preset}}
+
+      - name: Build native library
+        run: cmake --build --preset ${{matrix.preset}} --target dusk
+
+      - name: Stage stripped JNI library
+        run: ANDROID_STAGE_ABIS="${{matrix.abi}}" platforms/android/scripts/stage-jni-libs.sh
+
+      - name: Build APK
+        working-directory: platforms/android
+        run: ./gradlew :app:assembleRelease --rerun-tasks
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: dusk-${{env.DUSK_VERSION}}-android-${{matrix.artifact_arch}}
+          path: platforms/android/app/build/outputs/apk/release/app-${{matrix.abi}}-release-unsigned.apk
+
  build-windows:
    name: Build Windows (${{matrix.name}})
    runs-on: ${{matrix.runner}}
@@ -154,7 +216,7 @@ jobs:
      matrix:
        include:
          - name: MSVC x86_64
-            runner: [self-hosted, Windows]
+            runner: windows-latest
            preset: msvc
            msvc_arch: amd64
            vcpkg_arch: x64
@@ -191,7 +253,6 @@ jobs:
        uses: mozilla-actions/sccache-action@v0.0.9

      - name: Install dependencies
-        if: 'false' # disabled for self-hosted
        run: |
          choco install ninja
          vcpkg install freetype:${{matrix.vcpkg_arch}}-windows-static zstd:${{matrix.vcpkg_arch}}-windows-static
@@ -203,7 +264,6 @@ jobs:
        run: cmake --build --preset x-windows-ci-${{matrix.preset}}

      - name: Upload artifacts
-        if: startsWith(github.event.ref, 'refs/tags/v')
        uses: actions/upload-artifact@v7
        with:
          name: dusk-${{env.DUSK_VERSION}}-win32-msvc-${{matrix.artifact_arch}}
@@ -115,16 +115,22 @@ 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)
 set(DUSK_SENTRY_DSN "" CACHE STRING "Sentry DSN")
 set(DUSK_SENTRY_ENVIRONMENT "development" CACHE STRING "Sentry environment")

+# Edit & Continue
+if (MSVC)
+    if ("${CMAKE_MSVC_DEBUG_INFORMATION_FORMAT}" STREQUAL "" AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "EditAndContinue")
+    endif ()
+    if (CMAKE_MSVC_DEBUG_INFORMATION_FORMAT STREQUAL "EditAndContinue")
+        add_link_options("/INCREMENTAL")
+    endif ()
+endif ()
+
 if (DUSK_MOVIE_SUPPORT)
    find_package(libjpeg-turbo 3.0 CONFIG QUIET)
    if (libjpeg-turbo_FOUND)
@@ -154,6 +160,7 @@ if (DUSK_MOVIE_SUPPORT)
            CMAKE_C_COMPILER_LAUNCHER
            CMAKE_MAKE_PROGRAM
            CMAKE_MSVC_RUNTIME_LIBRARY
+            CMAKE_MSVC_DEBUG_INFORMATION_FORMAT
            CMAKE_OSX_ARCHITECTURES
            DEPLOYMENT_TARGET
            ENABLE_ARC
@@ -370,16 +377,6 @@ if (DUSK_ENABLE_DISCORD AND NOT ANDROID AND NOT IOS AND NOT TVOS)
    list(APPEND GAME_COMPILE_DEFS DUSK_DISCORD=1)
 endif ()

-# Edit & Continue
-if (MSVC)
-    if ("${CMAKE_MSVC_DEBUG_INFORMATION_FORMAT}" STREQUAL "" AND CMAKE_BUILD_TYPE STREQUAL "Debug")
-        set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "EditAndContinue")
-    endif ()
-    if (CMAKE_MSVC_DEBUG_INFORMATION_FORMAT STREQUAL "EditAndContinue")
-        add_link_options("/INCREMENTAL")
-    endif ()
-endif ()
-
 if(ANDROID)
    list(APPEND GAME_COMPILE_DEFS TARGET_ANDROID=1)
 endif ()
@@ -447,6 +444,12 @@ target_link_libraries(dusk PRIVATE aurora::main ${GAME_LIBS} ${JSYSTEM_LINK_LIBR
 target_precompile_headers(dusk PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/include/dusk_pch.hpp>")
 if (TARGET crashpad_handler)
    add_dependencies(dusk crashpad_handler)
+    add_custom_command(TARGET dusk POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "$<TARGET_FILE:crashpad_handler>"
+            "$<TARGET_FILE_DIR:dusk>"
+        COMMENT "Copying crashpad handler"
+    )
 endif ()

 if (ANDROID)
@@ -30,7 +30,7 @@
        "CMAKE_CXX_COMPILER_LAUNCHER": "sccache",
        "DUSK_ENABLE_SENTRY_NATIVE": {
          "type": "BOOL",
-          "value": false
+          "value": true
        },
        "DUSK_SENTRY_DSN": "$env{SENTRY_DSN}",
        "DUSK_SENTRY_ENVIRONMENT": "production"
@@ -352,6 +352,31 @@
        "ANDROID_ABI": "x86_64"
      }
    },
+    {
+      "name": "x-android-ci",
+      "hidden": true,
+      "inherits": [
+        "android-base",
+        "ci"
+      ],
+      "cacheVariables": {
+        "DUSK_ENABLE_SENTRY_NATIVE": {
+          "type": "BOOL",
+          "value": false
+        }
+      }
+    },
+    {
+      "name": "x-android-ci-arm64",
+      "binaryDir": "${sourceDir}/build/android-arm64",
+      "inherits": [
+        "x-android-ci"
+      ],
+      "cacheVariables": {
+        "ANDROID_ABI": "arm64-v8a",
+        "Rust_CARGO_TARGET": "aarch64-linux-android"
+      }
+    },
    {
      "name": "x-linux-ci",
      "hidden": true,
@@ -412,6 +437,7 @@
        "x-macos-ci"
      ],
      "cacheVariables": {
+        "AURORA_DAWN_PROVIDER": "vendor",
        "CMAKE_OSX_ARCHITECTURES": "x86_64",
        "Rust_CARGO_TARGET": "x86_64-apple-darwin"
      }
@@ -555,6 +581,15 @@
        "dusk"
      ]
    },
+    {
+      "name": "x-android-ci-arm64",
+      "configurePreset": "x-android-ci-arm64",
+      "description": "(Internal) Android CI arm64-v8a",
+      "displayName": "(Internal) Android CI arm64-v8a",
+      "targets": [
+        "dusk"
+      ]
+    },
    {
      "name": "windows-msvc-debug",
      "configurePreset": "windows-msvc-debug",
@@ -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>

@@ -19,6 +19,9 @@ It aims to be as accurate as possible to the original while also providing new o
 > [!IMPORTANT]
 > Dusk does *not* provide any copyrighted assets. You must provide your own copy of the original game.

+> [!IMPORTANT]
+> At a minimum, Dusk requires a GPU with support for either D3D12, Vulkan, or Metal. Your experience with specific hardware, operating systems, and drivers may vary. In particular, older Intel iGPUs have a high likelyhood of incompatibility. We are also aware of a number of issues on devices with Adreno GPUs and are working to resolve them.
+
 ### 1. Verify your dump

 First, make sure your dump of the game is clean and supported by Dusk. You can do this by checking the SHA-1 hash of your dump against this list of supported versions:
@@ -28,20 +31,31 @@ 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

 If you'd like to build Dusk from source, please read the [build instructions](docs/building.md).

-Pull requests are welcomed! Note that we do not accept contributions that are primarily AI-generated and will close your PR if we suspect as much.
+Pull requests are welcomed! Note that we do not accept contributions that are primarily AI-generated and will close your PR if we suspect as much. Please also see the [code conventions](docs/code-conventions.md).

 # Credits

@@ -1,18 +1,26 @@
 #!/bin/bash -ex
-shopt -s extglob
+
+if [[ -n "${GITHUB_WORKSPACE:-}" ]]; then
+  cd "$GITHUB_WORKSPACE"
+fi
+
+build_dir="$PWD/build"
+linuxdeploy="$build_dir/linuxdeploy-$(uname -m).AppImage"

 # Get linuxdeploy
-cd "$RUNNER_WORKSPACE"
-curl -fOL https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-$(uname -m).AppImage
-chmod +x linuxdeploy-$(uname -m).AppImage
+mkdir -p "$build_dir"
+curl -fL "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-$(uname -m).AppImage" -o "$linuxdeploy"
+chmod +x "$linuxdeploy"

 # Build AppImage
-cd "$GITHUB_WORKSPACE"
 mkdir -p build/appdir/usr/{bin,share/{applications,icons/hicolor}}
-cp -r build/install/!(*.*) build/appdir/usr/bin
+for install_path in build/install/*; do
+  [[ "$(basename "$install_path")" == *.* ]] && continue
+  cp -r "$install_path" build/appdir/usr/bin
+done
 cp -r platforms/freedesktop/{16x16,32x32,48x48,64x64,128x128,256x256,512x512,1024x1024} build/appdir/usr/share/icons/hicolor
 cp platforms/freedesktop/dusk.desktop build/appdir/usr/share/applications

 cd build/install
-VERSION="$DUSK_VERSION" NO_STRIP=1 "$RUNNER_WORKSPACE"/linuxdeploy-$(uname -m).AppImage \
-  -l /usr/lib/x86_64-linux-gnu/libusb-1.0.so --appdir "$GITHUB_WORKSPACE"/build/appdir --output appimage
+VERSION="$DUSK_VERSION" NO_STRIP=1 "$linuxdeploy" \
+  -l /usr/lib/x86_64-linux-gnu/libusb-1.0.so --appdir "$build_dir/appdir" --output appimage
@@ -0,0 +1,13 @@
+# Code conventions for Dusk
+
+## Upstream when appropriate
+
+Bug fixes, documentation improvements, code cleanup, etc that also apply to the [original decompilation project](https://github.com/zeldaret/tp) should preferably be PR'd there.
+
+## Properly indicate Dusk-modified code
+
+When modifying original game code (i.e. in decomp) for Dusk's purposes, please clearly delineate such code as being Dusk-specific. Generally, this can be done by using `#if TARGET_PC` and keeping the original code in place. Use `#if AVOID_UB` for Undefined Behavior fixes to the original codebase.
+
+## Miscellaneous things
+
+* The original codebase makes heavy use of global `operator new` and similar overloads to allocate into a strict tree of heaps. This would cause many linkage headaches for us, so effectively all uses of `new` or `delete` in the original game code have been replaced with `JKR_NEW`, `JKR_DELETE`, or similar macros. See `JKRHeap.h` for the full list.  
@@ -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
@@ -1450,6 +1450,7 @@ set(DUSK_FILES
        src/dusk/imgui/ImGuiBloomWindow.hpp
        src/dusk/imgui/ImGuiMenuTools.cpp
        src/dusk/imgui/ImGuiMenuTools.hpp
+        src/dusk/imgui/ImGuiActorSpawner.cpp
        src/dusk/imgui/ImGuiProcessOverlay.cpp
        src/dusk/imgui/ImGuiCameraOverlay.cpp
        src/dusk/imgui/ImGuiHeapOverlay.cpp
@@ -1494,6 +1495,8 @@ set(DUSK_FILES
        src/dusk/ui/prelaunch.hpp
        src/dusk/ui/preset.cpp
        src/dusk/ui/preset.hpp
+        src/dusk/ui/reporting.cpp
+        src/dusk/ui/reporting.hpp
        src/dusk/ui/select_button.cpp
        src/dusk/ui/select_button.hpp
        src/dusk/ui/settings.cpp
@@ -5,9 +5,73 @@
  outputs = { self, nixpkgs }:
    let
      pkgs = import nixpkgs { system = "x86_64-linux"; };
+      
+      # Dependencies that are not packaged in nixpkgs:
+      aurora-src = pkgs.fetchFromGitHub {
+        owner = "encounter";
+        repo = "aurora";
+        rev = "63606a43265a3bc18dafd500ab4d7a2108f109e6";
+        hash = "sha256-xBvnAwGwNzav67Ac6oUz7RqDUwqgL2bsME3OOMn8Tqw=";
+      };
+      dawn-src = pkgs.fetchzip {
+        url = "https://github.com/encounter/dawn-build/releases/download/v20260423.175430/dawn-linux-x86_64.tar.gz";
+        hash = "sha256-HXfKTLHtMPwupnFnaflCARtXVPuS/0PoCePXidjE5xs=";
+        stripRoot = false;
+      };
+      nod-src = pkgs.fetchzip {
+        url = "https://github.com/encounter/nod/releases/download/v2.0.0-alpha.8/libnod-linux-x86_64.tar.gz";
+        hash = "sha256-mUqvLsbsqaZ+HAjMmHYPYO+MgtanGRTw7Gzn5uXR5rE=";
+        stripRoot = false;
+      };
+      # The version of imgui on nixpkgs does not map cleanly.
+      imgui-src = pkgs.fetchFromGitHub {
+        owner = "ocornut";
+        repo = "imgui";
+        rev = "v1.91.9b-docking";
+        hash = "sha256-mQOJ6jCN+7VopgZ61yzaCnt4R1QLrW7+47xxMhFRHLQ=";
+      };
+      sqlite-src = pkgs.fetchzip {
+        url = "https://sqlite.org/2026/sqlite-amalgamation-3510300.zip";
+        hash = "sha256-pNMR8zxaaqfAzQ0AQBOXMct4usdjey1Q0Gnitg06UhM=";
+      };
+      rmlui-src = pkgs.fetchzip {
+        url = "https://github.com/mikke89/RmlUi/archive/f9b8c9e2935d5df2c7dff2c190d3968e99b0c3dc.tar.gz";
+        hash = "sha256-g4O/JZUrrcseOz8o2QJRt+2CeuiLnVeuDJc906xvuIg=";
+      };
+      # Dusk Actual
      dusk = pkgs.stdenv.mkDerivation {
        name = "dusk";
        src = ./.;
+        postUnpack = ''
+          mkdir -p $sourceRoot/extern/aurora
+          cp -r ${aurora-src}/. $sourceRoot/extern/aurora/
+          chmod -R u+w $sourceRoot/extern/aurora
+          sed -i '/add_subdirectory(tests)/d' $sourceRoot/extern/aurora/CMakeLists.txt
+        '';
+        # Remove last line to re-enable tests
+        cmakeFlags = [
+          "-DFETCHCONTENT_FULLY_DISCONNECTED=ON"
+          "-DFETCHCONTENT_SOURCE_DIR_CXXOPTS=${pkgs.cxxopts.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_JSON=${pkgs.nlohmann_json.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_DAWN_PREBUILT=${dawn-src}"
+          "-DFETCHCONTENT_SOURCE_DIR_XXHASH=${pkgs.xxHash.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_FMT=${pkgs.fmt.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_TRACY=${pkgs.tracy.src}"
+          "-DAURORA_SDL3_PROVIDER=system"
+          "-DFETCHCONTENT_SOURCE_DIR_NOD_PREBUILT=${nod-src}"
+          "-DAURORA_NOD_PROVIDER=package"
+          "-DFETCHCONTENT_SOURCE_DIR_FREETYPE=${pkgs.freetype.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_ZSTD=${pkgs.zstd.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_SQLITE3=${sqlite-src}"
+          "-DFETCHCONTENT_SOURCE_DIR_IMGUI=${imgui-src}"
+          "-DFETCHCONTENT_SOURCE_DIR_RMLUI=${rmlui-src}"
+          "-DCMAKE_CROSSCOMPILING=ON" # Tests are not working as I didn't want to work through getting google's test suite working as well. This is the only guard I could find to disable it.
+        ];
+        installPhase = ''
+          mkdir -p $out/bin
+          cp dusk $out/bin/dusk
+          cp -r ./res $out/bin/res
+        '';
        nativeBuildInputs = [
          pkgs.cmake
          pkgs.pkg-config
@@ -25,6 +89,13 @@
          pkgs.libjpeg8
          pkgs.libxkbcommon
          pkgs.libglvnd
+          pkgs.cxxopts
+          pkgs.abseil-cpp
+          pkgs.sdl3
+          pkgs.fmt
+          pkgs.tracy
+          pkgs.freetype
+          pkgs.zstd
        ];
      };
    in {
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -1,8 +1,17 @@
 #pragma once

-namespace dusk {
+namespace dusk::crash_reporting {

-void InitializeCrashReporting();
-void ShutdownCrashReporting();
+enum class Consent {
+    Unavailable,
+    Unknown,
+    Given,
+    Revoked,
+};

-}  // namespace dusk
+void initialize();
+void shutdown();
+Consent get_consent();
+void set_consent(bool enabled);
+
+}  // namespace dusk::crash_reporting
@@ -1,6 +1,7 @@
 #ifndef DUSK_IO_HPP
 #define DUSK_IO_HPP

+#include <filesystem>
 #include <vector>

 // I can't believe it's 2026 and neither SDL (no error codes) nor
@@ -15,7 +16,7 @@ namespace dusk::io {
 * Methods on this class throw appropriate C++ exceptions when an error occurs.
 */
 class FileStream {
-    void* file;
+    FILE* file;

 public:
    FileStream() noexcept;
@@ -23,7 +24,7 @@ public:
    /**
     * \brief Take ownership of a FILE* handle.
     */
-    explicit FileStream(void* file);
+    explicit FileStream(FILE* file);
    FileStream(const FileStream& other) = delete;
    FileStream(FileStream&& other) noexcept;

@@ -34,6 +35,11 @@ public:
     */
    static FileStream OpenRead(const char* utf8Path);

+    /**
+     * \brief Open a file for reading at the given path.
+     */
+    static FileStream OpenRead(const std::filesystem::path& path);
+
    /**
     * \brief Create a file for writing.
     *
@@ -41,16 +47,33 @@ public:
     */
    static FileStream Create(const char* utf8Path);

+    /**
+     * \brief Create a file for writing.
+     *
+     * If there is an existing file, its contents are demolished.
+     */
+    static FileStream Create(const std::filesystem::path& path);
+
    /**
     * \brief Read the byte contents of a file directly into a vector.
     */
    static std::vector<u8> ReadAllBytes(const char* utf8Path);

+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static std::vector<u8> ReadAllBytes(const std::filesystem::path& path);
+
    /**
     * \brief Read the byte contents of a file directly into a vector.
     */
    static void WriteAllText(const char* utf8Path, std::string_view text);

+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static void WriteAllText(const std::filesystem::path& path, std::string_view text);
+
    /**
     * \brief Read the remaining contents of the file directly into a vector.
     */
@@ -59,17 +82,24 @@ public:
    /**
     * Get direct access to the underlying FILE* handle.
     */
-    [[nodiscard]] void* GetFileHandle() const noexcept {
-        return file;
-    }
+    [[nodiscard]] void* GetFileHandle() const noexcept { return file; }

    /**
     * Write data to the file.
     */
    void Write(const char* data, size_t dataLen);
+
+    FILE* ToInner();
 };

+/**
+ * Converts a std::filesystem::path to a std::string, UTF-8, without exploding on Windows.
+ */
+inline std::string fs_path_to_string(const std::filesystem::path& path) {
+    const auto u8str = path.u8string();
+    return {reinterpret_cast<const char*>(u8str.c_str())};
 }

+}  // namespace dusk::io

 #endif  // DUSK_IO_HPP
@@ -7,6 +7,14 @@

 #include <filesystem>

+#if defined(_WIN32) ||                                                                             \
+    (defined(__APPLE__) && !TARGET_OS_IOS && !TARGET_OS_TV && !TARGET_OS_MACCATALYST) ||           \
+    (defined(__linux__) && !defined(__ANDROID__))
+#define DUSK_CAN_OPEN_DATA_FOLDER 1
+#else
+#define DUSK_CAN_OPEN_DATA_FOLDER 0
+#endif
+
 namespace dusk {
    extern bool IsRunning;
    extern bool IsShuttingDown;
@@ -22,6 +30,7 @@ namespace dusk {
 #endif

    void RequestRestart() noexcept;
+    bool OpenDataFolder();
 }

 #endif  // DUSK_MAIN_H
@@ -144,6 +144,8 @@ struct UserSettings {
        ConfigVar<bool> freeCamera;
        ConfigVar<bool> invertCameraXAxis;
        ConfigVar<bool> invertCameraYAxis;
+        ConfigVar<bool> invertFirstPersonXAxis;
+        ConfigVar<bool> invertFirstPersonYAxis;
        ConfigVar<float> freeCameraSensitivity;
        ConfigVar<bool> debugFlyCam;
        ConfigVar<bool> debugFlyCamLockEvents;
@@ -184,7 +186,6 @@ struct UserSettings {
        ConfigVar<bool> skipPreLaunchUI;
        ConfigVar<bool> showPipelineCompilation;
        ConfigVar<bool> wasPresetChosen;
-        ConfigVar<bool> enableCrashReporting;
        ConfigVar<bool> checkForUpdates;
        ConfigVar<int> cardFileType;
        ConfigVar<bool> enableAdvancedSettings;
@@ -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)
@@ -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)
    }
 }
@@ -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 { *; }
@@ -24,8 +24,19 @@
        <meta-data android:name="android.game_mode_config"
            android:resource="@xml/game_mode_config" />

+        <provider
+            android:name="dev.twilitrealm.dusk.DuskDocumentsProvider"
+            android:authorities="dev.twilitrealm.dusk.documents"
+            android:exported="true"
+            android:grantUriPermissions="true"
+            android:permission="android.permission.MANAGE_DOCUMENTS">
+            <intent-filter>
+                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
+            </intent-filter>
+        </provider>
+
        <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"
@@ -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];
    }
@@ -0,0 +1,413 @@
+package dev.twilitrealm.dusk;
+
+import android.content.ContentResolver;
+import android.content.res.AssetFileDescriptor;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.ParcelFileDescriptor;
+import android.provider.DocumentsContract;
+import android.provider.DocumentsContract.Document;
+import android.provider.DocumentsContract.Root;
+import android.provider.DocumentsProvider;
+import android.webkit.MimeTypeMap;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class DuskDocumentsProvider extends DocumentsProvider {
+    public static final String AUTHORITY = "dev.twilitrealm.dusk.documents";
+
+    private static final String ROOT_ID = "dusk";
+    private static final String ROOT_DOCUMENT_ID = "root";
+    private static final String DIRECTORY_MIME_TYPE = Document.MIME_TYPE_DIR;
+
+    private static final String[] DEFAULT_ROOT_PROJECTION = new String[] {
+        Root.COLUMN_ROOT_ID,
+        Root.COLUMN_FLAGS,
+        Root.COLUMN_TITLE,
+        Root.COLUMN_DOCUMENT_ID,
+        Root.COLUMN_ICON,
+        Root.COLUMN_AVAILABLE_BYTES,
+        Root.COLUMN_SUMMARY
+    };
+
+    private static final String[] DEFAULT_DOCUMENT_PROJECTION = new String[] {
+        Document.COLUMN_DOCUMENT_ID,
+        Document.COLUMN_DISPLAY_NAME,
+        Document.COLUMN_FLAGS,
+        Document.COLUMN_MIME_TYPE,
+        Document.COLUMN_LAST_MODIFIED,
+        Document.COLUMN_SIZE
+    };
+
+    @Override
+    public boolean onCreate() {
+        ensureUserDirectories();
+        return true;
+    }
+
+    @Override
+    public Cursor queryRoots(String[] projection) throws FileNotFoundException {
+        final MatrixCursor result = new MatrixCursor(resolveRootProjection(projection));
+        final File root = getRootDirectory();
+        final MatrixCursor.RowBuilder row = result.newRow();
+
+        row.add(Root.COLUMN_ROOT_ID, ROOT_ID);
+        row.add(Root.COLUMN_FLAGS,
+            Root.FLAG_LOCAL_ONLY |
+            Root.FLAG_SUPPORTS_CREATE |
+            Root.FLAG_SUPPORTS_IS_CHILD);
+        row.add(Root.COLUMN_TITLE, getContext().getString(R.string.app_name));
+        row.add(Root.COLUMN_DOCUMENT_ID, ROOT_DOCUMENT_ID);
+        row.add(Root.COLUMN_ICON, R.mipmap.icon);
+        row.add(Root.COLUMN_AVAILABLE_BYTES, root.getFreeSpace());
+        row.add(Root.COLUMN_SUMMARY, getContext().getString(R.string.documents_provider_summary));
+
+        return result;
+    }
+
+    @Override
+    public Cursor queryDocument(String documentId, String[] projection) throws FileNotFoundException {
+        final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
+        includeDocument(result, documentId, getFileForDocumentId(documentId));
+        return result;
+    }
+
+    @Override
+    public Cursor queryChildDocuments(String parentDocumentId, String[] projection, String sortOrder)
+        throws FileNotFoundException
+    {
+        return queryChildDocumentsInternal(parentDocumentId, projection);
+    }
+
+    @Override
+    public Cursor queryChildDocuments(String parentDocumentId, String[] projection, Bundle queryArgs)
+        throws FileNotFoundException
+    {
+        return queryChildDocumentsInternal(parentDocumentId, projection);
+    }
+
+    private Cursor queryChildDocumentsInternal(String parentDocumentId, String[] projection)
+        throws FileNotFoundException
+    {
+        final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
+        final File parent = getFileForDocumentId(parentDocumentId);
+        final File[] files = parent.listFiles();
+        result.setNotificationUri(getContext().getContentResolver(), getChildDocumentsUri(parentDocumentId));
+
+        if (files == null) {
+            return result;
+        }
+
+        for (File file : files) {
+            includeDocument(result, getDocumentIdForFile(file), file);
+        }
+
+        return result;
+    }
+
+    @Override
+    public boolean isChildDocument(String parentDocumentId, String documentId) {
+        try {
+            final File parent = getFileForDocumentId(parentDocumentId);
+            final File child = getFileForDocumentId(documentId);
+            return isInside(parent, child);
+        } catch (FileNotFoundException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public String createDocument(String parentDocumentId, String mimeType, String displayName)
+        throws FileNotFoundException
+    {
+        final File parent = getFileForDocumentId(parentDocumentId);
+        if (!parent.isDirectory()) {
+            throw new FileNotFoundException("Parent is not a directory: " + parentDocumentId);
+        }
+
+        final String safeDisplayName = sanitizeDisplayName(displayName);
+        final File file = buildUniqueFile(parent, safeDisplayName);
+        final boolean created;
+        if (DIRECTORY_MIME_TYPE.equals(mimeType)) {
+            created = file.mkdir();
+        } else {
+            try {
+                created = file.createNewFile();
+            } catch (IOException e) {
+                throw asFileNotFound("Unable to create document", e);
+            }
+        }
+
+        if (!created) {
+            throw new FileNotFoundException("Unable to create document: " + displayName);
+        }
+
+        notifyChildrenChanged(parentDocumentId);
+        return getDocumentIdForFile(file);
+    }
+
+    @Override
+    public String renameDocument(String documentId, String displayName) throws FileNotFoundException {
+        final File file = getFileForDocumentId(documentId);
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            throw new FileNotFoundException("Cannot rename root document");
+        }
+
+        final File target = buildUniqueFile(file.getParentFile(), sanitizeDisplayName(displayName));
+        final String parentDocumentId = getDocumentIdForFile(file.getParentFile());
+        if (!file.renameTo(target)) {
+            throw new FileNotFoundException("Unable to rename document: " + documentId);
+        }
+        notifyDocumentChanged(documentId);
+        notifyDocumentChanged(getDocumentIdForFile(target));
+        notifyChildrenChanged(parentDocumentId);
+        return getDocumentIdForFile(target);
+    }
+
+    @Override
+    public void deleteDocument(String documentId) throws FileNotFoundException {
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            throw new FileNotFoundException("Cannot delete root document");
+        }
+
+        final File file = getFileForDocumentId(documentId);
+        final String parentDocumentId = getDocumentIdForFile(file.getParentFile());
+        deleteRecursively(file);
+        notifyDocumentChanged(documentId);
+        notifyChildrenChanged(parentDocumentId);
+    }
+
+    @Override
+    public ParcelFileDescriptor openDocument(String documentId, String mode, CancellationSignal signal)
+        throws FileNotFoundException
+    {
+        return ParcelFileDescriptor.open(getFileForDocumentId(documentId), modeToParcelMode(mode));
+    }
+
+    @Override
+    public AssetFileDescriptor openDocumentThumbnail(String documentId, android.graphics.Point sizeHint,
+        CancellationSignal signal) throws FileNotFoundException
+    {
+        throw new FileNotFoundException("Thumbnails are not supported");
+    }
+
+    private void includeDocument(MatrixCursor result, String documentId, File file) throws FileNotFoundException {
+        final MatrixCursor.RowBuilder row = result.newRow();
+        final boolean isDirectory = file.isDirectory();
+        final String displayName = ROOT_DOCUMENT_ID.equals(documentId)
+            ? getContext().getString(R.string.documents_provider_root_name)
+            : file.getName();
+
+        int flags = Document.FLAG_SUPPORTS_DELETE | Document.FLAG_SUPPORTS_RENAME;
+        if (isDirectory) {
+            flags |= Document.FLAG_DIR_SUPPORTS_CREATE;
+        } else if (file.canWrite()) {
+            flags |= Document.FLAG_SUPPORTS_WRITE;
+        }
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            flags &= ~(Document.FLAG_SUPPORTS_DELETE | Document.FLAG_SUPPORTS_RENAME);
+        }
+
+        row.add(Document.COLUMN_DOCUMENT_ID, documentId);
+        row.add(Document.COLUMN_DISPLAY_NAME, displayName);
+        row.add(Document.COLUMN_FLAGS, flags);
+        row.add(Document.COLUMN_MIME_TYPE, isDirectory ? DIRECTORY_MIME_TYPE : getMimeType(file));
+        row.add(Document.COLUMN_LAST_MODIFIED, file.lastModified());
+        row.add(Document.COLUMN_SIZE, isDirectory ? null : file.length());
+    }
+
+    private File getRootDirectory() throws FileNotFoundException {
+        final File root = getContext().getFilesDir();
+        if (root == null) {
+            throw new FileNotFoundException("Dusk files directory is unavailable");
+        }
+        return root;
+    }
+
+    private File getFileForDocumentId(String documentId) throws FileNotFoundException {
+        final File root = getRootDirectory();
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            return root;
+        }
+        if (!documentId.startsWith(ROOT_DOCUMENT_ID + "/")) {
+            throw new FileNotFoundException("Invalid document id: " + documentId);
+        }
+
+        final String relativePath = documentId.substring(ROOT_DOCUMENT_ID.length() + 1);
+        final File file = new File(root, relativePath);
+        if (!isInside(root, file)) {
+            throw new FileNotFoundException("Document escapes Dusk files directory: " + documentId);
+        }
+        if (!file.exists()) {
+            throw new FileNotFoundException("Document does not exist: " + documentId);
+        }
+        return file;
+    }
+
+    private String getDocumentIdForFile(File file) throws FileNotFoundException {
+        final File root = getRootDirectory();
+        if (sameFile(root, file)) {
+            return ROOT_DOCUMENT_ID;
+        }
+        if (!isInside(root, file)) {
+            throw new FileNotFoundException("File escapes Dusk files directory: " + file);
+        }
+
+        final String rootPath = canonicalPath(root);
+        final String filePath = canonicalPath(file);
+        return ROOT_DOCUMENT_ID + "/" + filePath.substring(rootPath.length() + 1);
+    }
+
+    private void ensureUserDirectories() {
+        final File root = getContext().getFilesDir();
+        if (root == null) {
+            return;
+        }
+        new File(root, "texture_replacements").mkdirs();
+        new File(root, "USA/Card A").mkdirs();
+        new File(root, "EUR/Card A").mkdirs();
+    }
+
+    private static String[] resolveRootProjection(String[] projection) {
+        return projection != null ? projection : DEFAULT_ROOT_PROJECTION;
+    }
+
+    private static String[] resolveDocumentProjection(String[] projection) {
+        return projection != null ? projection : DEFAULT_DOCUMENT_PROJECTION;
+    }
+
+    private static String sanitizeDisplayName(String displayName) throws FileNotFoundException {
+        if (displayName == null) {
+            throw new FileNotFoundException("Document name is empty");
+        }
+
+        final String sanitized = displayName.trim();
+        if (sanitized.isEmpty() || ".".equals(sanitized) || "..".equals(sanitized) ||
+            sanitized.contains("/") || sanitized.contains("\\"))
+        {
+            throw new FileNotFoundException("Invalid document name: " + displayName);
+        }
+        return sanitized;
+    }
+
+    private static File buildUniqueFile(File parent, String displayName) {
+        File file = new File(parent, displayName);
+        if (!file.exists()) {
+            return file;
+        }
+
+        final int dot = displayName.lastIndexOf('.');
+        final String baseName = dot > 0 ? displayName.substring(0, dot) : displayName;
+        final String extension = dot > 0 ? displayName.substring(dot) : "";
+        for (int i = 1; i < 100; ++i) {
+            file = new File(parent, baseName + " (" + i + ")" + extension);
+            if (!file.exists()) {
+                return file;
+            }
+        }
+        return new File(parent, baseName + " (" + System.currentTimeMillis() + ")" + extension);
+    }
+
+    private static int modeToParcelMode(String mode) {
+        if ("r".equals(mode)) {
+            return ParcelFileDescriptor.MODE_READ_ONLY;
+        }
+        if ("w".equals(mode) || "wt".equals(mode)) {
+            return ParcelFileDescriptor.MODE_WRITE_ONLY |
+                ParcelFileDescriptor.MODE_CREATE |
+                ParcelFileDescriptor.MODE_TRUNCATE;
+        }
+        if ("wa".equals(mode)) {
+            return ParcelFileDescriptor.MODE_WRITE_ONLY |
+                ParcelFileDescriptor.MODE_CREATE |
+                ParcelFileDescriptor.MODE_APPEND;
+        }
+        if ("rw".equals(mode)) {
+            return ParcelFileDescriptor.MODE_READ_WRITE |
+                ParcelFileDescriptor.MODE_CREATE;
+        }
+        if ("rwt".equals(mode)) {
+            return ParcelFileDescriptor.MODE_READ_WRITE |
+                ParcelFileDescriptor.MODE_CREATE |
+                ParcelFileDescriptor.MODE_TRUNCATE;
+        }
+        return ParcelFileDescriptor.MODE_READ_ONLY;
+    }
+
+    private static String getMimeType(File file) {
+        final int dot = file.getName().lastIndexOf('.');
+        if (dot >= 0) {
+            final String extension = file.getName().substring(dot + 1).toLowerCase();
+            final String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
+            if (mimeType != null) {
+                return mimeType;
+            }
+        }
+        return "application/octet-stream";
+    }
+
+    private Uri getChildDocumentsUri(String parentDocumentId) {
+        return DocumentsContract.buildChildDocumentsUri(AUTHORITY, parentDocumentId);
+    }
+
+    private void notifyChildrenChanged(String parentDocumentId) {
+        final ContentResolver resolver = getContext().getContentResolver();
+        resolver.notifyChange(getChildDocumentsUri(parentDocumentId), null, false);
+    }
+
+    private void notifyDocumentChanged(String documentId) {
+        final ContentResolver resolver = getContext().getContentResolver();
+        resolver.notifyChange(DocumentsContract.buildDocumentUri(AUTHORITY, documentId), null, false);
+    }
+
+    private static void deleteRecursively(File file) throws FileNotFoundException {
+        if (file.isDirectory()) {
+            final File[] children = file.listFiles();
+            if (children != null) {
+                for (File child : children) {
+                    deleteRecursively(child);
+                }
+            }
+        }
+        if (!file.delete()) {
+            throw new FileNotFoundException("Unable to delete document: " + file);
+        }
+    }
+
+    private static boolean isInside(File parent, File child) {
+        try {
+            final String parentPath = canonicalPath(parent);
+            final String childPath = canonicalPath(child);
+            return childPath.equals(parentPath) || childPath.startsWith(parentPath + File.separator);
+        } catch (FileNotFoundException e) {
+            return false;
+        }
+    }
+
+    private static boolean sameFile(File a, File b) {
+        try {
+            return canonicalPath(a).equals(canonicalPath(b));
+        } catch (FileNotFoundException e) {
+            return false;
+        }
+    }
+
+    private static String canonicalPath(File file) throws FileNotFoundException {
+        try {
+            return file.getCanonicalPath();
+        } catch (IOException e) {
+            throw asFileNotFound("Unable to resolve path", e);
+        }
+    }
+
+    private static FileNotFoundException asFileNotFound(String message, IOException cause) {
+        final FileNotFoundException exception = new FileNotFoundException(message + ": " + cause.getMessage());
+        exception.initCause(cause);
+        return exception;
+    }
+}
@@ -1,4 +1,4 @@
-package com.twilitrealm.dusk;
+package dev.twilitrealm.dusk;

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -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();
@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
    <string name="app_name">Dusk</string>
+    <string name="documents_provider_root_name">Dusk Data</string>
+    <string name="documents_provider_summary">Saves, texture packs, settings, and logs</string>
 </resources>
@@ -79,5 +79,11 @@
    <true/>
    <key>CADisableMinimumFrameDurationOnPhone</key>
    <true/>
+    <key>UIFileSharingEnabled</key>
+    <true/>
+    <key>LSSupportsOpeningDocumentsInPlace</key>
+    <true/>
+    <key>LSSupportsGameMode</key>
+    <true/>
 </dict>
 </plist>
@@ -28,5 +28,7 @@
 	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
 	<key>NSHighResolutionCapable</key>
 	<true/>
+	<key>LSSupportsGameMode</key>
+    <true/>
 </dict>
 </plist>
@@ -45,5 +45,7 @@
    <string>LaunchScreen</string>
    <key>UIUserInterfaceStyle</key>
    <string>Automatic</string>
+    <key>LSSupportsGameMode</key>
+    <true />
 </dict>
 </plist>
@@ -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%;
@@ -119,8 +119,8 @@ BOOL daAlink_c::setBodyAngleToCamera() {
                var_f31 /= dComIfGp_getCameraZoomScale(field_0x317c);
            }

-            shape_angle.y = shape_angle.y + (var_f31 * cM_ssin(mStickAngle));
-            sp8 = mBodyAngle.x + (var_f31 * cM_scos(mStickAngle));
+            shape_angle.y = shape_angle.y + (var_f31 * cM_ssin(mStickAngle) IF_DUSK(* (dusk::getSettings().game.invertFirstPersonXAxis ? -1.0f : 1.0f)));
+            sp8 = mBodyAngle.x + (var_f31 * cM_scos(mStickAngle) IF_DUSK(* (dusk::getSettings().game.invertFirstPersonYAxis ? -1.0f : 1.0f)));

            if (checkNotItemSinkLimit() && sp8 > 0 && sp8 > mBodyAngle.x) {
                sp8 = mBodyAngle.x;
@@ -144,8 +144,8 @@ BOOL daAlink_c::setBodyAngleToCamera() {
            f32 gy_pitch = 0.f;
            dusk::gyro::getAimDeltas(gy_yaw, gy_pitch);

-            shape_angle.y = shape_angle.y + cM_rad2s(gy_yaw * gyro_scale);
-            sp8 = sp8 + cM_rad2s(gy_pitch * gyro_scale);
+            shape_angle.y = shape_angle.y + cM_rad2s(gy_yaw * gyro_scale * (dusk::getSettings().game.invertFirstPersonXAxis ? -1.0f : 1.0f));
+            sp8 = sp8 + cM_rad2s(gy_pitch * gyro_scale * (dusk::getSettings().game.invertFirstPersonYAxis ? -1.0f : 1.0f));

            if (checkNotItemSinkLimit() && sp8 > 0 && sp8 > mBodyAngle.x) {
                sp8 = mBodyAngle.x;
@@ -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) {
@@ -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) {
@@ -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) {
@@ -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);
@@ -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;
@@ -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) {
@@ -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)) {
@@ -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;
 }
@@ -7648,7 +7648,10 @@ bool dCamera_c::freeCamera() {
    cXyz camMovement = {mPadInfo.mCStick.mLastPosX, mPadInfo.mCStick.mLastPosY, 0.0f};
    f32 magnitude = sqrt(mPadInfo.mCStick.mLastPosX * mPadInfo.mCStick.mLastPosX + mPadInfo.mCStick.mLastPosY * mPadInfo.mCStick.mLastPosY);

-    if (mPadInfo.mCStick.mLastPosX != 0 || mPadInfo.mCStick.mLastPosY != 0) {
+    // If we aren't in manual cam mode, don't trigger it if the player tries to hit C-up
+    // for first person
+    if (mPadInfo.mCStick.mLastPosX != 0 || mPadInfo.mCStick.mLastPosY < 0 ||
+        (mCamParam.mManualMode == 1 && mPadInfo.mCStick.mLastPosY != 0)) {
        mCamParam.mManualMode = 1;
        camMovement = camMovement.normalize();
        camMovement.y *= dusk::getSettings().game.invertCameraYAxis ? 1.0f : -1.0f;
@@ -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;
@@ -1030,7 +1030,7 @@ void AchievementSystem::load() {
        return;
    }
    try {
-        auto data = io::FileStream::ReadAllBytes(filePath.string().c_str());
+        auto data = io::FileStream::ReadAllBytes(filePath);
        auto j = json::parse(data);
        if (!j.is_object()) {
            return;
@@ -1067,7 +1067,7 @@ void AchievementSystem::save() {
    }
    try {
        io::FileStream::WriteAllText(
-            (dusk::ConfigPath / ACHIEVEMENTS_FILENAME).string().c_str(),
+            dusk::ConfigPath / ACHIEVEMENTS_FILENAME,
            j.dump(2)
        );
    } catch (const std::exception&) {}
@@ -23,8 +23,8 @@ aurora::Module DuskConfigLog("dusk::config");
 static absl::flat_hash_map<std::string_view, ConfigVarBase*> RegisteredConfigVars;
 static bool RegistrationDone = false;

-static std::string GetConfigJsonPath() {
-    return (dusk::ConfigPath / ConfigFileName).string();
+static std::u8string GetConfigJsonPath() {
+    return (dusk::ConfigPath / ConfigFileName).u8string();
 }

 ConfigVarBase::ConfigVarBase(const char* name, const ConfigImplBase* impl) : name(name), registered(false), layer(ConfigVarLayer::Default), impl(impl) {
@@ -189,7 +189,7 @@ void dusk::config::LoadFromUserPreferences() {
    if (configJsonPath.empty()) {
        return;
    }
-    LoadFromFileName(configJsonPath.c_str());
+    LoadFromFileName(reinterpret_cast<const char*>(configJsonPath.c_str()));
 }

 static void LoadFromPath(const char* path) {
@@ -241,7 +241,9 @@ void dusk::config::Save() {
        return;
    }

-    DuskConfigLog.info("Saving config to '{}'", configJsonPath);
+    DuskConfigLog.info(
+        "Saving config to '{}'",
+        reinterpret_cast<const char*>(configJsonPath.c_str()));

    json j;

@@ -251,7 +253,7 @@ void dusk::config::Save() {
        }
    }

-    io::FileStream::WriteAllText(configJsonPath.c_str(), j.dump(4));
+    io::FileStream::WriteAllText(reinterpret_cast<const char*>(configJsonPath.c_str()), j.dump(4));
 }

 ConfigVarBase* dusk::config::GetConfigVar(std::string_view name) {
@@ -4,7 +4,6 @@
 #include "dusk/dusk.h"
 #include "dusk/logging.h"
 #include "dusk/main.h"
-#include "dusk/settings.h"
 #include "version.h"

 #include <cstdlib>
@@ -13,114 +12,83 @@
 #include <string_view>
 #include <system_error>

-#include "SDL3/SDL_filesystem.h"
-
 #if DUSK_ENABLE_SENTRY_NATIVE
 #include <sentry.h>
 #endif

-namespace dusk {
+namespace dusk::crash_reporting {

 namespace {

 #if DUSK_ENABLE_SENTRY_NATIVE
 bool g_sentryInitialized = false;

-bool IsTruthy(std::string_view value) {
-    return value == "1" || value == "true" || value == "TRUE" || value == "yes"
-        || value == "YES" || value == "on" || value == "ON";
+bool truthy(std::string_view value) {
+    return value == "1" || value == "true" || value == "TRUE" || value == "yes" || value == "YES" ||
+           value == "on" || value == "ON";
 }

-std::string GetEnvOrEmpty(const char* name) {
+std::string env_or_empty(const char* name) {
    if (const char* value = std::getenv(name)) {
        return value;
    }
    return {};
 }

-bool GetEffectiveEnabled() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_ENABLED");
-    if (!env.empty()) {
-        return IsTruthy(env);
-    }
-    return getSettings().backend.enableCrashReporting;
+bool disabled_by_env() {
+    const std::string env = env_or_empty("DUSK_SENTRY_ENABLED");
+    return !env.empty() && !truthy(env);
 }

-std::string GetEffectiveDsn() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_DSN");
+std::string effective_dsn() {
+    const std::string env = env_or_empty("DUSK_SENTRY_DSN");
    if (!env.empty()) {
        return env;
    }
    return DUSK_SENTRY_DSN;
 }

-bool GetEffectiveDebug() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_DEBUG");
+bool effective_debug() {
+    const std::string env = env_or_empty("DUSK_SENTRY_DEBUG");
    if (!env.empty()) {
-        return IsTruthy(env);
+        return truthy(env);
    }
    return false;
 }

-std::string GetReleaseName() {
+std::string release_name() {
    return std::string(AppName) + "@" DUSK_WC_DESCRIBE;
 }

-std::filesystem::path GetSentryDatabasePath() {
+std::filesystem::path sentry_database_path() {
    return dusk::ConfigPath / "sentry";
 }

-std::filesystem::path GetLogAttachmentPath() {
+std::filesystem::path log_attachment_path() {
    if (const char* logPath = GetLogFilePath()) {
        return logPath;
    }
    return {};
 }

-std::filesystem::path GetCrashpadHandlerPath() {
-    const char* basePath = SDL_GetBasePath();
-    if (!basePath) {
-        return {};
-    }
-
-    const std::filesystem::path handlerDir(basePath);
-#if _WIN32
-    return handlerDir / "crashpad_handler.exe";
-#else
-    return handlerDir / "crashpad_handler";
-#endif
-}
-
-void ConfigurePathOptions(sentry_options_t* options) {
-    const auto databasePath = GetSentryDatabasePath();
+void configure_path_options(sentry_options_t* options) {
+    const auto databasePath = sentry_database_path();
    std::error_code ec;
    std::filesystem::create_directories(databasePath, ec);
    if (ec) {
-        DuskLog.warn("Unable to create Sentry database path '{}': {}",
-                     databasePath.string(), ec.message());
+        DuskLog.warn(
+            "Unable to create Sentry database path '{}': {}", databasePath.string(), ec.message());
    }

 #if _WIN32
    const std::wstring databasePathWide = databasePath.wstring();
    sentry_options_set_database_pathw(options, databasePathWide.c_str());
-
-    const auto handlerPath = GetCrashpadHandlerPath();
-    if (!handlerPath.empty()) {
-        const std::wstring handlerPathWide = handlerPath.wstring();
-        sentry_options_set_handler_pathw(options, handlerPathWide.c_str());
-    }
 #else
    const std::string databasePathUtf8 = databasePath.string();
    sentry_options_set_database_path(options, databasePathUtf8.c_str());
-
-    const auto handlerPath = GetCrashpadHandlerPath();
-    if (!handlerPath.empty()) {
-        const std::string handlerPathUtf8 = handlerPath.string();
-        sentry_options_set_handler_path(options, handlerPathUtf8.c_str());
-    }
 #endif

-    const auto logPath = GetLogAttachmentPath();
+    const auto logPath = log_attachment_path();
    if (!logPath.empty()) {
 #if _WIN32
        sentry_options_add_attachmentw(options, logPath.wstring().c_str());
@@ -133,32 +101,29 @@ void ConfigurePathOptions(sentry_options_t* options) {

 }  // namespace

-void InitializeCrashReporting() {
+void initialize() {
 #if DUSK_ENABLE_SENTRY_NATIVE
-    if (g_sentryInitialized) {
+    if (g_sentryInitialized || disabled_by_env()) {
        return;
    }

-    if (!GetEffectiveEnabled()) {
-        return;
-    }
-
-    const std::string dsn = GetEffectiveDsn();
+    const std::string dsn = effective_dsn();
    if (dsn.empty()) {
        DuskLog.warn("Crash reporting is enabled but no Sentry DSN is configured");
        return;
    }

-    const std::string release = GetReleaseName();
+    const std::string release = release_name();

    sentry_options_t* options = sentry_options_new();
    sentry_options_set_dsn(options, dsn.c_str());
    sentry_options_set_release(options, release.c_str());
    sentry_options_set_environment(options, DUSK_SENTRY_ENVIRONMENT);
-    sentry_options_set_debug(options, GetEffectiveDebug() ? 1 : 0);
+    sentry_options_set_debug(options, effective_debug() ? 1 : 0);
+    sentry_options_set_require_user_consent(options, 1);
    sentry_options_set_cache_keep(options, 1);
    sentry_options_set_max_breadcrumbs(options, 100);
-    ConfigurePathOptions(options);
+    configure_path_options(options);

    if (sentry_init(options) != 0) {
        DuskLog.warn("Failed to initialize Sentry crash reporting");
@@ -173,7 +138,7 @@ void InitializeCrashReporting() {
 #endif
 }

-void ShutdownCrashReporting() {
+void shutdown() {
 #if DUSK_ENABLE_SENTRY_NATIVE
    if (!g_sentryInitialized) {
        return;
@@ -184,4 +149,40 @@ void ShutdownCrashReporting() {
 #endif
 }

-}  // namespace dusk
+Consent get_consent() {
+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (!g_sentryInitialized) {
+        return Consent::Unavailable;
+    }
+
+    switch (sentry_user_consent_get()) {
+    case SENTRY_USER_CONSENT_GIVEN:
+        return Consent::Given;
+    case SENTRY_USER_CONSENT_REVOKED:
+        return Consent::Revoked;
+    case SENTRY_USER_CONSENT_UNKNOWN:
+    default:
+        return Consent::Unknown;
+    }
+#else
+    return Consent::Unavailable;
+#endif
+}
+
+void set_consent(bool enabled) {
+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (!g_sentryInitialized) {
+        return;
+    }
+
+    if (enabled) {
+        sentry_user_consent_give();
+    } else {
+        sentry_user_consent_revoke();
+    }
+#else
+    (void)enabled;
+#endif
+}
+
+}  // namespace dusk::crash_reporting
@@ -140,8 +140,8 @@ void read(float dt) {
        float my_rel = 0.0f;
        SDL_GetRelativeMouseState(&mx_rel, &my_rel);
        // Convert pixels to radians
-        s_pitch_rad = my_rel * kMousePixelToRad * getSettings().game.gyroSensitivityX;
-        s_yaw_rad = -mx_rel * kMousePixelToRad * getSettings().game.gyroSensitivityY;
+        s_pitch_rad = my_rel * kMousePixelToRad * getSettings().game.gyroSensitivityY;
+        s_yaw_rad = -mx_rel * kMousePixelToRad * getSettings().game.gyroSensitivityX;
        s_roll_rad = 0.0f;

        s_pitch_rad = getSettings().game.gyroInvertPitch ? -s_pitch_rad : s_pitch_rad;
@@ -184,7 +184,7 @@ void read(float dt) {
    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 * getSettings().game.gyroSensitivityX;
+    s_pitch_rad = -pitch_rate * dt * getSettings().game.gyroSensitivityY;
    s_roll_rad  = roll_rate * dt * getSettings().game.gyroSensitivityX; // GYRO NOTE: Exposing Z sensitivity seems unusual, so I'm just using X

    float horizontal_rate = yaw_rate;
@@ -223,7 +223,7 @@ void read(float dt) {
        }
    }

-    s_yaw_rad = horizontal_rate * dt * getSettings().game.gyroSensitivityY;
+    s_yaw_rad = horizontal_rate * dt * getSettings().game.gyroSensitivityX;

    s_pitch_rad = getSettings().game.gyroInvertPitch ? -s_pitch_rad : s_pitch_rad;
    s_yaw_rad = getSettings().game.gyroInvertYaw ? -s_yaw_rad : s_yaw_rad;
@@ -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 {
@@ -0,0 +1,142 @@
+#include "imgui.h"
+
+#include "ImGuiMenuTools.hpp"
+#include "d/actor/d_a_alink.h"
+#include "d/d_com_inf_game.h"
+#include "f_op/f_op_actor_mng.h"
+#include "SSystem/SComponent/c_sxyz.h"
+#include "SSystem/SComponent/c_xyz.h"
+
+namespace dusk {
+namespace {
+
+struct ActorSpawnerState {
+    int actorId    = 0;
+    int params     = -1;
+    int argument   = -1;
+    int angleX     = 0;
+    int angleY     = 0;
+    int angleZ     = 0;
+    float scaleX   = 1.0f;
+    float scaleY   = 1.0f;
+    float scaleZ   = 1.0f;
+    bool usePlayerRoom = true;
+    int manualRoom = 0;
+    int spawnCount = 1;
+    bool hasResult = false;
+    unsigned int lastResult = 0;
+    int lastAttempted = 0;
+};
+
+ActorSpawnerState s_state;
+
+}  // namespace
+
+void ImGuiMenuTools::ShowActorSpawner() {
+    if (!m_showActorSpawner) {
+        return;
+    }
+
+    if (!ImGui::Begin("Actor Spawner", &m_showActorSpawner)) {
+        ImGui::End();
+        return;
+    }
+
+    daAlink_c* player = (daAlink_c*)dComIfGp_getPlayer(0);
+
+    ImGui::SeparatorText("Actor");
+    ImGui::InputInt("Actor ID", &s_state.actorId);
+    ImGui::InputInt("Params (hex)", &s_state.params, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+    ImGui::InputInt("Argument", &s_state.argument);
+    s_state.argument = (s_state.argument < -128) ? -128 : (s_state.argument > 127) ? 127 : s_state.argument;
+
+    ImGui::SeparatorText("Angle");
+    ImGui::InputInt("Angle X", &s_state.angleX);
+    ImGui::InputInt("Angle Y", &s_state.angleY);
+    ImGui::InputInt("Angle Z", &s_state.angleZ);
+
+    ImGui::SeparatorText("Scale");
+    ImGui::InputFloat("Scale X", &s_state.scaleX, 0.1f, 1.0f);
+    ImGui::InputFloat("Scale Y", &s_state.scaleY, 0.1f, 1.0f);
+    ImGui::InputFloat("Scale Z", &s_state.scaleZ, 0.1f, 1.0f);
+
+    ImGui::SeparatorText("Spawn");
+    ImGui::InputInt("Count", &s_state.spawnCount);
+    if (s_state.spawnCount < 1) {
+        s_state.spawnCount = 1;
+    }
+
+    ImGui::SeparatorText("Position");
+    ImGui::Checkbox("Use player room", &s_state.usePlayerRoom);
+    if (!s_state.usePlayerRoom) {
+        ImGui::InputInt("Room No", &s_state.manualRoom);
+    }
+
+    if (player != nullptr) {
+        ImGui::Text("Spawn pos: %.2f, %.2f, %.2f",
+            player->current.pos.x, player->current.pos.y, player->current.pos.z);
+    } else {
+        ImGui::TextDisabled("Player not available");
+    }
+
+    ImGui::Separator();
+
+    bool canSpawn = player != nullptr;
+    if (!canSpawn) {
+        ImGui::BeginDisabled();
+    }
+
+    if (ImGui::Button("Spawn", ImVec2(-1, 0))) {
+        cXyz pos = player->current.pos;
+        csXyz angle;
+        angle.set((s16)s_state.angleX, (s16)s_state.angleY, (s16)s_state.angleZ);
+        cXyz scale(s_state.scaleX, s_state.scaleY, s_state.scaleZ);
+        int roomNo = s_state.usePlayerRoom ? player->current.roomNo : s_state.manualRoom;
+
+        layer_class* savedLayer = fpcLy_CurrentLayer();
+        base_process_class* playScene = fpcM_SearchByName(fpcNm_PLAY_SCENE_e);
+        if (playScene != nullptr) {
+            fpcLy_SetCurrentLayer(&((process_node_class*)playScene)->layer);
+        }
+
+        s_state.lastResult = 0;
+        s_state.lastAttempted = s_state.spawnCount;
+        for (int i = 0; i < s_state.spawnCount; ++i) {
+            unsigned int result = fopAcM_create(
+                (s16)s_state.actorId,
+                (u32)s_state.params,
+                &pos,
+                roomNo,
+                &angle,
+                &scale,
+                (s8)s_state.argument
+            );
+            if (result != 0) {
+                s_state.lastResult = result;
+            }
+        }
+        s_state.hasResult = true;
+
+        fpcLy_SetCurrentLayer(savedLayer);
+    }
+
+    if (!canSpawn) {
+        ImGui::EndDisabled();
+    }
+
+    if (s_state.hasResult) {
+        if (s_state.lastResult != 0) {
+            if (s_state.lastAttempted == 1) {
+                ImGui::Text("Spawned: proc ID %u", s_state.lastResult);
+            } else {
+                ImGui::Text("Spawned %d (last proc ID %u)", s_state.lastAttempted, s_state.lastResult);
+            }
+        } else {
+            ImGui::TextColored(ImVec4(1, 0.4f, 0.4f, 1), "Spawn failed (returned 0)");
+        }
+    }
+
+    ImGui::End();
+}
+
+}  // namespace dusk
@@ -313,7 +313,9 @@ namespace dusk {
                ImGui::PopFont();
            }
            ImGui::PushFont(ImGuiEngine::fontLarge);
-            ImGuiTextCenter("Failed to initialize any graphics backend");
+            ImGuiTextCenter("Failed to initialize any graphics backend.");
+            ImGuiTextCenter("\nYour system may be misconfigured, or your hardware may not support the required versions of any of the available backends.");
+            ImGuiTextCenter("\nA clean reinstall of Dusk may help. For further assistance, please visit #tech-support on the Twilit Realm Discord server.");
            const auto& style = ImGui::GetStyle();
            const auto retrySize = ImGui::CalcTextSize("Retry (Auto backend)");
            const auto quitSize = ImGui::CalcTextSize("Quit");
@@ -373,21 +375,22 @@ namespace dusk {
            m_menuTools.ShowAudioDebug();
            m_menuTools.ShowSaveEditor();
            m_menuTools.ShowStateShare();
+            m_menuTools.ShowActorSpawner();
        }

        // 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();
@@ -2,11 +2,9 @@
 #define DUSK_IMGUI_HPP

 #include <deque>
-#include <filesystem>
 #include <string>
 #include <string_view>

-#include <SDL3/SDL_misc.h>
 #include <aurora/aurora.h>

 #include "ImGuiMenuGame.hpp"
@@ -73,24 +71,4 @@ bool ImGuiButtonCenter(std::string_view text);
 float ImGuiScale();
 }  // namespace dusk

-#if defined(_WIN32) ||                                                                             \
-    (defined(__APPLE__) && !TARGET_OS_IOS && !TARGET_OS_TV && !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
-
 #endif  // DUSK_IMGUI_HPP
@@ -56,12 +56,12 @@ namespace dusk {
        }

        // L+R+A+Start to reset timer
-        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigStart(PAD_1)) {
+        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigZ(PAD_1)) {
            m_speedrunInfo.reset();
        }

        // L+R+A+Z to manually stop timer
-        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigZ(PAD_1)) {
+        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigY(PAD_1)) {
            if (m_speedrunInfo.m_isRunStarted) {
                m_speedrunInfo.m_endTimestamp = OSGetTime() - m_speedrunInfo.m_startTimestamp;
                m_speedrunInfo.m_isRunStarted = false;
@@ -107,6 +107,7 @@ namespace dusk {
            ImGui::MenuItem("Audio Debug", hotkeys::SHOW_AUDIO_DEBUG, &m_showAudioDebug);
            ImGui::MenuItem("Bloom", nullptr, &m_showBloomWindow);
            ImGui::MenuItem("Stub Log", nullptr, &m_showStubLog);
+            ImGui::MenuItem("Actor Spawner", nullptr, &m_showActorSpawner);

            if (!dusk::IsGameLaunched) {
                ImGui::EndDisabled();
@@ -28,6 +28,7 @@ namespace dusk {
        void ShowSaveEditor();
        void ShowStateShare();
        void ShowInputViewer();
+        void ShowActorSpawner();

    private:
 		bool m_showDebugOverlay = false;
@@ -70,6 +71,7 @@ namespace dusk {

        bool m_showInputViewer = false;
        bool m_showInputViewerGyro = false;
+        bool m_showActorSpawner = false;
        int m_inputOverlayCorner = 3;
        std::string m_controllerName;
    };
@@ -48,19 +48,18 @@ void ImGuiStateShare::onMergeFileSelected(void* userdata, const char* path, cons



-static std::string GetStatesFilePath() {
-    return (dusk::ConfigPath / STATES_FILENAME).string();
+static std::filesystem::path GetStatesFilePath() {
+    return ConfigPath / STATES_FILENAME;
 }

 void ImGuiStateShare::loadStatesFile() {
    m_loaded = true;
-    const std::filesystem::path filePath = dusk::ConfigPath / STATES_FILENAME;
+    const std::filesystem::path filePath = GetStatesFilePath();
    if (!std::filesystem::exists(filePath)) {
        return;
    }
    try {
-        const std::string pathStr = filePath.string();
-        auto data = io::FileStream::ReadAllBytes(pathStr.c_str());
+        auto data = io::FileStream::ReadAllBytes(filePath);
        auto j = json::parse(data);
        if (!j.is_array()) {
            return;
@@ -85,7 +84,7 @@ void ImGuiStateShare::saveStatesFile() {
        j.push_back(json{{"name", s.name}, {"data", s.encoded}});
    }
    try {
-        io::FileStream::WriteAllText(GetStatesFilePath().c_str(), j.dump(2));
+        io::FileStream::WriteAllText(GetStatesFilePath(), j.dump(2));
    } catch (const std::exception& e) {
        m_statusMsg = fmt::format("Failed to save states: {}", e.what());
    }
@@ -1,7 +1,8 @@
-#include "dusk/io.hpp"
 #include <cstdio>
 #include <filesystem>

+#include "dusk/io.hpp"
+
 using namespace dusk::io;

 #if _WIN32
@@ -58,7 +59,7 @@ static FILE* OpenCore(const char* path, const MODE_TYPE* mode) {
 FileStream::FileStream() noexcept : file(nullptr) {
 }

-FileStream::FileStream(void* file) : file(file) {
+FileStream::FileStream(FILE* file) : file(file) {
    if (!file) {
        CRASH("Invalid file handle");
    }
@@ -78,10 +79,18 @@ FileStream FileStream::OpenRead(const char* utf8Path) {
    return FileStream(OpenCore(utf8Path, MODE("rb")));
 }

+FileStream FileStream::OpenRead(const std::filesystem::path& path) {
+    return FileStream(OpenCore(path, MODE("rb")));
+}
+
 FileStream FileStream::Create(const char* utf8Path) {
    return FileStream(OpenCore(utf8Path, MODE("wb")));
 }

+FileStream FileStream::Create(const std::filesystem::path& path) {
+    return FileStream(OpenCore(path, MODE("wb")));
+}
+
 std::vector<u8> FileStream::ReadFull() {
    const auto fileHandle = ThrowIfNotOpen(*this);

@@ -128,7 +137,11 @@ std::vector<u8> FileStream::ReadFull() {
 }

 std::vector<u8> FileStream::ReadAllBytes(const char* utf8Path) {
-    auto handle = OpenRead(utf8Path);
+    return ReadAllBytes(reinterpret_cast<const char8_t*>(utf8Path));
+}
+
+std::vector<u8> FileStream::ReadAllBytes(const std::filesystem::path& path) {
+    auto handle = OpenRead(path);
    return std::move(handle.ReadFull());
 }

@@ -142,6 +155,16 @@ void FileStream::Write(const char* data, size_t dataLen) {
 }

 void FileStream::WriteAllText(const char* utf8Path, const std::string_view text) {
-    auto handle = Create(utf8Path);
+    WriteAllText(reinterpret_cast<const char8_t*>(utf8Path), text);
+}
+
+void FileStream::WriteAllText(const std::filesystem::path& path, const std::string_view text) {
+    auto handle = Create(path);
    handle.Write(text.data(), text.size());
 }
+
+FILE* FileStream::ToInner() {
+    auto handle = file;
+    file = nullptr;
+    return handle;
+}
@@ -9,6 +9,8 @@
 #include <stdexcept>
 #include <string_view>

+#include "dusk/logging.h"
+
 namespace {

 constexpr uint8_t hex_nibble_to_u8(char c) {
@@ -42,6 +44,18 @@ constexpr XXH128_hash_t parse_xxh128(std::string_view hex) {
    };
 }

+const char* verification_state_name(dusk::DiscVerificationState state) noexcept {
+    switch (state) {
+    case dusk::DiscVerificationState::Success:
+        return "verified";
+    case dusk::DiscVerificationState::HashMismatch:
+        return "hash mismatch";
+    case dusk::DiscVerificationState::Unknown:
+    default:
+        return "unknown";
+    }
+}
+
 }  // namespace

 namespace dusk::iso {
@@ -248,4 +262,10 @@ bool isPal(const char* path) {
    DiscInfo info{};
    return inspect(path, info) == ValidationError::Success && info.isPal;
 }
+
+void log_verification_state(std::string_view path, DiscVerificationState state) {
+    const std::string pathText = path.empty() ? "<none>" : std::string(path);
+    DuskLog.info(
+        "Disc verification status: {} (path: {})", verification_state_name(state), pathText);
+}
 }  // namespace dusk::iso
@@ -31,6 +31,7 @@ struct DiscInfo {
 ValidationError inspect(const char* path, DiscInfo& info);
 ValidationError validate(const char* path, VerificationStatus& status, DiscInfo& info);
 bool isPal(const char* path);
+void log_verification_state(std::string_view path, DiscVerificationState state);

 }  // namespace dusk::iso

@@ -8,6 +8,7 @@
 #include <mutex>
 #include <string>

+#include "dusk/io.hpp"
 #include "tracy/Tracy.hpp"

 #if TARGET_ANDROID
@@ -40,7 +41,7 @@ std::atomic g_logStateAlive(true);
 struct LogState {
    std::mutex mutex;
    FILE* file = nullptr;
-    std::string filePath;
+    std::u8string filePath;

    ~LogState() {
        CloseFile();
@@ -207,19 +208,19 @@ void dusk::InitializeFileLogging(const std::filesystem::path& configDir, AuroraL
    std::filesystem::create_directories(logsDir, ec);
    if (ec) {
        std::fprintf(stderr, "[WARNING | dusk] Failed to create log directory '%s': %s\n",
-                     logsDir.string().c_str(), ec.message().c_str());
+            io::fs_path_to_string(logsDir).c_str(), ec.message().c_str());
        return;
    }

    const std::filesystem::path logPath = logsDir / MakeTimestampedLogName();
-    g_logState.file = std::fopen(logPath.string().c_str(), "wb");
+    g_logState.file = io::FileStream::Create(logPath).ToInner();
    if (g_logState.file == nullptr) {
        std::fprintf(stderr, "[WARNING | dusk] Failed to open log file '%s'\n",
-                     logPath.string().c_str());
+            io::fs_path_to_string(logPath).c_str());
        return;
    }

-    g_logState.filePath = logPath.string();
+    g_logState.filePath = logPath.u8string();
    aurora::g_config.logCallback = &aurora_log_callback;
    aurora::g_config.logLevel = logLevel;
    WriteLogLine(g_logState.file, "INFO", "dusk", "File logging initialized", 24);
@@ -237,5 +238,6 @@ const char* dusk::GetLogFilePath() {
        return nullptr;
    }
    std::lock_guard lock(g_logState.mutex);
-    return g_logState.filePath.empty() ? nullptr : g_logState.filePath.c_str();
+    return reinterpret_cast<const char*>(
+        g_logState.filePath.empty() ? nullptr : g_logState.filePath.c_str());
 }
@@ -6,6 +6,7 @@

 #include <aurora/main.h>
 #include "dusk/main.h"
+#include "dusk/io.hpp"

 #include <algorithm>
 #include <array>
@@ -91,7 +92,7 @@ bool RestartProcess(int argc, char* argv[]) {

    std::vector<std::string> args;
    args.reserve(static_cast<size_t>(std::max(argc, 1)));
-    args.push_back(executablePath.string());
+    args.push_back(dusk::io::fs_path_to_string(executablePath));
    for (int i = 1; i < argc; ++i) {
        args.emplace_back(argv[i] != nullptr ? argv[i] : "");
    }
@@ -81,6 +81,8 @@ UserSettings g_userSettings = {
        .freeCamera {"game.freeCamera", false},
        .invertCameraXAxis {"game.invertCameraXAxis", false},
        .invertCameraYAxis {"game.invertCameraYAxis", false},
+        .invertFirstPersonXAxis {"game.invertFirstPersonXAxis", false},
+        .invertFirstPersonYAxis {"game.invertFirstPersonYAxis", false},
        .freeCameraSensitivity {"game.freeCameraSensitivity", 1.0f},
        .debugFlyCam {"game.debugFlyCam", false},
        .debugFlyCamLockEvents {"game.debugFlyCamLockEvents", true},
@@ -121,7 +123,6 @@ UserSettings g_userSettings = {
        .skipPreLaunchUI {"backend.skipPreLaunchUI", false},
        .showPipelineCompilation {"backend.showPipelineCompilation", false},
        .wasPresetChosen {"backend.wasPresetChosen", false},
-        .enableCrashReporting {"backend.enableCrashReporting", true},
        .checkForUpdates {"backend.checkForUpdates", true},
        .cardFileType {"backend.cardFileType", static_cast<int>(CARD_GCIFOLDER)},
        .enableAdvancedSettings {"backend.enableAdvancedSettings", false},
@@ -171,6 +172,8 @@ void registerSettings() {
    Register(g_userSettings.game.enableMirrorMode);
    Register(g_userSettings.game.invertCameraXAxis);
    Register(g_userSettings.game.invertCameraYAxis);
+    Register(g_userSettings.game.invertFirstPersonXAxis);
+    Register(g_userSettings.game.invertFirstPersonYAxis);
    Register(g_userSettings.game.freeCameraSensitivity);
    Register(g_userSettings.game.minimalHUD);
    Register(g_userSettings.game.pauseOnFocusLost);
@@ -228,7 +231,6 @@ void registerSettings() {
    Register(g_userSettings.backend.skipPreLaunchUI);
    Register(g_userSettings.backend.showPipelineCompilation);
    Register(g_userSettings.backend.wasPresetChosen);
-    Register(g_userSettings.backend.enableCrashReporting);
    Register(g_userSettings.backend.checkForUpdates);
    Register(g_userSettings.backend.cardFileType);
    Register(g_userSettings.backend.enableAdvancedSettings);
@@ -208,7 +208,15 @@ bool input_neutral(int port) {
 bool keyboard_escape_pressed() {
    int keyCount = 0;
    const bool* keys = SDL_GetKeyboardState(&keyCount);
-    return keys != nullptr && SDL_SCANCODE_ESCAPE < keyCount && keys[SDL_SCANCODE_ESCAPE];
+    if (keys == nullptr || SDL_SCANCODE_ESCAPE >= keyCount || !keys[SDL_SCANCODE_ESCAPE]) {
+        return false;
+    }
+    for (int i = 0; i < keyCount; ++i) {
+        if (i != SDL_SCANCODE_ESCAPE && keys[i]) {
+            return false;
+        }
+    }
+    return true;
 }

 Rml::String keyboard_key_name(s32 scancode) {
@@ -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
@@ -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);

@@ -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);
@@ -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() {
@@ -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
@@ -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;
@@ -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
@@ -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;
@@ -302,9 +302,17 @@ std::string get_error_msg(iso::ValidationError error) {
 }

 void persist_disc_choice(const std::string& path, iso::ValidationError validation) {
+    const auto previousPath = getSettings().backend.isoPath.getValue();
+    const auto previousVerification = getSettings().backend.isoVerification.getValue();
+    const auto verification = verification_to_config(validation);
+
    getSettings().backend.isoPath.setValue(path);
-    getSettings().backend.isoVerification.setValue(verification_to_config(validation));
+    getSettings().backend.isoVerification.setValue(verification);
    config::Save();
+
+    if (previousPath != path || previousVerification != verification) {
+        iso::log_verification_state(path, verification);
+    }
 }

 void apply_valid_disc_result(
@@ -687,6 +695,8 @@ Prelaunch::Prelaunch() : Document(kDocumentSource), mRoot(mDocument->GetElementB
                return;
            }

+            toggle_cursor_if_gyro(false);
+
            mDoAud_seStartMenu(kSoundPlay);
            show_menu_notification();

@@ -33,6 +33,7 @@ void applyPresetDusk() {
    s.game.fastTears.setValue(true);
    s.game.biggerWallets.setValue(true);
    s.game.invertCameraXAxis.setValue(true);
+    s.game.invertFirstPersonYAxis.setValue(true);
    s.game.no2ndFishForCat.setValue(true);
    s.game.enableAchievementToasts.setValue(true);
    s.game.enableControllerToasts.setValue(true);
@@ -0,0 +1,113 @@
+#if DUSK_ENABLE_SENTRY_NATIVE
+
+#include "reporting.hpp"
+
+#include "button.hpp"
+#include "dusk/crash_reporting.h"
+#include "ui.hpp"
+
+#include <dolphin/gx/GXAurora.h>
+
+namespace dusk::ui {
+
+CrashReportWindow::CrashReportWindow() : WindowSmall("modal", "modal-dialog") {
+    mDialog->SetClass("modal-dialog", true);
+
+    auto* header = append(mDialog, "div");
+    header->SetClass("modal-header", true);
+
+    auto* title = append(header, "div");
+    title->SetClass("modal-title", true);
+    title->SetInnerRML("Send Crash Reports");
+
+    auto* headIcon = append(header, "icon");
+    headIcon->SetClass("question-mark", true);
+
+    auto* intro = append(mDialog, "div");
+    intro->SetClass("modal-body", true);
+    intro->SetInnerRML(
+        "Dusk can automatically send crash reports to the developers. Crash reports contain the "
+        "following:"
+        "<br/>• Operating system version<br/>• CPU architecture<br/>• GPU model & driver version"
+        "<br/>• File paths (may include account username)<br/>• Stack trace<br/><br/>"
+        "This can be changed in the Settings menu at any time.");
+
+    auto* grid = append(mDialog, "div");
+    grid->SetClass("preset-grid", true);
+
+    struct OptionInfo {
+        const char* name;
+        const char* desc;
+        void (*apply)();
+    };
+
+    static constexpr OptionInfo kOptions[] = {
+        {"Enable",
+            "Send crash reports to Dusk developers. Reports will include the information described "
+            "above.",
+            [] { crash_reporting::set_consent(true); }},
+        {"Disable",
+            "Do not send crash reports. This may make it more difficult to resolve issues you "
+            "encounter.",
+            [] { crash_reporting::set_consent(false); }},
+    };
+
+    for (const auto& option : kOptions) {
+        auto* col = append(grid, "div");
+        col->SetClass("preset-col", true);
+
+        auto btn = std::make_unique<Button>(col, Rml::String(option.name));
+        btn->on_nav_command([this, apply = option.apply](Rml::Event&, NavCommand cmd) {
+            if (cmd == NavCommand::Confirm) {
+                apply();
+                hide(true);
+                return true;
+            }
+            return false;
+        });
+        mButtons.push_back(std::move(btn));
+
+        auto* desc = append(col, "div");
+        desc->SetClass("preset-desc", true);
+        desc->SetInnerRML(option.desc);
+    }
+}
+
+bool CrashReportWindow::focus() {
+    if (!mButtons.empty()) {
+        return mButtons.back()->focus();
+    }
+    return false;
+}
+
+bool CrashReportWindow::handle_nav_command(Rml::Event& event, NavCommand cmd) {
+    if (cmd == NavCommand::Cancel || cmd == NavCommand::Menu) {
+        return true;
+    }
+    int direction = 0;
+    if (cmd == NavCommand::Left) {
+        direction = -1;
+    } else if (cmd == NavCommand::Right) {
+        direction = 1;
+    } else {
+        return false;
+    }
+    auto* target = event.GetTargetElement();
+    for (int i = 0; i < static_cast<int>(mButtons.size()); ++i) {
+        if (mButtons[i]->contains(target)) {
+            const int next = i + direction;
+            if (next >= 0 && next < static_cast<int>(mButtons.size())) {
+                if (mButtons[next]->focus()) {
+                    mDoAud_seStartMenu(kSoundItemFocus);
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    return false;
+}
+
+}  // namespace dusk::ui
+
+#endif
@@ -0,0 +1,28 @@
+#pragma once
+
+#if DUSK_ENABLE_SENTRY_NATIVE
+
+#include "component.hpp"
+#include "window.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace dusk::ui {
+
+class CrashReportWindow : public WindowSmall {
+public:
+    CrashReportWindow();
+
+    bool focus() override;
+
+protected:
+    bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
+
+private:
+    std::vector<std::unique_ptr<Component>> mButtons;
+};
+
+}  // namespace dusk::ui
+
+#endif
@@ -9,6 +9,7 @@
 #include "dusk/file_select.hpp"
 #include "dusk/imgui/ImGuiEngine.hpp"
 #include "dusk/livesplit.h"
+#include "dusk/main.h"
 #include "graphics_tuner.hpp"
 #include "m_Do/m_Do_main.h"
 #include "menu_bar.hpp"
@@ -18,6 +19,10 @@
 #include "prelaunch.hpp"
 #include "ui.hpp"

+#if DUSK_ENABLE_SENTRY_NATIVE
+#include "dusk/crash_reporting.h"
+#endif
+
 #include <algorithm>

 namespace dusk::ui {
@@ -274,7 +279,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 +297,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 +556,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 +566,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 +577,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 +586,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,
@@ -640,6 +645,10 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
        config_percent_select(leftPane, rightPane, getSettings().game.freeCameraSensitivity,
            "Free Camera Sensitivity", "Adjusts twin-stick camera sensitivity.", 50, 200, 5,
            [] { return !getSettings().game.freeCamera; });
+        addOption("Invert First Person X Axis", getSettings().game.invertFirstPersonXAxis,
+            "Invert horizontal movement while aiming with items or first person camera. Applies to both stick and gyro aiming.");
+        addOption("Invert First Person Y Axis", getSettings().game.invertFirstPersonYAxis,
+            "Invert vertical movement while aiming with items or first person camera. Applies to both stick and gyro aiming.");

        leftPane.add_section("Gyro");
        leftPane.register_control(
@@ -946,6 +955,18 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
        auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);

        leftPane.add_section("Dusk");
+#if DUSK_CAN_OPEN_DATA_FOLDER
+        leftPane.register_control(
+            leftPane.add_button("Open Data Folder").on_pressed([] {
+                mDoAud_seStartMenu(kSoundClick);
+                dusk::OpenDataFolder();
+            }),
+            rightPane, [](Pane& pane) {
+                pane.add_text(
+                    "Open the folder where Dusk stores settings, saves, logs, texture "
+                    "replacements, and other app data.");
+            });
+#endif
        leftPane.register_control(
            leftPane.add_select_button({
                .key = "Notifications",
@@ -1011,16 +1032,24 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                pane.add_rml("<br/>Choose which notifications can be displayed.");
            });
 #if DUSK_ENABLE_SENTRY_NATIVE
-        config_bool_select(leftPane, rightPane, getSettings().backend.enableCrashReporting,
-            {.key = "Crash Reporting",
-                .helpText = "Enable automatic reporting of crashes to the developers.<br/><br/>"
-                            "Submissions include logs which may contain sensitive information. "
-                            "Refrain from "
-                            "enabling reporting if you do not agree with the following "
-                            "inclusions:<br/><br/> "
-                            "- Operating System<br/>- CPU Architecture<br/>- GPU Model & Driver "
-                            "Version<br/>"
-                            "- Account Username"});
+        auto& crashReporting = leftPane.add_child<BoolButton>(BoolButton::Props{
+            .key = "Crash Reporting",
+            .getValue =
+                [] { return crash_reporting::get_consent() == crash_reporting::Consent::Given; },
+            .setValue = [](bool enabled) { crash_reporting::set_consent(enabled); },
+            .isDisabled =
+                [] {
+                    return crash_reporting::get_consent() == crash_reporting::Consent::Unavailable;
+                },
+            .isModified = [] { return false; },
+        });
+        leftPane.register_control(crashReporting, rightPane, [](Pane& pane) {
+            pane.clear();
+            pane.add_rml("Dusk can automatically send crash reports to the developers. Crash "
+                         "reports contain the following:<br/>• Operating system version<br/>• CPU "
+                         "architecture<br/>• GPU model & driver version<br/>• File paths (may "
+                         "include account username)<br/>• Stack trace");
+        });
 #endif
        config_bool_select(leftPane, rightPane, getSettings().backend.skipPreLaunchUI,
            {
@@ -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) {
@@ -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(); }
@@ -11,6 +11,7 @@
 #include <ranges>

 #include "aurora/lib/window.hpp"
+#include "dusk/io.hpp"
 #include "input.hpp"
 #include "prelaunch.hpp"
 #include "window.hpp"
@@ -19,7 +20,7 @@ namespace dusk::ui {
 namespace {

 void load_font(const char* filename, bool fallback = false) {
-    Rml::LoadFontFace(resource_path(filename).string(), fallback);
+    Rml::LoadFontFace(io::fs_path_to_string(resource_path(filename)), fallback);
 }

 bool sInitialized = false;
@@ -740,12 +740,20 @@ static void fapGm_AfterRecord() {
    fapGm_After();
 }

+BOOL isRecording = false;
+
 static void duskExecute() {
    handleGamepadColor();
    updateAutoSave();

    if (dusk::getSettings().game.recordingMode) {
-        Z2GetSeqMgr()->bgmAllMute(0, 0);
+        Z2GetSoundMgr()->getSeqMgr()->getParams()->moveVolume(0.0f, 0);
+        Z2GetSoundMgr()->getStreamMgr()->getParams()->moveVolume(0.0f, 0);
+        isRecording = true;
+    } else if (isRecording) {
+        Z2GetSoundMgr()->getSeqMgr()->getParams()->moveVolume(1.0f, 0);
+        Z2GetSoundMgr()->getStreamMgr()->getParams()->moveVolume(1.0f, 0);
+        isRecording = false;
    }

    if (mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getTrigX(PAD_1)) {
@@ -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);
@@ -71,18 +71,28 @@
 #include <dolphin/dvd.h>

 #include "SDL3/SDL_filesystem.h"
+#include "SDL3/SDL_iostream.h"
+#include "SDL3/SDL_misc.h"
 #include "cxxopts.hpp"
 #include "d/actor/d_a_movie_player.h"
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/audio/DuskDsp.hpp"
 #include "dusk/config.hpp"
 #include "dusk/settings.h"
+#include "dusk/io.hpp"
 #include "dusk/version.hpp"
 #include "dusk/discord_presence.hpp"
 #include "tracy/Tracy.hpp"
 #include "f_pc/f_pc_draw.h"
 #include "tracy/Tracy.hpp"
 #include <RmlUi/Core.h>
+#ifdef __APPLE__
+#include <TargetConditionals.h>
+#endif
+
+#if DUSK_ENABLE_SENTRY_NATIVE
+#include "dusk/ui/reporting.hpp"
+#endif

 // --- GLOBALS ---
 s8 mDoMain::developmentMode = -1;
@@ -114,6 +124,32 @@ void dusk::RequestRestart() noexcept {
    IsRunning = false;
 }

+bool dusk::OpenDataFolder() {
+#if DUSK_CAN_OPEN_DATA_FOLDER
+    std::error_code ec;
+    std::filesystem::path path = std::filesystem::absolute(ConfigPath, ec);
+    if (ec) {
+        DuskLog.warn("Failed to resolve absolute data folder path '{}': {}",
+            io::fs_path_to_string(ConfigPath), ec.message());
+        path = ConfigPath;
+    }
+
+#if defined(_WIN32)
+    const std::string url = "file:///" + path.generic_string();
+#else
+    const std::string url = "file://" + path.generic_string();
+#endif
+    if (!SDL_OpenURL(url.c_str())) {
+        DuskLog.warn(
+            "Failed to open data folder '{}': {}", io::fs_path_to_string(path), SDL_GetError());
+        return false;
+    }
+    return true;
+#else
+    return false;
+#endif
+}
+
 s32 LOAD_COPYDATE(void*) {
    char buffer[32];
    memset(buffer, 0, sizeof(buffer));
@@ -392,13 +428,77 @@ static void ApplyCVarOverrides(const cxxopts::OptionValue& option) {
    }
 }

-static std::filesystem::path CalculateConfigPath() {
+static void migrate_directory(const std::filesystem::path& from, const std::filesystem::path& to) {
+    std::error_code ec;
+    std::filesystem::create_directories(to, ec);
+    if (ec) {
+        return;
+    }
+
+    for (std::filesystem::recursive_directory_iterator it(
+             from, std::filesystem::directory_options::skip_permission_denied, ec);
+        it != std::filesystem::recursive_directory_iterator(); it.increment(ec))
+    {
+        if (ec) {
+            return;
+        }
+
+        const auto relativePath = std::filesystem::relative(it->path(), from, ec);
+        if (ec) {
+            return;
+        }
+
+        const auto targetPath = to / relativePath;
+        if (it->is_directory(ec)) {
+            std::filesystem::create_directories(targetPath, ec);
+            if (ec) {
+                return;
+            }
+        } else if (it->is_regular_file(ec) && !std::filesystem::exists(targetPath, ec)) {
+            std::filesystem::create_directories(targetPath.parent_path(), ec);
+            if (ec) {
+                return;
+            }
+            std::filesystem::copy_file(
+                it->path(), targetPath, std::filesystem::copy_options::skip_existing, ec);
+            if (ec) {
+                return;
+            }
+        }
+    }
+}
+
+static std::filesystem::path calculate_config_path() {
+#ifdef __APPLE__
+#if TARGET_OS_IOS && !TARGET_OS_TV
+    const char* documentsPath = SDL_GetUserFolder(SDL_FOLDER_DOCUMENTS);
+    if (!documentsPath) {
+        DuskLog.fatal("Unable to get iOS Documents path: {}", SDL_GetError());
+    }
+
+    std::filesystem::path configPath = reinterpret_cast<const char8_t*>(documentsPath);
+
+    char* oldPrefPath = SDL_GetPrefPath(dusk::OrgName, dusk::AppName);
+    if (oldPrefPath) {
+        const std::filesystem::path oldConfigPath = reinterpret_cast<const char8_t*>(oldPrefPath);
+        SDL_free(oldPrefPath);
+
+        std::error_code ec;
+        if (oldConfigPath != configPath && std::filesystem::exists(oldConfigPath, ec)) {
+            migrate_directory(oldConfigPath, configPath);
+        }
+    }
+
+    return configPath;
+#endif
+#endif
+
    const auto result = SDL_GetPrefPath(dusk::OrgName, dusk::AppName);
    if (!result) {
        DuskLog.fatal("Unable to get PrefPath: {}", SDL_GetError());
    }

-    return result;
+    return reinterpret_cast<const char8_t*>(result);
 }

 static void EnsureInitialPipelineCache(const std::filesystem::path& configDir) {
@@ -411,16 +511,21 @@ static void EnsureInitialPipelineCache(const std::filesystem::path& configDir) {
        return;
    }

-    const char* basePath = SDL_GetBasePath();
-    if (basePath == nullptr) {
-        DuskLog.warn("Unable to resolve base path while seeding pipeline cache: {}", SDL_GetError());
-        return;
-    }
+    std::string sourcePathString;
+    SDL_IOStream* source = nullptr;

-    const std::filesystem::path initialPipelineCachePath =
-        std::filesystem::path(basePath) / "initial_pipeline_cache.db";
-    if (!std::filesystem::exists(initialPipelineCachePath)) {
-        DuskLog.info("No bundled initial pipeline cache found at '{}'", initialPipelineCachePath.string());
+    const char* basePath = SDL_GetBasePath();
+    if (basePath != nullptr) {
+        sourcePathString = dusk::io::fs_path_to_string(
+            std::filesystem::path(basePath) / "initial_pipeline_cache.db");
+        source = SDL_IOFromFile(sourcePathString.c_str(), "rb");
+    }
+    if (source == nullptr) {
+        sourcePathString = "initial_pipeline_cache.db";
+        source = SDL_IOFromFile(sourcePathString.c_str(), "rb");
+    }
+    if (source == nullptr) {
+        DuskLog.info("No bundled initial pipeline cache found");
        return;
    }

@@ -428,18 +533,68 @@ static void EnsureInitialPipelineCache(const std::filesystem::path& configDir) {
    std::filesystem::create_directories(configDir, ec);
    if (ec) {
        DuskLog.warn("Failed to create config directory '{}' for pipeline cache: {}",
-                     configDir.string(), ec.message());
+            dusk::io::fs_path_to_string(configDir), ec.message());
+        SDL_CloseIO(source);
        return;
    }

-    std::filesystem::copy_file(initialPipelineCachePath, pipelineCachePath, std::filesystem::copy_options::none, ec);
-    if (ec) {
-        DuskLog.warn("Failed to seed pipeline cache from '{}' to '{}': {}",
-                     initialPipelineCachePath.string(), pipelineCachePath.string(), ec.message());
+    const auto pipelineCacheString = dusk::io::fs_path_to_string(pipelineCachePath);
+    SDL_IOStream* destination = SDL_IOFromFile(pipelineCacheString.c_str(), "wb");
+    if (destination == nullptr) {
+        DuskLog.warn("Failed to open '{}' for seeded pipeline cache: {}", pipelineCacheString,
+            SDL_GetError());
+        SDL_CloseIO(source);
        return;
    }

-    DuskLog.info("Seeded pipeline cache from '{}'", initialPipelineCachePath.string());
+    bool copied = true;
+    std::array<char, 64 * 1024> buffer{};
+    while (true) {
+        const size_t bytesRead = SDL_ReadIO(source, buffer.data(), buffer.size());
+        if (bytesRead > 0) {
+            size_t bytesWritten = 0;
+            while (bytesWritten < bytesRead) {
+                const size_t written = SDL_WriteIO(
+                    destination, buffer.data() + bytesWritten, bytesRead - bytesWritten);
+                if (written == 0) {
+                    DuskLog.warn("Failed to write seeded pipeline cache '{}': {}",
+                        pipelineCacheString, SDL_GetError());
+                    copied = false;
+                    break;
+                }
+                bytesWritten += written;
+            }
+        }
+
+        if (!copied) {
+            break;
+        }
+
+        if (bytesRead < buffer.size()) {
+            if (SDL_GetIOStatus(source) == SDL_IO_STATUS_EOF) {
+                break;
+            }
+
+            DuskLog.warn(
+                "Failed to read bundled pipeline cache '{}': {}", sourcePathString, SDL_GetError());
+            copied = false;
+            break;
+        }
+    }
+
+    if (!SDL_CloseIO(destination)) {
+        DuskLog.warn("Failed to close seeded pipeline cache '{}': {}",
+            dusk::io::fs_path_to_string(pipelineCachePath), SDL_GetError());
+        copied = false;
+    }
+    SDL_CloseIO(source);
+
+    if (!copied) {
+        std::filesystem::remove(pipelineCachePath, ec);
+        return;
+    }
+
+    DuskLog.info("Seeded pipeline cache from '{}'", sourcePathString);
 }

 static constexpr PADDefaultMapping defaultPadMapping = {
@@ -536,21 +691,22 @@ int game_main(int argc, char* argv[]) {
        exit(1);
    }

-    dusk::ConfigPath = CalculateConfigPath();
+    dusk::ConfigPath = calculate_config_path();
    const auto startupLogLevel = static_cast<AuroraLogLevel>(parsed_arg_options["log-level"].as<uint8_t>());
    dusk::InitializeFileLogging(dusk::ConfigPath, startupLogLevel);

    dusk::config::LoadFromUserPreferences();
    ApplyCVarOverrides(parsed_arg_options["cvar"]);
-    dusk::InitializeCrashReporting();
+    dusk::crash_reporting::initialize();
    EnsureInitialPipelineCache(dusk::ConfigPath);
-    PADSetDefaultMapping(&defaultPadMapping);
+    // TODO: How to handle this?
+    //PADSetDefaultMapping(&defaultPadMapping, PAD_TYPE_STANDARD);

    {
-        const auto configPathString = dusk::ConfigPath.string();
+        const auto configPathString = dusk::ConfigPath.u8string();
        AuroraConfig config{};
        config.appName = dusk::AppName;
-        config.configPath = configPathString.c_str();
+        config.configPath = reinterpret_cast<const char*>(configPathString.c_str());
        config.vsync = dusk::getSettings().video.enableVsync;
        config.startFullscreen = dusk::getSettings().video.enableFullscreen;
        config.windowPosX = -1;
@@ -592,7 +748,7 @@ int game_main(int argc, char* argv[]) {
    // Run ImGui UI loop if Aurora couldn't initialize a backend
    if (auroraInfo.backend == BACKEND_NULL) {
        launchUILoop();
-        dusk::ShutdownCrashReporting();
+        dusk::crash_reporting::shutdown();
        dusk::ShutdownFileLogging();
        fflush(stdout);
        fflush(stderr);
@@ -648,6 +804,10 @@ int game_main(int argc, char* argv[]) {
        }
    }

+    dusk::iso::log_verification_state(
+        dusk::getSettings().backend.isoPath.getValue(),
+        dusk::getSettings().backend.isoVerification.getValue());
+
    if (!dvd_opened) {
        if (dusk::getSettings().backend.isoPath.getValue().empty()) {
            forcePreLaunchUI = true;
@@ -666,7 +826,7 @@ int game_main(int argc, char* argv[]) {

            // pre game launch ui main loop
            if (!launchUILoop()) {
-                dusk::ShutdownCrashReporting();
+                dusk::crash_reporting::shutdown();
                dusk::ShutdownFileLogging();
                fflush(stdout);
                fflush(stderr);
@@ -697,6 +857,12 @@ int game_main(int argc, char* argv[]) {
        dusk::IsGameLaunched = true;
    }

+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (dusk::crash_reporting::get_consent() == dusk::crash_reporting::Consent::Unknown) {
+        dusk::ui::push_document(std::make_unique<dusk::ui::CrashReportWindow>());
+    }
+#endif
+
    if (!dusk::getSettings().backend.wasPresetChosen) {
        dusk::ui::push_document(std::make_unique<dusk::ui::PresetWindow>());
    }
@@ -728,7 +894,7 @@ int game_main(int argc, char* argv[]) {

    dusk::MoviePlayerShutdown();

-    dusk::ShutdownCrashReporting();
+    dusk::crash_reporting::shutdown();
    dusk::ShutdownFileLogging();
    fflush(stdout);
    fflush(stderr);
Author	SHA1	Message	Date
SuperDude88	1b4a842eec	Invert First Person Aiming (#870 ) - Inverts first person aiming on either axis, for both stick and gyro controls Could be separated from gyro if desirable, but I think it makes the most sense to have it apply to both	2026-05-10 19:00:20 -06:00
gymnast86	08c7261262	fix going into first person with orbital cam (#923 )	2026-05-10 19:00:09 -06:00
Luke Street	07b440a1c9	Update aurora	2026-05-10 18:42:31 -06:00
SuperDude88	e7ab978a30	Crash Reporting Popup (#879 ) * Initial Draft - Add draft crash report window on startup If you want to disable them before/during startup, there is a command line option to force it * Fixes - Update language to be more precise, consistent with settings menu - Actually shut down reporting properly if you disable it - Fix my silly syntax errors * Update text & use Sentry consent --------- Co-authored-by: Luke Street <luke@street.dev>	2026-05-10 18:37:22 -06:00
qwertyquerty	3a02e129e7	Fix keyboard not binding maybe (idk i cant repro) (#901 ) * fixkb * restore comment	2026-05-10 17:35:29 -06:00
qwertyquerty	93c6106770	cherry pick actor spawner (#920 )	2026-05-10 17:30:39 -06:00
Luke Street	b08d994e32	Update aurora	2026-05-10 17:27:30 -06:00
Luke Street	0665a78c84	Update CMakePresets.json	2026-05-10 13:35:58 -06:00
Luke Street	4db8b51f24	Disable Sentry on Android	2026-05-10 13:22:26 -06:00
Luke Street	800da8dbff	Update aurora	2026-05-10 12:48:49 -06:00
Luke Street	a0ecdb1735	Re-enable Sentry for release builds	2026-05-10 12:10:32 -06:00
Luke Street	c948bffd32	Update aurora	2026-05-10 10:55:30 -06:00
Luke Street	4bcf4ca354	Improve build-appimage.sh	2026-05-10 10:54:43 -06:00
Krutonium	bfd9917ca1	Fix Flake to Build Successfully (#791 ) * Fix Flake to Build Successfully * Fix typo; Res Folder is now correctly placed	2026-05-10 10:53:07 -06:00
Pieter-Jan Briers	7f6212f9b7	Add some basic code conventions to the README (#831 )	2026-05-10 10:52:47 -06:00
Irastris	80245387f3	Update README & fallback ImGui error message (#857 )	2026-05-10 10:52:34 -06:00
Markos Theocharis	0a1fea4bc7	Add `LSSupportsGameMode` to enable game mode (#859 )	2026-05-10 10:51:45 -06:00
project516	4ec7b01213	update github actions in ci (#852 )	2026-05-10 10:39:55 -06:00
Luke Street	5187fe90c3	Seed initial pipeline cache through SDL IO & UTF8 path fixes	2026-05-10 10:39:11 -06:00
Pieter-Jan Briers	a86fa9c162	State share Unicode fix (#834 )	2026-05-10 10:35:11 -06:00
MelonSpeedruns	4ec8c1aaee	Fix recording mode muting music until next reboot (#832 ) Co-authored-by: MelonSpeedruns <melonspeedruns@stratobox.net>	2026-05-10 17:32:55 +02:00
Luke Street	97d032f8b5	Add Android CI	2026-05-10 00:51:34 -06:00
Luke Street	286532904a	Update aurora	2026-05-10 00:31:49 -06:00
Luke Street	04b5861f29	Update CI (again x2)	2026-05-10 00:12:11 -06:00
Luke Street	453e958068	Update CI (again)	2026-05-10 00:11:05 -06:00
Luke Street	e7d2fbcc0b	Update CI	2026-05-10 00:08:42 -06:00
Krutonium	8f71c70d14	fix io.hpp to enable compiling on GCC15 (#790 )	2026-05-09 23:41:15 -06:00
Luke Street	df23edcb69	Add iOS UIFileSharingEnabled integration	2026-05-09 21:42:43 -06:00
Luke Street	daff157027	Fix change notifications in Android DocumentsProvider	2026-05-09 21:42:32 -06:00
Luke Street	0c23bd4332	Add "Open Data Folder" to Interface menu	2026-05-09 20:57:34 -06:00
Luke Street	7562486449	Log disc verification status	2026-05-09 20:40:59 -06:00
Luke Street	5e08b810fc	Update aurora	2026-05-09 20:26:37 -06:00
Pieter-Jan Briers	c66cccf660	Fix handling of Unicode paths on Windows (#767 ) I love C++	2026-05-09 20:24:50 -06:00
Luke Street	3b1118229b	Add Android DocumentsProvider	2026-05-09 20:23:11 -06:00
TakaRikka	491da372a1	Merge pull request #764 from TwilitRealm/gyro-axis-fix Fix Gyro Sensitivity Axes	2026-05-09 17:47:59 -07:00
SuperDude88	a2f463d146	Fix Gyro Sensitivity Axes Fixes #759	2026-05-09 20:15:33 -04:00
TakaRikka	63b3ce4849	temp fix for speedrun timer controls	2026-05-09 15:16:54 -07:00
MelonSpeedruns	8280ac00a0	Always disable cursor if Gyro is set to Mouse mode and the menu is not open (#736 ) Co-authored-by: MelonSpeedruns <melonspeedruns@stratobox.net>	2026-05-09 15:06:58 -06:00
Luke Street	45ef0d72b1	Fix Android backgrounding & re-hide bars after swipe	2026-05-09 15:03:21 -06:00
SuperDude88	ad9c460ec9	Navigate Carousel Without Focus (#741 ) * Navigate Carousel Without Focus - Allow left/right inputs to change the setting value without having the arrow explicitly clicked * Formatting	2026-05-09 14:23:59 -06:00
Phillip Stephens	23dc9bc39a	Disable setting default mappings for now (#742 )	2026-05-09 14:14:45 -06:00
SuperDude88	bf23d44389	Fix Syntax Warning (#743 ) - Remove invalid property value	2026-05-09 14:14:36 -06:00
SuperDude88	d0b9b6d10f	Fix Prelaunch Break-out (#738 ) - Prevent users from breaking out of the prelaunch menu through the GraphicsTuner pages	2026-05-09 13:37:14 -06:00
Luke Street	2f83753260	Fix Android release gradle build	2026-05-09 10:13:59 -06:00
Luke Street	eeb0ad77a4	Missed a spot	2026-05-09 10:03:05 -06:00
Luke Street	594cadcf7d	Update Android app ID to dev.twilitrealm.dusk	2026-05-09 09:55:26 -06:00
TakaRikka	4290726691	update setup instructions	2026-05-09 07:38:19 -07:00
TakaRikka	80dd5ff278	revert mirror mode message override for now	2026-05-09 07:32:29 -07:00
TakaRikka	08efb9a3cf	Merge pull request #735 from TwilitRealm/mute-streams Recording Mode - Mute streams & Fix 1 note playing	2026-05-09 06:38:33 -07:00
MelonSpeedruns	d8a1dd1da4	Recording Mode - Mute streams & Fix 1 note playing	2026-05-09 09:15:10 -04:00
SuperDude88	13dd3c3932	Clamp LOD For Cutscene Midna (#728 ) - Sets max eye LOD level to 0 for `demo00_Midna_cut00_FC_tongue` and `demo00_Midna_cut00_BD_tmp`	2026-05-09 06:30:46 -06:00
TakaRikka	dd7885da9c	Merge pull request #734 from TwilitRealm/number-button-fix Number Button Fix	2026-05-09 04:40:55 -07:00
TakaRikka	5a05433a2b	Merge pull request #733 from TwilitRealm/fix/e_s1_e_yg Frame interp: Fix e_s1 & e_yg	2026-05-09 04:35:25 -07:00
TakaRikka	c3ff3884d7	Merge pull request #730 from TwilitRealm/fix/fchain Frame interp: Fix obj_fchain	2026-05-09 04:34:34 -07:00
SuperDude88	e42c4d3174	Number Button Fix - Add `is_editing` helper to BaseStringButton - Block left/right input from changing number while typing Resolves #706	2026-05-08 23:19:48 -04:00
Pheenoh	06c77a6818	frame interp: e_s1 & e_yg	2026-05-08 21:16:57 -06:00
Pheenoh	4d4a80891f	frame interp: fix obj_fchain	2026-05-08 20:21:37 -06:00
doop	71c892368d	Use float vertex positions for trim (#729 ) Fixes #726 and looks much smoother.	2026-05-08 21:31:46 -04:00
Irastris	d2a1dda523	Add interp callbacks to the stalks of four Baba variants	2026-05-08 21:00:16 -04:00
roeming	78179eb93f	comment out flags tab in editor (#727 ) Co-authored-by: roeming <roeming@users.noreply.github.com>	2026-05-08 18:56:38 -06:00
Luke Street	34e10d3844	Show "3-finger tap" for menu notif on mobile	2026-05-08 17:55:39 -06:00