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
382 changed files with 28484 additions and 3713 deletions
@@ -2,7 +2,7 @@
 Language: Cpp
 Standard: C++03
 AccessModifierOffset: -4
-AlignAfterOpenBracket: Align
+AlignAfterOpenBracket: DontAlign
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 AlignOperands:   true
@@ -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}}
@@ -6,7 +6,7 @@
            "type": "cppvsdbg",
            "request": "launch",
            "program": "${command:cmake.launchTargetPath}",
-            "args": ["-l", "1", "--dvd", "${workspaceRoot}/orig/GZ2E01/GZ2E01.iso"],
+            "args": ["-l", "1", "--dvd", "${workspaceRoot}/orig/GZ2E01/GZ2E01.iso", "--console"],
            "MIMode": "gdb",
            "miDebuggerPath": "gdb",
            "symbolSearchPath": "${command:cmake.launchTargetPath}",
@@ -48,13 +48,15 @@ else ()
    message(STATUS "Unable to find git, commit information will not be available")
 endif ()

-if (DUSK_WC_DESCRIBE MATCHES "^v([0-9]+)\\.([0-9]+)\\.([0-9]+)(-([0-9]+).*)?$")
+if (DUSK_WC_DESCRIBE MATCHES "^v([0-9]+)\\.([0-9]+)\\.([0-9]+)([-+].*)?$")
    set(DUSK_SHORT_VERSION_STRING "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
-    if (CMAKE_MATCH_5)
-        set(DUSK_VERSION_STRING "${DUSK_SHORT_VERSION_STRING}.${CMAKE_MATCH_5}")
-    else ()
-        set(DUSK_VERSION_STRING "${DUSK_SHORT_VERSION_STRING}.0")
+    set(DUSK_VERSION_TWEAK "0")
+    if (DUSK_WC_DESCRIBE MATCHES "^v[0-9]+\\.[0-9]+\\.[0-9]+-([0-9]+)(-dirty)?$")
+        set(DUSK_VERSION_TWEAK "${CMAKE_MATCH_1}")
+    elseif (DUSK_WC_DESCRIBE MATCHES "^v[0-9]+\\.[0-9]+\\.[0-9]+-[0-9A-Za-z.-]+-([0-9]+)(-dirty)?$")
+        set(DUSK_VERSION_TWEAK "${CMAKE_MATCH_1}")
    endif ()
+    set(DUSK_VERSION_STRING "${DUSK_SHORT_VERSION_STRING}.${DUSK_VERSION_TWEAK}")
 else ()
    set(DUSK_WC_DESCRIBE "UNKNOWN-VERSION")
    set(DUSK_VERSION_STRING "0.0.0.0")
@@ -69,7 +71,7 @@ message(STATUS "Dusk version set to ${DUSK_WC_DESCRIBE}")
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 project(dusk LANGUAGES C CXX VERSION ${DUSK_VERSION_STRING})
 if (APPLE)
-    enable_language(OBJC)
+    enable_language(OBJC OBJCXX)
 endif ()
 if (APPLE AND NOT TVOS AND CMAKE_SYSTEM_NAME STREQUAL tvOS)
    # ios.toolchain.cmake hack for SDL
@@ -90,31 +92,45 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)

+# Folder-based instead of target-based organization
+# in Visual Studio and Xcode generators
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "_cmake")
+
 if (CMAKE_SYSTEM_NAME STREQUAL Linux)
  set(DAWN_USE_WAYLAND ON CACHE BOOL "Enable support for Wayland surface" FORCE)
 endif ()
 set(AURORA_ENABLE_DVD ON CACHE BOOL "Enable DVD API support" FORCE)
 set(AURORA_ENABLE_CARD ON CACHE BOOL "Enable CARD API support" FORCE)
+set(AURORA_ENABLE_RMLUI ON CACHE BOOL "Enable RmlUi UI support" FORCE)
 add_subdirectory(extern/aurora EXCLUDE_FROM_ALL)
+target_compile_definitions(aurora_mtx PRIVATE MTX_USE_PS=1)

 add_subdirectory(libs/freeverb)

 option(DUSK_BUILD_WARNINGS "Enable compiler warnings (off by default)")
 option(DUSK_SELECTED_OPT "If on, selected parts of the project will be compiled with optimizations on Debug, intending to make the game run at 30 FPS. Note for MSVC: you will need to remove '/RTC1' from your debug flags in CMake.")
 option(DUSK_MOVIE_SUPPORT "If on, compile against libjpeg-turbo to enable THP file decoding" ON)
+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)
@@ -144,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
@@ -275,30 +292,26 @@ set(DUSK_COMPANY_NAME "Twilit Realm")
 set(DUSK_FILE_DESCRIPTION "Dusk")
 set(DUSK_PRODUCT_NAME "Dusk")
 set(DUSK_COPYRIGHT "Copyright (C) Twilit Realm contributors")
-set(DUSK_GAME_NAME "GZ2E")
-set(DUSK_GAME_VERSION "01")
-set(DUSK_TP_VERSION ${DUSK_GAME_NAME}${DUSK_GAME_VERSION})

-message(STATUS "dusk: Game Version: ${DUSK_TP_VERSION}")
+source_group("dolzel" FILES ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${REL_FILES})
+source_group("dusk" FILES ${DUSK_FILES} ${DUSK_HTTP_BACKEND_FILES})

-source_group("dolzel" FILES ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${JSYSTEM_FILES} ${JSYSTEM_DEBUG_FILES} ${REL_FILES})
-source_group("dusk" FILES ${DUSK_FILES})
-
-set(GAME_COMPILE_DEFS TARGET_PC WIDESCREEN_SUPPORT=1 AVOID_UB=1 VERSION=0
-    DUSK_TP_VERSION="${DUSK_TP_VERSION}" DUSK_GAME_NAME="${DUSK_GAME_NAME}" DUSK_GAME_VERSION="${DUSK_GAME_VERSION}")
+set(GAME_COMPILE_DEFS TARGET_PC WIDESCREEN_SUPPORT=1 AVOID_UB=1 VERSION=0 MTX_USE_PS=1)

 set(GAME_INCLUDE_DIRS
    include
    src
-    assets/${DUSK_TP_VERSION}
+    assets/GZ2E01 # TODO: make this dynamic if needed?
    libs/JSystem/include
    libs
    extern/aurora/include/dolphin
    extern
    ${CMAKE_BINARY_DIR})

+find_package(Threads REQUIRED)
 set(GAME_LIBS aurora::core aurora::gx aurora::gd aurora::si aurora::vi aurora::pad aurora::mtx aurora::os aurora::dvd
-    aurora::card freeverb cxxopts::cxxopts absl::flat_hash_map nlohmann_json::nlohmann_json TracyClient fmt::fmt)
+    aurora::card freeverb cxxopts::cxxopts absl::flat_hash_map nlohmann_json::nlohmann_json TracyClient fmt::fmt
+    Threads::Threads)

 list(APPEND GAME_LIBS libzstd_static)

@@ -307,6 +320,45 @@ if (DUSK_ENABLE_SENTRY_NATIVE)
    list(APPEND GAME_COMPILE_DEFS DUSK_ENABLE_SENTRY_NATIVE=1 SENTRY_BUILD_STATIC=1)
 endif ()

+if (WIN32)
+    list(APPEND GAME_LIBS Ws2_32)
+endif ()
+
+set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/no_backend.cpp)
+if (DUSK_ENABLE_UPDATE_CHECKER)
+    list(APPEND GAME_COMPILE_DEFS DUSK_ENABLE_UPDATE_CHECKER=1)
+    if (WIN32)
+        set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/winhttp.cpp)
+        list(APPEND GAME_LIBS winhttp)
+        list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_WINHTTP=1)
+        message(STATUS "dusk: Enabled update checker (WinHTTP)")
+    elseif (ANDROID)
+        set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/android.cpp)
+        list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_ANDROID=1)
+        message(STATUS "dusk: Enabled update checker (Android)")
+    elseif (APPLE)
+        find_library(FOUNDATION_FRAMEWORK Foundation REQUIRED)
+        set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/url_session.mm)
+        set_source_files_properties(src/dusk/http/url_session.mm PROPERTIES COMPILE_FLAGS -fobjc-arc)
+        list(APPEND GAME_LIBS ${FOUNDATION_FRAMEWORK})
+        list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_URLSESSION=1)
+        message(STATUS "dusk: Enabled update checker (NSURLSession)")
+    elseif (CMAKE_SYSTEM_NAME STREQUAL Linux)
+        find_package(CURL QUIET OPTIONAL_COMPONENTS HTTPS SSL)
+        if (CURL_FOUND AND CURL_HTTPS_FOUND AND CURL_SSL_FOUND)
+            set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/curl.cpp)
+            list(APPEND GAME_LIBS CURL::libcurl)
+            list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_LIBCURL=1)
+            message(STATUS "dusk: Enabled update checker (libcurl)")
+        else ()
+            message(STATUS "dusk: Disabled update checker (libcurl + HTTPS/SSL not found)")
+        endif ()
+    else ()
+        message(STATUS "dusk: Disabled update checker (unsupported platform)")
+    endif ()
+endif ()
+list(APPEND DUSK_FILES ${DUSK_HTTP_BACKEND_SOURCE})
+
 if (DUSK_MOVIE_SUPPORT)
    if (TARGET libjpeg-turbo::turbojpeg-static)
        list(APPEND GAME_LIBS libjpeg-turbo::turbojpeg-static)
@@ -316,14 +368,13 @@ if (DUSK_MOVIE_SUPPORT)
    list(APPEND GAME_COMPILE_DEFS MOVIE_SUPPORT=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 ()
+set(DUSK_ENABLE_DISCORD_DEFAULT ON)
+if (DEFINED DUSK_ENABLE_DISCORD_RPC AND NOT DEFINED DUSK_ENABLE_DISCORD)
+    set(DUSK_ENABLE_DISCORD_DEFAULT ${DUSK_ENABLE_DISCORD_RPC})
+endif ()
+option(DUSK_ENABLE_DISCORD "Enable Discord Rich Presence support" ${DUSK_ENABLE_DISCORD_DEFAULT})
+if (DUSK_ENABLE_DISCORD AND NOT ANDROID AND NOT IOS AND NOT TVOS)
+    list(APPEND GAME_COMPILE_DEFS DUSK_DISCORD=1)
 endif ()

 if(ANDROID)
@@ -332,49 +383,73 @@ endif ()

 # game_debug is for game code files that we know work when compiled with DEBUG=1
 # Of course, if building a release build, this distinction is irrelevant
-add_library(game_debug OBJECT ${JSYSTEM_DEBUG_FILES} ${SSYSTEM_FILES}
+set(GAME_DEBUG_FILES
+        ${SSYSTEM_FILES}
        src/dusk/audio/DuskAudioSystem.cpp
        src/dusk/audio/JASCriticalSection.cpp
        src/dusk/audio/DuskDsp.cpp
        src/dusk/audio/Adpcm.cpp
        src/dusk/audio/DspStub.cpp
-        src/dusk/imgui/ImGuiAudio.cpp)
+        src/dusk/imgui/ImGuiAudio.cpp
+)
+set_source_files_properties(
+        ${GAME_DEBUG_FILES}
+        PROPERTIES
+        COMPILE_DEFINITIONS "$<$<CONFIG:Debug>:DEBUG=1>;$<$<CONFIG:Debug>:PARTIAL_DEBUG=1>"
+)

 # game_base is for all other game code files
-add_library(game_base OBJECT ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${JSYSTEM_FILES} ${REL_FILES} ${DUSK_FILES} ${DOLPHIN_FILES})
+set(GAME_BASE_FILES
+        ${DOLZEL_FILES}
+        ${Z2AUDIOLIB_FILES}
+        ${REL_FILES}
+        ${DUSK_FILES}
+        ${DOLPHIN_FILES}
+)
+set_source_files_properties(
+        ${GAME_BASE_FILES}
+        PROPERTIES
+        COMPILE_DEFINITIONS "NDEBUG=1;NDEBUG_DEFINED=1;DEBUG_DEFINED=0;$<$<CONFIG:Debug>:PARTIAL_DEBUG=1>"
+)

-target_compile_definitions(game_debug PRIVATE ${GAME_COMPILE_DEFS} $<$<CONFIG:Debug>:DEBUG=1> $<$<CONFIG:Debug>:PARTIAL_DEBUG=1>)
-target_compile_definitions(game_base PRIVATE ${GAME_COMPILE_DEFS} NDEBUG=1 NDEBUG_DEFINED=1 DEBUG_DEFINED=0 $<$<CONFIG:Debug>:PARTIAL_DEBUG=1>)
+foreach(jsystem_lib IN LISTS JSYSTEM_LIBRARIES)
+    target_compile_definitions(${jsystem_lib} PRIVATE
+            ${GAME_COMPILE_DEFS}
+            $<$<CONFIG:Debug>:DEBUG=1>
+            $<$<CONFIG:Debug>:PARTIAL_DEBUG=1>
+    )
+    target_include_directories(${jsystem_lib} PRIVATE ${GAME_INCLUDE_DIRS})
+    target_link_libraries(${jsystem_lib} PRIVATE ${GAME_LIBS})
+    set_target_properties(${jsystem_lib} PROPERTIES FOLDER "JSystem")
+endforeach()

-# only apply PCH to game_base since not all headers are necessarily validated with DEBUG=1
-target_precompile_headers(game_base PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/include/dusk_pch.hpp>")
-
-target_include_directories(game_debug PRIVATE ${GAME_INCLUDE_DIRS})
-target_include_directories(game_base PRIVATE ${GAME_INCLUDE_DIRS})
-
-# This implicitly pulls in the library include directories even though no
-# linking actually takes place for object libraries
-target_link_libraries(game_debug PRIVATE ${GAME_LIBS})
-target_link_libraries(game_base PRIVATE ${GAME_LIBS})
-
-# Combined game library
-add_library(game STATIC
-    $<TARGET_OBJECTS:game_base>
-    $<TARGET_OBJECTS:game_debug>)
-target_link_libraries(game PUBLIC ${GAME_LIBS})
-
-if(ANDROID)
-    add_library(dusk SHARED src/dusk/main.cpp)
-    set_target_properties(dusk PROPERTIES OUTPUT_NAME main)
-else ()
-    add_executable(dusk src/dusk/main.cpp)
+set(JSYSTEM_LINK_LIBRARIES ${JSYSTEM_LIBRARIES})
+if (CMAKE_CXX_LINK_GROUP_USING_RESCAN_SUPPORTED OR CMAKE_LINK_GROUP_USING_RESCAN_SUPPORTED)
+    # GNU ld resolves static archives in a single left-to-right pass. The split
+    # JSystem libraries reference each other, so they need a RESCAN group there.
+    set(JSYSTEM_LINK_LIBRARIES "$<LINK_GROUP:RESCAN,${JSYSTEM_LIBRARIES}>")
 endif ()

-target_compile_definitions(dusk PRIVATE TARGET_PC AVOID_UB=1 VERSION=0)
-target_include_directories(dusk PRIVATE include)
-target_link_libraries(dusk PRIVATE game aurora::main)
+set(DUSK_FILES src/dusk/main.cpp ${GAME_BASE_FILES} ${GAME_DEBUG_FILES})
+if(ANDROID)
+    add_library(dusk SHARED ${DUSK_FILES})
+    set_target_properties(dusk PROPERTIES OUTPUT_NAME main)
+else ()
+    add_executable(dusk ${DUSK_FILES})
+endif ()
+
+target_compile_definitions(dusk PRIVATE ${GAME_COMPILE_DEFS})
+target_include_directories(dusk PRIVATE ${GAME_INCLUDE_DIRS})
+target_link_libraries(dusk PRIVATE aurora::main ${GAME_LIBS} ${JSYSTEM_LINK_LIBRARIES})
+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)
@@ -352,13 +352,41 @@
        "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,
      "inherits": [
        "relwithdebinfo",
        "ci"
-      ]
+      ],
+      "cacheVariables": {
+        "AURORA_SDL3_PROVIDER": "vendor"
+      }
    },
    {
      "name": "x-linux-ci-gcc",
@@ -409,6 +437,7 @@
        "x-macos-ci"
      ],
      "cacheVariables": {
+        "AURORA_DAWN_PROVIDER": "vendor",
        "CMAKE_OSX_ARCHITECTURES": "x86_64",
        "Rust_CARGO_TARGET": "x86_64-apple-darwin"
      }
@@ -552,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",
@@ -1,59 +1,69 @@
-![DuskLogo](res/logo-mascot.webp)
+<div align="center">
+  <img src="res/logo-mascot.png" alt="Logo" width="640">

- ### **[Official Website](https://twilitrealm.dev)**
- ### **[Discord](https://discord.gg/QACynxeyna)**
+  <p align="center">
+    <a href="https://twilitrealm.dev">Official Website</a>
+    •
+    <a href="https://discord.gg/dusktp">Discord</a>
+  </p>
+</div>
+
+# Overview
+
+Dusk is a reverse-engineered reimplementation of Twilight Princess.
+
+It aims to be as accurate as possible to the original while also providing new options, enhancements, and tools to customize your experience.

 # Setup
-**⚠️Dusk does NOT provide any copyrighted assets. You must provide your own copy of the game.**

-### 1. Verify your ROM dump
-First make sure your dump of the game is clean and supported by Dusk. You can do this by checking the sha1 hash of your dump against this list of supported versions.
+> [!IMPORTANT]
+> Dusk does *not* provide any copyrighted assets. You must provide your own copy of the original game.

-| Version      | sha1 hash                                |
-| ------------ | ---------------------------------------- |
-| GameCube USA | 75edd3ddff41f125d1b4ce1a40378f1b565519e7 |
+> [!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:
+
+| Version      | SHA-1 hash                                 |
+|--------------| ------------------------------------------ |
+| 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
- Extract the zip folder
- Place your dump of the game into the same folder where you extracted to
- Launch `dusk.exe`
+**Windows / macOS / Linux**
+- Extract the .zip file
+- Launch Dusk
+- Press **Select Disc Image** and provide the path to your supported game dump
+- Press **Play**!

-#### macOS
- TODO
+**iOS**
+- Follow the [iOS setup guide](docs/ios-install-altstore.md)

-#### Linux
- TODO
-
-#### iOS
- TODO
-
-#### android
- TODO
+**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).

-# Credits
- Taka
- encounter
- Antidote
- caseif
- CraftyBoss
- crowell
- dooplecks
- gymnast86
- Irastris
- kipcode66
- Lars
- LunarSoap
- Maddie
- MelonSpeedruns
- Pheenoh
- PJB
- Roeming
- YunataSavior
+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).

-Special thanks to the TP Decomp team, the GC/Wii Decomp community, the Aurora developers, and the TP speedrunning community.
+# Credits
+
+Special thanks to the [TP decompilation](https://github.com/zeldaret/tp) team, the GC/Wii decompilation community, the [Aurora](https://github.com/encounter/aurora) developers, the [TP speedrunning community](https://zsrtp.link), and all [contributors](https://github.com/TwilitRealm/dusk/graphs/contributors).
+
+<br/>
+<div align="center">
+    <a href="https://github.com/encounter/aurora">
+        <img src="assets/aurora-powered.png" alt="Powered by Aurora" width="800">
+    </a>
+</div>
@@ -0,0 +1,66 @@
+<svg width="600" height="600" viewBox="0 0 300 300" xmlns="http://www.w3.org/2000/svg">
+  <circle cx="150" cy="150" r="105" fill="none" stroke="white" stroke-width="4"/>
+  <circle cx="150" cy="150" r="95" fill="none" stroke="white" stroke-width="4"/>
+  <circle cx="150" cy="150" r="60" fill="none" stroke="white" stroke-width="4"/>
+  <circle cx="150" cy="150" r="75" fill="none" stroke="white" stroke-width="4"/>
+
+  <defs>
+    <line id="ray" x1="150" y1="55" x2="150" y2="45"/>
+    <clipPath id="zigzag-clip">
+      <circle cx="150" cy="150" r="75"/>
+    </clipPath>
+  </defs>
+
+  <g stroke="white" stroke-width="3">
+    <use href="#ray"/>
+    <use href="#ray" transform="rotate(18 150 150)"/>
+    <use href="#ray" transform="rotate(36 150 150)"/>
+    <use href="#ray" transform="rotate(54 150 150)"/>
+    <use href="#ray" transform="rotate(72 150 150)"/>
+    <use href="#ray" transform="rotate(90 150 150)"/>
+    <use href="#ray" transform="rotate(108 150 150)"/>
+    <use href="#ray" transform="rotate(126 150 150)"/>
+    <use href="#ray" transform="rotate(144 150 150)"/>
+    <use href="#ray" transform="rotate(162 150 150)"/>
+    <use href="#ray" transform="rotate(180 150 150)"/>
+    <use href="#ray" transform="rotate(198 150 150)"/>
+    <use href="#ray" transform="rotate(216 150 150)"/>
+    <use href="#ray" transform="rotate(234 150 150)"/>
+    <use href="#ray" transform="rotate(252 150 150)"/>
+    <use href="#ray" transform="rotate(270 150 150)"/>
+    <use href="#ray" transform="rotate(288 150 150)"/>
+    <use href="#ray" transform="rotate(306 150 150)"/>
+    <use href="#ray" transform="rotate(324 150 150)"/>
+    <use href="#ray" transform="rotate(342 150 150)"/>
+  </g>
+
+  <polygon fill="none" stroke="white" stroke-width="4" opacity="1" clip-path="url(#zigzag-clip)"
+    points="
+      126.82,78.67
+      150,90
+      173.18,78.67
+      185.27,101.46
+      210.68,105.92
+      207.06,131.46
+      225,150
+      207.06,168.54
+      210.68,194.08
+      185.27,198.54
+      173.18,221.33
+      150,210
+      126.82,221.33
+      114.73,198.54
+      89.32,194.08
+      92.94,168.54
+      75,150
+      92.94,131.46
+      89.32,105.92
+      114.73,101.46
+    "/>
+
+  <g fill="none" stroke="white" stroke-width="4">
+    <polygon points="150,105 130,140 170,140"/>
+    <polygon points="130,140 110,175 150,175"/>
+    <polygon points="170,140 150,175 190,175"/>
+  </g>
+</svg>
@@ -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
@@ -13,13 +13,3 @@ buildType:
      short: RelWithDebInfo
      long: Optimized, with debug symbols
      buildType: RelWithDebInfo
-
-tp_version:
-  default: GZ2E01
-  description: TP Version
-  choices:
-    GZ2E01:
-      short: GZ2E01
-      long: GZ2E01
-      settings:
-        DUSK_TP_VERSION: GZ2E01
@@ -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
@@ -1,7 +1,7 @@

 set(DOLZEL_FILES
        src/m_Do/m_Do_main.cpp
-        src/m_Do/m_Do_printf.cpp
+        #src/m_Do/m_Do_printf.cpp
        src/m_Do/m_Do_audio.cpp
        src/m_Do/m_Do_controller_pad.cpp
        #src/m_Do/m_Re_controller_pad.cpp
@@ -15,7 +15,6 @@ set(DOLZEL_FILES
        src/m_Do/m_Do_DVDError.cpp
        src/m_Do/m_Do_MemCard.cpp
        src/m_Do/m_Do_MemCardRWmng.cpp
-        src/m_Do/m_Do_machine_exception.cpp
        src/m_Do/m_Do_hostIO.cpp
        src/c/c_damagereaction.cpp
        src/c/c_dylink.cpp
@@ -315,7 +314,7 @@ set(SSYSTEM_FILES
        src/SSystem/SStandard/s_basic.cpp
 )

-set(JSYSTEM_DEBUG_FILES
+add_library(JSystem_JParticle STATIC
        libs/JSystem/src/JParticle/JPAResourceManager.cpp
        libs/JSystem/src/JParticle/JPAResource.cpp
        libs/JSystem/src/JParticle/JPABaseShape.cpp
@@ -331,10 +330,19 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JParticle/JPAEmitter.cpp
        libs/JSystem/src/JParticle/JPAParticle.cpp
        libs/JSystem/src/JParticle/JPAMath.cpp
+)
+
+add_library(JSystem_JFramework STATIC
        libs/JSystem/src/JFramework/JFWSystem.cpp
        libs/JSystem/src/JFramework/JFWDisplay.cpp
+)
+
+add_library(JSystem_J3DU STATIC
        libs/JSystem/src/J3DU/J3DUClipper.cpp
        libs/JSystem/src/J3DU/J3DUDL.cpp
+)
+
+add_library(JSystem_JKernel STATIC
        libs/JSystem/src/JKernel/JKRHeap.cpp
        libs/JSystem/src/JKernel/JKRExpHeap.cpp
        libs/JSystem/src/JKernel/JKRSolidHeap.cpp
@@ -360,14 +368,23 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JKernel/JKRDvdRipper.cpp
        libs/JSystem/src/JKernel/JKRDvdAramRipper.cpp
        libs/JSystem/src/JKernel/JKRDecomp.cpp
+)
+
+add_library(JSystem_JMath STATIC
        libs/JSystem/src/JMath/JMath.cpp
        libs/JSystem/src/JMath/random.cpp
        libs/JSystem/src/JMath/JMATrigonometric.cpp
+)
+
+add_library(JSystem_JSupport STATIC
        libs/JSystem/src/JSupport/JSUList.cpp
        libs/JSystem/src/JSupport/JSUInputStream.cpp
        libs/JSystem/src/JSupport/JSUOutputStream.cpp
        libs/JSystem/src/JSupport/JSUMemoryStream.cpp
        libs/JSystem/src/JSupport/JSUFileStream.cpp
+)
+
+add_library(JSystem_JUtility STATIC
        libs/JSystem/src/JUtility/JUTCacheFont.cpp
        libs/JSystem/src/JUtility/JUTResource.cpp
        libs/JSystem/src/JUtility/JUTTexture.cpp
@@ -388,6 +405,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JUtility/JUTConsole.cpp
        libs/JSystem/src/JUtility/JUTDirectFile.cpp
        libs/JSystem/src/JUtility/JUTFontData_Ascfont_fix12.cpp
+)
+
+add_library(JSystem_JStage STATIC
        libs/JSystem/src/JStage/JSGActor.cpp
        libs/JSystem/src/JStage/JSGAmbientLight.cpp
        libs/JSystem/src/JStage/JSGCamera.cpp
@@ -395,6 +415,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JStage/JSGLight.cpp
        libs/JSystem/src/JStage/JSGObject.cpp
        libs/JSystem/src/JStage/JSGSystem.cpp
+)
+
+add_library(JSystem_J2DGraph STATIC
        libs/JSystem/src/J2DGraph/J2DGrafContext.cpp
        libs/JSystem/src/J2DGraph/J2DOrthoGraph.cpp
        libs/JSystem/src/J2DGraph/J2DTevs.cpp
@@ -413,6 +436,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J2DGraph/J2DAnmLoader.cpp
        libs/JSystem/src/J2DGraph/J2DAnimation.cpp
        libs/JSystem/src/J2DGraph/J2DManage.cpp
+)
+
+add_library(JSystem_J3DGraphBase STATIC
        libs/JSystem/src/J3DGraphBase/J3DGD.cpp
        libs/JSystem/src/J3DGraphBase/J3DSys.cpp
        libs/JSystem/src/J3DGraphBase/J3DVertex.cpp
@@ -427,6 +453,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J3DGraphBase/J3DTevs.cpp
        libs/JSystem/src/J3DGraphBase/J3DDrawBuffer.cpp
        libs/JSystem/src/J3DGraphBase/J3DStruct.cpp
+)
+
+add_library(JSystem_J3DGraphAnimator STATIC
        libs/JSystem/src/J3DGraphAnimator/J3DShapeTable.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DJointTree.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DModelData.cpp
@@ -438,6 +467,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J3DGraphAnimator/J3DCluster.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DJoint.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DMaterialAttach.cpp
+)
+
+add_library(JSystem_J3DGraphLoader STATIC
        libs/JSystem/src/J3DGraphLoader/J3DMaterialFactory.cpp
        libs/JSystem/src/J3DGraphLoader/J3DMaterialFactory_v21.cpp
        libs/JSystem/src/J3DGraphLoader/J3DClusterLoader.cpp
@@ -446,6 +478,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J3DGraphLoader/J3DJointFactory.cpp
        libs/JSystem/src/J3DGraphLoader/J3DShapeFactory.cpp
        libs/JSystem/src/J3DGraphLoader/J3DAnmLoader.cpp
+)
+
+add_library(JSystem_JStudio STATIC
        libs/JSystem/src/JStudio/JStudio/ctb.cpp
        libs/JSystem/src/JStudio/JStudio/ctb-data.cpp
        libs/JSystem/src/JStudio/JStudio/functionvalue.cpp
@@ -460,6 +495,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JStudio/JStudio/stb.cpp
        libs/JSystem/src/JStudio/JStudio/stb-data-parse.cpp
        libs/JSystem/src/JStudio/JStudio/stb-data.cpp
+)
+
+add_library(JSystem_JStudio_JStage STATIC
        libs/JSystem/src/JStudio/JStudio_JStage/control.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object-actor.cpp
@@ -467,10 +505,19 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JStudio/JStudio_JStage/object-camera.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object-fog.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object-light.cpp
+)
+
+add_library(JSystem_JStudio_JAudio2 STATIC
        libs/JSystem/src/JStudio/JStudio_JAudio2/control.cpp
        libs/JSystem/src/JStudio/JStudio_JAudio2/object-sound.cpp
+)
+
+add_library(JSystem_JStudio_JParticle STATIC
        libs/JSystem/src/JStudio/JStudio_JParticle/control.cpp
        libs/JSystem/src/JStudio/JStudio_JParticle/object-particle.cpp
+)
+
+add_library(JSystem_JAudio2 STATIC
        libs/JSystem/src/JAudio2/JASCalc.cpp
        libs/JSystem/src/JAudio2/JASTaskThread.cpp
        libs/JSystem/src/JAudio2/JASDvdThread.cpp
@@ -535,22 +582,34 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JAudio2/JAUSoundAnimator.cpp
        libs/JSystem/src/JAudio2/JAUSoundTable.cpp
        libs/JSystem/src/JAudio2/JAUStreamFileTable.cpp
+)
+
+add_library(JSystem_JMessage STATIC
        libs/JSystem/src/JMessage/control.cpp
        libs/JSystem/src/JMessage/data.cpp
        libs/JSystem/src/JMessage/processor.cpp
        libs/JSystem/src/JMessage/resource.cpp
        libs/JSystem/src/JMessage/locale.cpp
+)
+
+add_library(JSystem_JGadget STATIC
        libs/JSystem/src/JGadget/binary.cpp
        libs/JSystem/src/JGadget/define.cpp
        libs/JSystem/src/JGadget/linklist.cpp
        libs/JSystem/src/JGadget/search.cpp
        libs/JSystem/src/JGadget/std-vector.cpp
+)
+
+add_library(JSystem_JAHostIO STATIC
        libs/JSystem/src/JAHostIO/JAHFrameNode.cpp
        libs/JSystem/src/JAHostIO/JAHioMessage.cpp
        libs/JSystem/src/JAHostIO/JAHioMgr.cpp
        libs/JSystem/src/JAHostIO/JAHioNode.cpp
        libs/JSystem/src/JAHostIO/JAHioUtil.cpp
        libs/JSystem/src/JAHostIO/JAHVirtualNode.cpp
+)
+
+add_library(JSystem_JHostIO STATIC
        libs/JSystem/src/JHostIO/JORFile.cpp
        libs/JSystem/src/JHostIO/JORHostInfo.cpp
        libs/JSystem/src/JHostIO/JORMessageBox.cpp
@@ -560,7 +619,28 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JHostIO/JHIMccBuf.cpp
 )

-set(JSYSTEM_FILES
+set(JSYSTEM_LIBRARIES
+        JSystem_JParticle
+        JSystem_JFramework
+        JSystem_J3DU
+        JSystem_JKernel
+        JSystem_JMath
+        JSystem_JSupport
+        JSystem_JUtility
+        JSystem_JStage
+        JSystem_J2DGraph
+        JSystem_J3DGraphBase
+        JSystem_J3DGraphAnimator
+        JSystem_J3DGraphLoader
+        JSystem_JStudio
+        JSystem_JStudio_JStage
+        JSystem_JStudio_JAudio2
+        JSystem_JStudio_JParticle
+        JSystem_JAudio2
+        JSystem_JMessage
+        JSystem_JGadget
+        JSystem_JAHostIO
+        JSystem_JHostIO
 )

 set(REL_FILES
@@ -1342,18 +1422,22 @@ set(DUSK_FILES
        src/dusk/crash_reporting.cpp
        src/dusk/endian.cpp
        src/dusk/extras.c
-        src/dusk/extras.cpp
        src/dusk/file_select.cpp
        src/dusk/file_select.hpp
        src/dusk/frame_interpolation.cpp
        src/dusk/game_clock.cpp
        src/dusk/globals.cpp
        src/dusk/gyro.cpp
+		src/dusk/gamepad_color.cpp
+		src/dusk/autosave.cpp
+        src/dusk/http/http.hpp
        src/dusk/io.cpp
        src/dusk/layout.cpp
        src/dusk/logging.cpp
        src/dusk/settings.cpp
        src/dusk/stubs.cpp
+        src/dusk/update_check.cpp
+        src/dusk/update_check.hpp
        #src/dusk/m_Do_ext_dusk.cpp
        src/dusk/imgui/ImGuiConfig.hpp
        src/dusk/imgui/ImGuiConsole.hpp
@@ -1366,25 +1450,82 @@ set(DUSK_FILES
        src/dusk/imgui/ImGuiBloomWindow.hpp
        src/dusk/imgui/ImGuiMenuTools.cpp
        src/dusk/imgui/ImGuiMenuTools.hpp
-        src/dusk/imgui/ImGuiMenuEnhancements.cpp
-        src/dusk/imgui/ImGuiMenuEnhancements.hpp
-        src/dusk/imgui/ImGuiPreLaunchWindow.cpp
-        src/dusk/imgui/ImGuiPreLaunchWindow.hpp
-        src/dusk/imgui/ImGuiFirstRunPreset.hpp
-        src/dusk/imgui/ImGuiFirstRunPreset.cpp
+        src/dusk/imgui/ImGuiActorSpawner.cpp
        src/dusk/imgui/ImGuiProcessOverlay.cpp
        src/dusk/imgui/ImGuiCameraOverlay.cpp
        src/dusk/imgui/ImGuiHeapOverlay.cpp
-        src/dusk/imgui/ImGuiDebugPad.cpp
        src/dusk/imgui/ImGuiControllerOverlay.cpp
        src/dusk/imgui/ImGuiStubLog.cpp
        src/dusk/imgui/ImGuiMapLoader.cpp
        src/dusk/imgui/ImGuiSaveEditor.cpp
        src/dusk/imgui/ImGuiStateShare.hpp
        src/dusk/imgui/ImGuiStateShare.cpp
+        src/dusk/ui/achievements.cpp
+        src/dusk/ui/achievements.hpp
+        src/dusk/ui/bool_button.cpp
+        src/dusk/ui/bool_button.hpp
+        src/dusk/ui/button.cpp
+        src/dusk/ui/button.hpp
+        src/dusk/ui/component.cpp
+        src/dusk/ui/component.hpp
+        src/dusk/ui/controller_config.cpp
+        src/dusk/ui/controller_config.hpp
+        src/dusk/ui/document.cpp
+        src/dusk/ui/document.hpp
+        src/dusk/ui/editor.cpp
+        src/dusk/ui/editor.hpp
+        src/dusk/ui/event.cpp
+        src/dusk/ui/event.hpp
+        src/dusk/ui/graphics_tuner.cpp
+        src/dusk/ui/graphics_tuner.hpp
+        src/dusk/ui/input.cpp
+        src/dusk/ui/input.hpp
+        src/dusk/ui/modal.cpp
+        src/dusk/ui/modal.hpp
+        src/dusk/ui/nav_types.hpp
+        src/dusk/ui/number_button.cpp
+        src/dusk/ui/number_button.hpp
+        src/dusk/ui/overlay.cpp
+        src/dusk/ui/overlay.hpp
+        src/dusk/ui/pane.cpp
+        src/dusk/ui/pane.hpp
+        src/dusk/ui/menu_bar.cpp
+        src/dusk/ui/menu_bar.hpp
+        src/dusk/ui/prelaunch.cpp
+        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
+        src/dusk/ui/settings.hpp
+        src/dusk/ui/string_button.cpp
+        src/dusk/ui/string_button.hpp
+        src/dusk/ui/tab_bar.cpp
+        src/dusk/ui/tab_bar.hpp
+        src/dusk/ui/ui.cpp
+        src/dusk/ui/ui.hpp
+        src/dusk/ui/window.cpp
+        src/dusk/ui/window.hpp
+        src/dusk/achievements.cpp
        src/dusk/iso_validate.cpp
+        src/dusk/livesplit.cpp
        src/dusk/offset_ptr.cpp
        src/dusk/OSContext.cpp
+        src/dusk/OSReport.cpp
        src/dusk/OSThread.cpp
        src/dusk/OSMutex.cpp
+        src/dusk/discord.cpp
+        src/dusk/discord.hpp
+        src/dusk/discord_presence.cpp
+        src/dusk/version.cpp
+)
+
+set(DUSK_HTTP_BACKEND_FILES
+        src/dusk/http/no_backend.cpp
+        src/dusk/http/curl.cpp
+        src/dusk/http/winhttp.cpp
+        src/dusk/http/url_session.mm
 )
@@ -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 {
@@ -4552,6 +4552,18 @@ public:
    void handleWolfHowl();
    void handleQuickTransform();
    bool checkGyroAimContext();
+
+    void onIronBallChainInterpCallback();
+
+    static const int IRON_BALL_CHAIN_COUNT = 102;
+    cXyz mIBChainInterpPrevPos[IRON_BALL_CHAIN_COUNT];
+    cXyz mIBChainInterpCurrPos[IRON_BALL_CHAIN_COUNT];
+    csXyz mIBChainInterpPrevAngle[IRON_BALL_CHAIN_COUNT];
+    csXyz mIBChainInterpCurrAngle[IRON_BALL_CHAIN_COUNT];
+    cXyz mIBChainInterpPrevHandRoot;
+    cXyz mIBChainInterpCurrHandRoot;
+    bool mIBChainInterpPrevValid;
+    bool mIBChainInterpCurrValid;
 #endif
 };  // Size: 0x385C

@@ -188,6 +188,15 @@ public:
    /* 0x273C */ f32 mKankyoBlend;
    /* 0x2740 */ u8 field_0x2740;
    /* 0x2744 */ dMsgFlow_c mMsgFlow;
+#if TARGET_PC
+    cXyz mReinsInterpPrev[2][16];
+    cXyz mReinsInterpCurr[2][16];
+    cXyz mReinsTexInterpPrev[2];
+    cXyz mReinsTexInterpCurr[2];
+    bool mReinsInterpPrevValid;
+    bool mReinsInterpCurrValid;
+    s8 mDemoCamSyncTicks;
+#endif
 };

 STATIC_ASSERT(sizeof(b_gnd_class) == 0x2790);
@@ -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);
@@ -44,6 +44,12 @@ public:
    /* 0x88C */ u8 field_0x88C[0x8C8 - 0x88C];
    /* 0x8C8 */ s8 field_0x8c8;
    /* 0x8C9 */ u8 mInitHIO;
+#if TARGET_PC
+    cXyz mRopeInterpPrev[16];
+    cXyz mRopeInterpCurr[16];
+    bool mRopeInterpPrevValid;
+    bool mRopeInterpCurrValid;
+#endif
 };

 STATIC_ASSERT(sizeof(e_mb_class) == 0x8cc);
@@ -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);
@@ -220,6 +220,15 @@ public:
    /* 0x17E2 */ s16 wait_roll_angle;  ///< @brief Roll angle during wait state.
    /* 0x17E4 */ u8 field_0x17e4[0x17e8 - 0x17e4];
    /* 0x17E8 */ f32 ride_speed_max;  ///< @brief Speed rate for riding calculations.
+#if TARGET_PC
+    cXyz himo_mat_interp_prev[2][16];
+    cXyz himo_mat_interp_curr[2][16];
+    cXyz himo_tex_interp_prev[2];
+    cXyz himo_tex_interp_curr[2];
+    bool himo_interp_prev_valid;
+    bool himo_interp_curr_valid;
+    s8 demo_cam_sync_ticks;
+#endif
 };

 STATIC_ASSERT(sizeof(e_wb_class) == 0x17EC);
@@ -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);
@@ -25,6 +25,10 @@ public:
    /* 0x164 */ cXyz mMinVal;
    /* 0x170 */ cXyz mMaxVal;
    /* 0x17C */ cXyz mViewScale;
+#if TARGET_PC
+    bool mbReset = false;
+    bool mbHadEntry = false;
+#endif
 };

 /**
@@ -94,6 +94,12 @@ static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr);
 #define THP_TEXTURE_SET_COUNT  3
 #endif

+#if TARGET_PC
+namespace dusk {
+    void MoviePlayerShutdown();
+}
+#endif
+
 struct daMP_THPPlayer {
    /* 0x000 */ DVDFileInfo fileInfo;
 	/* 0x03C */ THPHeader header;
@@ -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);
@@ -25,6 +25,10 @@ public:
    int Draw();
    int Delete();

+#if TARGET_PC
+    void onInterpCallback();
+#endif
+
    enum Param_e {
        LOCK_e = (1 << 6), NO_BASE_DISP = (1 << 7)
    };
@@ -50,6 +54,13 @@ private:
    /* 0x1020 */ dCcD_Cyl mCylinderCollider;
    /* 0x115C */ s32 mStopSwingingFrames;

+#if TARGET_PC
+    cXyz mChainInterpPrev[64];
+    cXyz mChainInterpCurr[64];
+    bool mChainInterpPrevValid;
+    bool mChainInterpCurrValid;
+#endif
+
    // Number of chain models
    u32 getArg0() {
        return fopAcM_GetParamBit(this, 0, 6);
@@ -58,6 +58,9 @@ public:
    void setNextPoint();
    int Draw();
    int Delete();
+#if TARGET_PC
+    friend void daL8Lift_interp_callback(bool isSimFrame, void* pUserWork);
+#endif

    u8 getPthID() { return fopAcM_GetParamBit(this, 0, 8); }
    u8 getMoveSpeed() { return fopAcM_GetParamBit(this, 8, 4); }
@@ -68,10 +68,8 @@ public:
    /* 0x904 */ cXyz field_0x904[2];
    /* 0x91C */ int field_0x91c;
    /* 0x920 */ cXyz field_0x920[63];
-    /* 0xC14 */ f32 field_0xc14[4];
-    /* 0xC24 */ u8 field_0xc24[0xd10 - 0xc24];
-    /* 0xD10 */ s8 field_0xd10[4];
-    /* 0xD14 */ u8 field_0xd14[0xd50 - 0xd14];
+    /* 0xC14 */ f32 field_0xc14[63];
+    /* 0xD10 */ s8 field_0xd10[64];
    /* 0xD50 */ mDoExt_3DlineMat1_c field_0xd50;
    /* 0xD8C */ int field_0xd8c;
 };
@@ -143,6 +143,12 @@ public:
    /* 0x20 */ JORFile mFile;
 #endif

+#if TARGET_PC
+    /* 0x24 */ u8 mManualMode;
+    /* 0x25 */ f32 freeXAngle;
+    /* 0x29 */ f32 freeYAngle;
+#endif
+
    u32 Id(s32 i_style) { return mCamStyleData[i_style].field_0x0; }
    int Algorythmn(s32 i_style) { return mCamStyleData[i_style].field_0x4; }
    int Algorythmn() { return mCurrentStyle->field_0x4; }
@@ -118,6 +118,18 @@ class camera_class;
 class dCamera_c;
 typedef bool (dCamera_c::*engine_fn)(s32);

+#if TARGET_PC
+struct DebugFlyCam {
+    bool initialized;
+    f32 pitch;
+    f32 yaw;
+    cXyz savedCenter;
+    cXyz savedEye;
+    f32 savedFovy;
+    cSAngle savedBank;
+};
+#endif
+
 class dCamera_c {
 public:
    class dCamInfo_c {
@@ -273,6 +285,8 @@ public:
        /* 0xA4 */ f32 field_0xa4;
        /* 0xA8 */ int field_0xa8;
        /* 0xAC */ f32 field_0xac;
+        f32 xAngle;
+        f32 yAngle;
    };

    struct LockOnData {
@@ -1024,6 +1038,11 @@ public:
    bool colosseumCamera(s32);
    bool test1Camera(s32);
    bool test2Camera(s32);
+    #if TARGET_PC
+    bool freeCamera();
+    bool executeDebugFlyCam();
+    void deactivateDebugFlyCam();
+    #endif
    bool towerCamera(s32);
    bool hookshotCamera(s32);
    bool railCamera(s32);
@@ -1371,6 +1390,10 @@ public:
    /* 0x970 */ dCamSetup_c mCamSetup;
    /* 0xAEC */ dCamParam_c mCamParam;
    /* 0xB0C */ u8 field_0xb0c;
+
+#if TARGET_PC
+    DebugFlyCam mDebugFlyCam;
+#endif
 };  // Size: 0xB10

 dCamera_c* dCam_getBody();
@@ -1845,6 +1845,12 @@ inline void dComIfGs_addDeathCount() {
    g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().addDeathCount();
 }

+#if TARGET_PC
+inline u16 dComIfGs_getDeathCount() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getDeathCount();
+}
+#endif
+
 inline char* dComIfGs_getPlayerName() {
    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getPlayerName();
 }
@@ -4834,8 +4840,7 @@ inline void dComIfGd_drawXluListDark() {
 inline void dComIfGd_drawXluListInvisible() {
    ZoneScoped;
 #ifdef TARGET_PC
-    if (dusk::getSettings().game.enableWaterRefraction &&
-        !dusk::getSettings().game.enableFrameInterpolation) {
+    if (!dusk::getSettings().game.disableWaterRefraction) {
 #endif
        g_dComIfG_gameInfo.drawlist.drawXluListInvisible();
 #ifdef TARGET_PC
@@ -4846,8 +4851,7 @@ inline void dComIfGd_drawXluListInvisible() {
 inline void dComIfGd_drawOpaListInvisible() {
    ZoneScoped;
 #ifdef TARGET_PC
-    if (dusk::getSettings().game.enableWaterRefraction &&
-        !dusk::getSettings().game.enableFrameInterpolation) {
+    if (!dusk::getSettings().game.disableWaterRefraction) {
 #endif
        g_dComIfG_gameInfo.drawlist.drawOpaListInvisible();
 #ifdef TARGET_PC
@@ -209,6 +209,10 @@ public:
    /* 0x04 */ TGXTexObj* mpTexObj;
    /* 0x08 */ Mtx mVolumeMtx;
    /* 0x38 */ Mtx mMtx;
+#if TARGET_PC
+    const void* mVolumeMtxKey;
+    const void* mMtxKey;
+#endif
 };  // Size: 0x68

 struct cBgD_Vtx_t;
@@ -10,6 +10,7 @@
 #include "JSystem/J3DGraphLoader/J3DAnmLoader.h"

 class dFile_info_c;
+class J2DPicture;

 class dDlst_FileSel_c : public dDlst_base_c {
 public:
@@ -113,6 +114,14 @@ public:
    /* 0x04 */ J2DScreen* Scr3m;
 };

+class dDlst_FileSelFade_c : public dDlst_base_c {
+public:
+    void draw();
+    virtual ~dDlst_FileSelFade_c() {}
+
+    /* 0x04 */ J2DPicture* mpPict;
+};
+
 class dFs_HIO_c : public JORReflexible {
 public:
    dFs_HIO_c();
@@ -676,6 +685,9 @@ public:
    #if PLATFORM_GCN
    /* 0x2378 */ J2DPicture* mpFadePict;
    #endif
+#ifdef TARGET_PC
+    dDlst_FileSelFade_c mFadeDlst;
+#endif

    #if PLATFORM_WII || PLATFORM_SHIELD
    /* 0x2376 */ u8 field_0x2376[SAVEFILE_SIZE];
@@ -684,6 +696,10 @@ public:
    #endif
 };

+#ifdef TARGET_PC
+STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C + sizeof(dDlst_FileSelFade_c));
+#else
 STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C);
+#endif

 #endif /* D_FILE_D_FILE_SELECT_H */
@@ -91,6 +91,10 @@ public:
    void calcCursor();
    void drawCursor();

+    #if TARGET_PC
+    void dMapBgWide();
+    #endif
+
    void setDPDFloorSelCurPos(s8 i_pos) { field_0xdd6 = i_pos; }

    f32 getMapWidth() { return mMapWidth; }
@@ -103,6 +107,10 @@ public:
        field_0xd98 = param_1;
    }

+#if TARGET_PC
+    void resetScrollArrowMask() { field_0xdda = 0; }
+#endif
+
    /* 0xC98 */ JKRExpHeap* mpHeap;
    /* 0xC9C */ JKRExpHeap* mpTalkHeap;
    /* 0xCA0 */ STControl* mpStick;
@@ -75,7 +75,9 @@ public:
        /* 0x8 */ BE(u16) mAreaName;
        /* 0xA */ u8 mCount;
 #ifdef _MSVC_LANG
-        u8* __get_mRoomNos() const { return (u8*)(this + 1); }
+        // Room numbers start at offset 0xB (right after mCount), NOT at sizeof(data)=12.
+        // (u8*)(this+1) would give offset 12 because MSVC sizeof=12; use &mCount+1 instead.
+        u8* __get_mRoomNos() const { return (u8*)&mCount + 1; }
        __declspec(property(get = __get_mRoomNos)) u8* mRoomNos;
 #else
        /* 0xB */ u8 mRoomNos[0];
@@ -81,6 +81,10 @@ public:
    void calcDrawPriority();
    void setArrowPosAxis(f32, f32);

+    #if TARGET_PC
+    void fMapBackWide();
+    #endif
+
    virtual void draw();
    virtual ~dMenu_Fmap2DBack_c();

@@ -165,6 +169,12 @@ public:

    void mapBlink() {}

+    #if PLATFORM_WII || TARGET_PC
+    f32 getMirrorPosX(f32 param_0, f32 param_1) {
+        return (field_0x11dc * 2.0f - (param_0 + param_1)) - param_1;
+    }
+    #endif
+
    // Unknown name
    struct RegionTexData {
        /* 0x00 */ float mMinX;
@@ -330,6 +340,10 @@ public:
    void setHIO(bool);
    bool isWarpAccept();

+    #if TARGET_PC
+    void fMapTopWide();
+    #endif
+
    virtual void draw();
    virtual ~dMenu_Fmap2DTop_c();

@@ -66,6 +66,16 @@ public:
        _c90 = param_2;
    }

+#if PLATFORM_WII || TARGET_PC
+    f32 getMirrorCenterPosX(f32 param_0, f32 param_1) {
+        if (_c90) {
+            return (mCenterPosX * 2.0f - (param_0 + param_1)) - param_1;
+        }
+
+        return param_0;
+    }
+#endif
+
    struct Stage_c {
        // Incomplete class

@@ -206,6 +206,15 @@ private:
    /* 0x6D3 */ u8 field_0x6d3;
 #if TARGET_PC
    f32 mSelectItemSlideElapsed[4];
+    f32 mCursorInterpPrevX;
+    f32 mCursorInterpPrevY;
+    f32 mCursorInterpCurrX;
+    f32 mCursorInterpCurrY;
+    s16 mCursorInterpPrevAngle;
+    s16 mCursorInterpCurrAngle;
+    bool mCursorInterpPrevAngular;
+    bool mCursorInterpCurrAngular;
+    bool mCursorInterpInit;
 #endif
 };

@@ -343,6 +343,11 @@ public:
    /* 0x624 */ f32 mMidonaPosX;
    /* 0x628 */ f32 mMidonaPosY;
    /* 0x62C */ f32 mMidonaScale;
+
+#ifdef TARGET_PC
+    bool mWasListen[2];
+    bool mWasRepeat[2];
+#endif
 };

 #endif /* D_METER_D_METER_BUTTON_H */
@@ -67,6 +67,9 @@ public:
    bool isStaffMessage();
    bool isSaveMessage();
    bool isTalkMessage();
+#if TARGET_PC
+    bool isShopItemMessage();
+#endif
    const char* getSmellName();
    const char* getPortalName();
    const char* getBombName();
@@ -89,7 +89,7 @@ public:
    void MojiSelectAnm3();
    int mojiChange(u8);
    void selectMojiSet();
-    #if REGION_JPN
+    #if TARGET_PC || REGION_JPN
    int checkDakuon(int, u8);
    int setDakuon(int, u8);
    #endif
@@ -79,7 +79,7 @@ public:
    bool isProgressiveMode();
    void setRenderMode();

-    #if VERSION == VERSION_GCN_PAL || PLATFORM_WII || PLATFORM_SHIELD
+    #if TARGET_PC || VERSION == VERSION_GCN_PAL || PLATFORM_WII || PLATFORM_SHIELD
    u8 getPalLanguage();
    #endif

@@ -149,7 +149,7 @@ public:
    /* 0x200 */ dDlst_2D_c* mNvLogo;
    /* 0x204 */ dDlst_2D_c* mMocImg;
 #endif
-#if VERSION == VERSION_GCN_PAL
+#if TARGET_PC || VERSION == VERSION_GCN_PAL
    /* 0x1FC */ mDoDvdThd_mountArchive_c* mpPalLogoResCommand;
 #endif
    /* 0x1FC */ request_of_phase_process_class* m_preLoad_dylPhase;
@@ -486,6 +486,9 @@ public:
            mDeathCount++;
        }
    }
+#if TARGET_PC
+    u16 getDeathCount() const { return mDeathCount; }
+#endif
    char* getPlayerName() const { return const_cast<char*>(mPlayerName); }
    void setPlayerName(const char* i_name) {
 #if AVOID_UB
@@ -47,6 +47,13 @@ public:
        mPositionY = y;
    }

+#ifdef TARGET_PC
+    f32 getPositionX() const { return mPositionX; }
+    f32 getPositionY() const { return mPositionY; }
+
+    void refreshAspectScale();
+#endif
+
    void onUpdateFlag() { mUpdateFlag = true; }

    void resetUpdateFlag() { mUpdateFlag = false; }
@@ -79,6 +86,9 @@ private:
    /* 0x58 */ f32 mPositionX;
    /* 0x5C */ f32 mPositionY;
    /* 0x60 */ f32 mParam1;
+#ifdef TARGET_PC
+    f32 mBaseParam1;
+#endif
    /* 0x64 */ f32 mParam2;
    /* 0x68 */ f32 mParam3;
    /* 0x6C */ f32 mParam4;
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <queue>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+#include <vector>
+#include "nlohmann/json.hpp"
+
+namespace dusk {
+
+enum class AchievementCategory : uint8_t {
+    Challenge,
+    Collection,
+    Minigame,
+    Misc,
+    Glitched
+};
+
+struct Achievement {
+    const char* key;
+    const char* name;
+    const char* description;
+    AchievementCategory category;
+    bool isCounter;
+    int32_t goal;
+    int32_t progress;
+    bool unlocked;
+};
+
+// Responsible for updating a.progress.
+// Use extra for any per-achievement state that must survive across frames or sessions, extra is saved
+using AchievementCheckFn = std::function<void(Achievement& a, nlohmann::json& extra)>;
+
+class AchievementSystem {
+public:
+    static AchievementSystem& get();
+
+    void load();
+    void save();
+    void tick();
+    void clearAll();
+    void clearOne(const char* key);
+
+    // Signals are visible to all achievement checks within the same tick, then cleared.
+    void signal(const char* key);
+    bool hasSignal(const char* key) const;
+
+    std::vector<Achievement> getAchievements() const;
+
+private:
+    struct Entry {
+        Achievement achievement;
+        AchievementCheckFn check;
+        nlohmann::json extra;
+    };
+
+    AchievementSystem();
+    static std::vector<Entry> makeEntries();
+    void processEntry(Entry& e);
+
+    std::vector<Entry> m_entries;
+    std::unordered_set<std::string_view> m_signals;
+    bool m_loaded = false;
+    bool m_dirty = false;
+};
+
+} // namespace dusk
@@ -12,6 +12,8 @@ namespace dusk::audio {

    void SetMasterVolume(f32 value);

+    void SetPaused(bool paused);
+
    u32 GetResetCount(int channelIdx);

    f32 VolumeFromU16(u16 value);
@@ -0,0 +1,17 @@
+#pragma once
+
+#ifndef AUTOSAVE_H
+#define AUTOSAVE_H
+
+#include <m_Do/m_Do_MemCardRWmng.h>
+#include <m_Do/m_Do_MemCard.h>
+
+void noAutoSave();
+void triggerAutoSave();
+void updateAutoSave();
+void enterAutoSave();
+void autoSaving();
+void waitingForWrite();
+void endAutoSave();
+
+#endif
@@ -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
@@ -0,0 +1,14 @@
+#pragma once
+
+#ifdef DUSK_DISCORD
+
+namespace dusk::discord {
+
+void initialize();
+void run_callbacks();
+void update_presence();
+void shutdown();
+
+}  // namespace dusk::discord
+
+#endif  // DUSK_DISCORD
@@ -6,7 +6,6 @@
 #include "aurora/gfx.h"

 extern AuroraInfo auroraInfo;
-extern const char* configPath;

 namespace dusk {
    extern AuroraStats lastFrameAuroraStats;
@@ -1,22 +1,31 @@
 #pragma once

 #include "dolphin/types.h"
+#include "version.hpp"

 namespace dusk {

+struct OffsetVersion {
+    version::GameVersion mGameVersion;
+    u32 mOffset;
+
+    constexpr OffsetVersion(const version::GameVersion gameVersion, const u32 offset)
+        : mGameVersion(gameVersion), mOffset(offset) {}
+};
+
 /**
 * Load bytes from the main DOL by GameCube virtual address
 */
-bool LoadDolAsset(void* dst, u32 virtualAddress, s32 size);
+bool LoadDolAsset(void* dst, std::initializer_list<OffsetVersion> virtualAddress, s32 size);

 /**
 * Load bytes from a REL file in the ISO filesystem, dst must be 32-byte aligned
 */
-bool LoadRelAsset(void* dst, const char* dvdPath, s32 offset, s32 size);
+bool LoadRelAsset(void* dst, const char* dvdPath, std::initializer_list<OffsetVersion> offset, s32 size);

 /**
 * Load bytes from a REL inside RELS.arc
 */
-bool LoadArchivedRelAsset(void* dst, u32 memType, const char* relFileName, s32 offset, s32 size);
+bool LoadArchivedRelAsset(void* dst, u32 memType, const char* relFileName, std::initializer_list<OffsetVersion> offset, s32 size);

 }  // namespace dusk
@@ -1,5 +1,4 @@
-#ifndef DUSK_FRAME_INTERP_H
-#define DUSK_FRAME_INTERP_H
+#pragma once

 #include <dolphin/mtx.h>
 #include <stdbool.h>
@@ -7,6 +6,7 @@
 #include <stdint.h>

 class camera_process_class;
+class view_class;

 #ifdef __cplusplus
 namespace dusk {
@@ -16,40 +16,37 @@ void ensure_initialized();

 void begin_record();
 void end_record();
-void interpolate(float step);
+void begin_sim_tick();
+void begin_frame(bool enabled, bool is_sim_frame, float step);
+void interpolate();
 float get_interpolation_step();

 void request_presentation_sync();
 bool presentation_sync_active();

+bool is_enabled();
+
 // TODO: These should be phased out as UI is progressively updated to use game_clock
 void set_ui_tick_pending(bool value);
 bool get_ui_tick_pending();

-void open_child(const void* key, int32_t id);
-void close_child();
-void record_camera(::camera_process_class* cam, int camera_id);
-void record_final_mtx_raw(const Mtx* dest, const Mtx src);
-void record_final_mtx_raw_tagged(const Mtx* dest, const Mtx src, uint64_t stable_tag);
+bool is_sim_frame();

-bool lookup_replacement(const void* source, Mtx out);
+void record_camera(::camera_process_class* cam, int camera_id);
+void interp_view(::view_class* view);
+void record_final_mtx(Mtx m, const void *key);
+void record_final_mtx(Mtx m);
+
+bool lookup_replacement(const void* key, Mtx out);
 bool lookup_concat_replacement(const void* lhs, const void* rhs, Mtx out);

+typedef void (*InterpolationCallBack)(bool isSimFrame, void* pUserWork);
+// call on a sim tick, will get called during presentation
+void add_interpolation_callback(InterpolationCallBack pCallBack, void* pUserWork);
+
 void begin_presentation_camera();
 void end_presentation_camera();

-struct PresentationCameraScope {
-    PresentationCameraScope() { begin_presentation_camera(); }
-    ~PresentationCameraScope() { end_presentation_camera(); }
-    PresentationCameraScope(const PresentationCameraScope&) = delete;
-    PresentationCameraScope& operator=(const PresentationCameraScope&) = delete;
-    PresentationCameraScope(PresentationCameraScope&&) = delete;
-    PresentationCameraScope& operator=(PresentationCameraScope&&) = delete;
-};
-
-uint64_t alloc_simple_shadow_pair_base();
 }  // namespace frame_interp
 }  // namespace dusk
 #endif
-
-#endif
@@ -1,13 +1,9 @@
-#ifndef DUSK_GAME_CLOCK_H
-#define DUSK_GAME_CLOCK_H
+#pragma once

-#include <stddef.h>
-
-namespace dusk {
-namespace game_clock {
+namespace dusk::game_clock {

 void ensure_initialized();
-void reset_accumulator();
+void reset_frame_timer();

 constexpr float sim_pace() { return 1.0f / 30.0f; }
 constexpr float period_for_original_frames(float frame_count) { return frame_count * sim_pace(); }
@@ -17,16 +13,14 @@ constexpr float ui_initial_dt() { return 1.0f / 60.0f; }
 struct MainLoopPacer {
    float presentation_dt_seconds;
    bool is_interpolating;
-    bool do_sim_tick;
-    float interpolation_step;
+    int sim_ticks_to_run;
    float sim_pace;
 };

 MainLoopPacer advance_main_loop();
+void commit_sim_tick();
+float sample_interpolation_step();

 float consume_interval(const void* consumer);

-}  // namespace game_clock
-}  // namespace dusk
-
-#endif  // DUSK_GAME_CLOCK_H
+} // namespace dusk::game_clock
@@ -0,0 +1,8 @@
+#pragma once
+
+#ifndef GAMEPAD_COLOR_H
+#define GAMEPAD_COLOR_H
+
+void handleGamepadColor();
+
+#endif
@@ -12,6 +12,7 @@ void rollgoalTableOffset(s16& out_ax, s16& out_az);
 extern bool s_sensor_keep_alive;
 bool get_sensor_keep_alive();
 void set_sensor_keep_alive(bool value);
+bool rollgoal_gyro_enabled();
 }  // namespace dusk::gyro

 #endif
@@ -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
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstdint>
+
+namespace dusk::speedrun {
+void onGameFrame();
+uint64_t getFrameCount();
+void start();
+void reset();
+void connectLiveSplit(const char* host = "127.0.0.1", int port = 16834);
+void disconnectLiveSplit();
+bool consumeConnectedEvent();
+bool consumeDisconnectedEvent();
+void updateLiveSplit();
+void shutdown();
+}
@@ -4,10 +4,12 @@
 #include <aurora/aurora.h>
 #include <aurora/lib/logging.hpp>

+#include <filesystem>
+
 void aurora_log_callback(AuroraLogLevel level, const char* module, const char* message, unsigned int len);

 namespace dusk {
-    void InitializeFileLogging(const char* configDir, AuroraLogLevel logLevel);
+    void InitializeFileLogging(const std::filesystem::path& configDir, AuroraLogLevel logLevel);
    void ShutdownFileLogging();
    const char* GetLogFilePath();
    void SendToStubLog(AuroraLogLevel level, const char* module, const char* message);
@@ -1,10 +1,36 @@
 #ifndef DUSK_MAIN_H
 #define DUSK_MAIN_H

+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#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;
    extern bool IsGameLaunched;
+    extern bool RestartRequested;
+    extern std::filesystem::path ConfigPath;
+
+#if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) || \
+    (defined(TARGET_OS_TV) && TARGET_OS_TV)
+    inline constexpr bool SupportsProcessRestart = false;
+#else
+    inline constexpr bool SupportsProcessRestart = true;
+#endif
+
+    void RequestRestart() noexcept;
+    bool OpenDataFolder();
 }

 #endif  // DUSK_MAIN_H
@@ -1,5 +1,7 @@
 #pragma once

+#include <array>
+
 struct RoomEntry {
    u8 roomNo;
    std::vector<s16> roomPoints = {};
@@ -2,9 +2,6 @@
 #define _SRC_DUSK_MATH_H_

 #include <cmath>
-#include <array>
-#include <limits>
-#include <bit>

 #ifndef M_PI
 #define M_PI 3.14159265358979323846f
@@ -19,139 +16,6 @@ inline float i_cosf(float x) { return cos(x); }
 inline float i_tanf(float x) { return tan(x); }
 inline float i_acosf(float x) { return acos(x); }

-
-// frsqrte matching courtesy of Geotale, with reference to https://achurch.org/cpu-tests/ppc750cl.s
-
-struct BaseAndDec32 {
-    uint32_t base;
-    int32_t dec;
-};
-
-struct BaseAndDec64 {
-    uint64_t base;
-    int64_t dec;
-};
-
-union c32 {
-    constexpr c32(const float p) {
-        f = p;
-    }
-
-    constexpr c32(const uint32_t p) {
-        u = p;
-    }
-
-    uint32_t u;
-    float f;
-};
-
-union c64 {
-    constexpr c64(const double p) {
-        f = p;
-    }
-
-    constexpr c64(const uint64_t p) {
-        u = p;
-    }
-
-    uint64_t u;
-    double f;
-};
-
-static constexpr uint64_t EXPONENT_SHIFT_F64 = 52;
-static constexpr uint64_t MANTISSA_MASK_F64 = 0x000fffffffffffffULL;
-static constexpr uint64_t EXPONENT_MASK_F64 = 0x7ff0000000000000ULL;
-static constexpr uint64_t SIGN_MASK_F64 = 0x8000000000000000ULL;
-
-static constexpr std::array<BaseAndDec64, 32> RSQRTE_TABLE = {{
-        {0x69fa000000000ULL, -0x15a0000000LL},
-        {0x5f2e000000000ULL, -0x13cc000000LL},
-        {0x554a000000000ULL, -0x1234000000LL},
-        {0x4c30000000000ULL, -0x10d4000000LL},
-        {0x43c8000000000ULL, -0x0f9c000000LL},
-        {0x3bfc000000000ULL, -0x0e88000000LL},
-        {0x34b8000000000ULL, -0x0d94000000LL},
-        {0x2df0000000000ULL, -0x0cb8000000LL},
-        {0x2794000000000ULL, -0x0bf0000000LL},
-        {0x219c000000000ULL, -0x0b40000000LL},
-        {0x1bfc000000000ULL, -0x0aa0000000LL},
-        {0x16ae000000000ULL, -0x0a0c000000LL},
-        {0x11a8000000000ULL, -0x0984000000LL},
-        {0x0ce6000000000ULL, -0x090c000000LL},
-        {0x0862000000000ULL, -0x0898000000LL},
-        {0x0416000000000ULL, -0x082c000000LL},
-        {0xffe8000000000ULL, -0x1e90000000LL},
-        {0xf0a4000000000ULL, -0x1c00000000LL},
-        {0xe2a8000000000ULL, -0x19c0000000LL},
-        {0xd5c8000000000ULL, -0x17c8000000LL},
-        {0xc9e4000000000ULL, -0x1610000000LL},
-        {0xbedc000000000ULL, -0x1490000000LL},
-        {0xb498000000000ULL, -0x1330000000LL},
-        {0xab00000000000ULL, -0x11f8000000LL},
-        {0xa204000000000ULL, -0x10e8000000LL},
-        {0x9994000000000ULL, -0x0fe8000000LL},
-        {0x91a0000000000ULL, -0x0f08000000LL},
-        {0x8a1c000000000ULL, -0x0e38000000LL},
-        {0x8304000000000ULL, -0x0d78000000LL},
-        {0x7c48000000000ULL, -0x0cc8000000LL},
-        {0x75e4000000000ULL, -0x0c28000000LL},
-        {0x6fd0000000000ULL, -0x0b98000000LL},
-}};
-
-[[nodiscard]] static inline double frsqrte(const double val) {
-    c64 bits(val);
-
-    uint64_t mantissa = bits.u & MANTISSA_MASK_F64;
-    int64_t exponent = bits.u & EXPONENT_MASK_F64;
-    bool sign = (bits.u & SIGN_MASK_F64) != 0;
-
-    // Handle 0 case
-    if (mantissa == 0 && exponent == 0) {
-        return std::copysign(std::numeric_limits<double>::infinity(), bits.f);
-    }
-
-    // Handle NaN-like
-    if (exponent == EXPONENT_MASK_F64) {
-        if (mantissa == 0) {
-            return sign ? std::numeric_limits<double>::quiet_NaN() : 0.0;
-        }
-
-        return val;
-    }
-
-    // Handle negative inputs
-    if (sign) {
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-
-    if (exponent == 0) {
-        // Shift so one bit goes to where the exponent would be,
-        // then clear that bit to mimic a not-subnormal number!
-        // Aka, if there are 12 leading zeroes, shift left once
-        uint32_t shift = std::countl_zero(mantissa) - static_cast<uint32_t>(63 - EXPONENT_SHIFT_F64);
-
-        mantissa <<= shift;
-        mantissa &= MANTISSA_MASK_F64;
-        // The shift is subtracted by 1 because denormals by default
-        // are offset by 1 (exponent 0 doesn't have implied 1 bit)
-        exponent -= static_cast<int64_t>(shift - 1) << EXPONENT_SHIFT_F64;
-    }
-
-    // In reality this doesn't get the full exponent -- Only the least significant bit
-    // Only that's needed because square roots of higher exponent bits simply multiply the
-    // result by 2!!
-    uint32_t key = static_cast<uint32_t>((static_cast<uint64_t>(exponent) | mantissa) >> 37);
-    uint64_t new_exp =
-            (static_cast<uint64_t>((0xbfcLL << EXPONENT_SHIFT_F64) - exponent) >> 1) & EXPONENT_MASK_F64;
-
-    // Remove the bits relating to anything higher than the LSB of the exponent
-    const auto &entry = RSQRTE_TABLE[0x1f & (key >> 11)];
-
-    // The result is given by an estimate then an adjustment based on the original
-    // key that was computed
-    uint64_t new_mantissa = static_cast<uint64_t>(entry.base + entry.dec * static_cast<int64_t>(key & 0x7ff));
-
-    return c64(new_exp | new_mantissa).f;
-}
+#include <dolphin/ppc_math.h>

 #endif // _SRC_DUSK_MATH_H_
@@ -13,12 +13,49 @@ enum class BloomMode : int {
    Dusk = 2,
 };

+enum class GameLanguage : u8 {
+    English = OS_LANGUAGE_ENGLISH,
+    German = OS_LANGUAGE_GERMAN,
+    French = OS_LANGUAGE_FRENCH,
+    Spanish = OS_LANGUAGE_SPANISH,
+    Italian = OS_LANGUAGE_ITALIAN,
+};
+
+enum class DiscVerificationState : u8 {
+    Unknown = 0,
+    Success,
+    HashMismatch,
+};
+
+enum class GyroMode : u8 {
+    Sensor = 0,
+    Mouse = 1,
+};
+
 namespace config {
 template <>
 struct ConfigEnumRange<BloomMode> {
    static constexpr auto min = BloomMode::Off;
    static constexpr auto max = BloomMode::Dusk;
 };
+
+template <>
+struct ConfigEnumRange<GameLanguage> {
+    static constexpr auto min = GameLanguage::English;
+    static constexpr auto max = GameLanguage::Italian;
+};
+
+template <>
+struct ConfigEnumRange<DiscVerificationState> {
+    static constexpr auto min = DiscVerificationState::Unknown;
+    static constexpr auto max = DiscVerificationState::HashMismatch;
+};
+
+template <>
+struct ConfigEnumRange<GyroMode> {
+    static constexpr auto min = GyroMode::Sensor;
+    static constexpr auto max = GyroMode::Mouse;
+};
 }

 // Persistent user settings
@@ -31,6 +68,8 @@ struct UserSettings {
        ConfigVar<bool> enableFullscreen;
        ConfigVar<bool> enableVsync;
        ConfigVar<bool> lockAspectRatio;
+        ConfigVar<bool> enableFpsOverlay;
+        ConfigVar<int> fpsOverlayCorner;
    } video;

    struct {
@@ -41,15 +80,18 @@ struct UserSettings {
        ConfigVar<int> soundEffectsVolume;
        ConfigVar<int> fanfareVolume;
        ConfigVar<bool> enableReverb;
+        ConfigVar<bool> enableHrtf;
+        ConfigVar<bool> menuSounds;
    } audio;

    // Game settings

    struct {
+        ConfigVar<GameLanguage> language;
+
        // QoL
        ConfigVar<bool> enableQuickTransform;
        ConfigVar<bool> hideTvSettingsScreen;
-        ConfigVar<bool> skipWarningScreen;
        ConfigVar<bool> biggerWallets;
        ConfigVar<bool> noReturnRupees;
        ConfigVar<bool> disableRupeeCutscenes;
@@ -60,28 +102,36 @@ struct UserSettings {
        ConfigVar<bool> fastClimbing;
        ConfigVar<bool> noMissClimbing;
        ConfigVar<bool> fastTears;
+        ConfigVar<bool> no2ndFishForCat;
        ConfigVar<bool> instantSaves;
        ConfigVar<bool> instantText;
        ConfigVar<bool> sunsSong;
+        ConfigVar<bool> autoSave;

        // Preferences
        ConfigVar<bool> enableMirrorMode;
-        ConfigVar<bool> invertCameraXAxis;
-        ConfigVar<bool> disableMainHUD;
+        ConfigVar<bool> minimalHUD;
+        ConfigVar<bool> pauseOnFocusLost;
+        ConfigVar<bool> enableLinkDollRotation;
+        ConfigVar<bool> enableAchievementToasts;
+        ConfigVar<bool> enableControllerToasts;

        // Graphics
        ConfigVar<BloomMode> bloomMode;
        ConfigVar<float> bloomMultiplier;
-        ConfigVar<bool> enableWaterRefraction;
+        ConfigVar<bool> disableWaterRefraction;
        ConfigVar<bool> enableFrameInterpolation;
        ConfigVar<int> internalResolutionScale;
        ConfigVar<int> shadowResolutionMultiplier;
+        ConfigVar<bool> enableDepthOfField;
+        ConfigVar<bool> enableMapBackground;

        // Audio
        ConfigVar<bool> noLowHpSound;
        ConfigVar<bool> midnasLamentNonStop;

        // Input
+        ConfigVar<GyroMode> gyroMode;
        ConfigVar<bool> enableGyroAim;
        ConfigVar<bool> enableGyroRollgoal;
        ConfigVar<float> gyroSensitivityX;
@@ -91,6 +141,15 @@ struct UserSettings {
        ConfigVar<float> gyroDeadband;
        ConfigVar<bool> gyroInvertPitch;
        ConfigVar<bool> gyroInvertYaw;
+        ConfigVar<bool> freeCamera;
+        ConfigVar<bool> invertCameraXAxis;
+        ConfigVar<bool> invertCameraYAxis;
+        ConfigVar<bool> invertFirstPersonXAxis;
+        ConfigVar<bool> invertFirstPersonYAxis;
+        ConfigVar<float> freeCameraSensitivity;
+        ConfigVar<bool> debugFlyCam;
+        ConfigVar<bool> debugFlyCamLockEvents;
+        ConfigVar<bool> allowBackgroundInput;

        // Cheats
        ConfigVar<bool> infiniteHearts;
@@ -99,6 +158,7 @@ struct UserSettings {
        ConfigVar<bool> infiniteOil;
        ConfigVar<bool> infiniteOxygen;
        ConfigVar<bool> infiniteRupees;
+        ConfigVar<bool> enableIndefiniteItemDrops;
        ConfigVar<bool> moonJump;
        ConfigVar<bool> superClawshot;
        ConfigVar<bool> alwaysGreatspin;
@@ -112,16 +172,23 @@ struct UserSettings {

        // Controls
        ConfigVar<bool> enableTurboKeybind;
+
+        // Tools
+        ConfigVar<bool> speedrunMode;
+        ConfigVar<bool> liveSplitEnabled;
+        ConfigVar<bool> recordingMode;
    } game;

    struct {
        ConfigVar<std::string> isoPath;
+        ConfigVar<DiscVerificationState> isoVerification;
        ConfigVar<std::string> graphicsBackend;
        ConfigVar<bool> skipPreLaunchUI;
        ConfigVar<bool> showPipelineCompilation;
        ConfigVar<bool> wasPresetChosen;
-        ConfigVar<bool> enableCrashReporting;
-        ConfigVar<bool> duskMenuOpen;
+        ConfigVar<bool> checkForUpdates;
+        ConfigVar<int> cardFileType;
+        ConfigVar<bool> enableAdvancedSettings;
    } backend;
 };

@@ -146,6 +213,7 @@ struct TransientSettings {
    CollisionViewSettings collisionView;
    bool skipFrameRateLimit;
    bool moveLinkActive;
+    bool stateShareLoadActive;
 };

 TransientSettings& getTransientSettings();
@@ -1,9 +1,10 @@
 #ifndef DUSK_TIME_H
 #define DUSK_TIME_H

-#include <chrono>
-#include <numeric>
 #include <array>
+#include <numeric>
+
+#include "SDL3/SDL_timer.h"

 #ifdef _WIN32
 #ifndef WIN32_LEAN_AND_MEAN
@@ -15,28 +16,26 @@
 #include <Windows.h>
 #include <shellapi.h>
 #include <intrin.h>
-#else
-#include "SDL3/SDL_timer.h"
 #endif

 class Limiter {
-  using delta_clock = std::chrono::high_resolution_clock;
-  using duration_t = std::chrono::nanoseconds;
-
 public:
-  void Reset() { m_oldTime = delta_clock::now(); }
+  using duration_t = Uint64;
+
+  void Reset() { m_oldTime = SDL_GetTicksNS(); }

  void Sleep(duration_t targetFrameTime) {
-    if (targetFrameTime.count() == 0) {
+    if (targetFrameTime == 0) {
      return;
    }

-    auto start = delta_clock::now();
+    const Uint64 start = SDL_GetTicksNS();
    duration_t adjustedSleepTime = SleepTime(targetFrameTime);
-    if (adjustedSleepTime.count() > 0) {
+    if (adjustedSleepTime > 0) {
      NanoSleep(adjustedSleepTime);
-      duration_t overslept = TimeSince(start) - adjustedSleepTime;
-      if (overslept < duration_t{targetFrameTime}) {
+      const duration_t elapsed = TimeSince(start);
+      const duration_t overslept = elapsed > adjustedSleepTime ? elapsed - adjustedSleepTime : 0;
+      if (overslept < targetFrameTime) {
        m_overheadTimes[m_overheadTimeIdx] = overslept;
        m_overheadTimeIdx = (m_overheadTimeIdx + 1) % m_overheadTimes.size();
      }
@@ -45,23 +44,23 @@ public:
  }

  duration_t SleepTime(duration_t targetFrameTime) {
-    const auto sleepTime = duration_t{targetFrameTime} - TimeSince(m_oldTime);
-    m_overhead = std::accumulate(m_overheadTimes.begin(), m_overheadTimes.end(), duration_t{}) / m_overheadTimes.size();
+    const duration_t elapsed = TimeSince(m_oldTime);
+    const duration_t sleepTime = elapsed < targetFrameTime ? targetFrameTime - elapsed : 0;
+    m_overhead = std::accumulate(m_overheadTimes.begin(), m_overheadTimes.end(), duration_t{0}) /
+                 m_overheadTimes.size();
    if (sleepTime > m_overhead) {
      return sleepTime - m_overhead;
    }
-    return duration_t{0};
+    return 0;
  }

 private:
-  delta_clock::time_point m_oldTime;
+  Uint64 m_oldTime = 0;
  std::array<duration_t, 4> m_overheadTimes{};
  size_t m_overheadTimeIdx = 0;
-  duration_t m_overhead = duration_t{0};
+  duration_t m_overhead = 0;

-  duration_t TimeSince(delta_clock::time_point start) {
-    return std::chrono::duration_cast<duration_t>(delta_clock::now() - start);
-  }
+  duration_t TimeSince(Uint64 start) const { return SDL_GetTicksNS() - start; }

 #if _WIN32
  void NanoSleep(const duration_t duration) {
@@ -85,9 +84,10 @@ private:

    LARGE_INTEGER start, current;
    QueryPerformanceCounter(&start);
-    LONGLONG ticksToWait = static_cast<LONGLONG>(duration.count() * countPerNs);
-    if (DWORD ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count(); ms > 1) {
-      ::Sleep(ms - 1);
+    const LONGLONG ticksToWait = static_cast<LONGLONG>(duration * countPerNs);
+    const Uint64 ms = duration / 1'000'000ULL;
+    if (ms > 1) {
+      ::Sleep(static_cast<DWORD>(ms - 1));
    }
    do {
      QueryPerformanceCounter(&current);
@@ -99,7 +99,7 @@ private:
    } while (current.QuadPart - start.QuadPart < ticksToWait);
  }
 #else
-  void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration.count()); }
+  void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration); }
 #endif
 };

@@ -0,0 +1,67 @@
+#ifndef DUSK_VERSION_HPP
+#define DUSK_VERSION_HPP
+
+/**
+ * Functionality for switching game behavior based on the loaded game version (e.g. PAL/JPN, GC/Wii)
+ */
+namespace dusk::version {
+    enum class GameVersion : u8 {
+        GcnUsa = VERSION_GCN_USA,
+        GcnPal = VERSION_GCN_PAL,
+        GcnJpn = VERSION_GCN_JPN,
+        WiiUsaRev0 = VERSION_WII_USA_R0,
+        WiiUsa = VERSION_WII_USA_R2,
+        WiiPal = VERSION_WII_PAL,
+        WiiJpn = VERSION_WII_JPN,
+        WiiKor = VERSION_WII_KOR,
+    };
+
+    bool isGcn();
+    bool isWii();
+    bool isPalOrAtLeastWiiR2();
+
+    bool isRegionPal();
+    bool isRegionJpn();
+    bool isRegionUsa();
+
+    GameVersion getGameVersion();
+
+    const DVDDiskID& getDiskID();
+
+    void init();
+
+    template<typename T>
+    struct VersionOption {
+        GameVersion mVersion;
+        T mValue;
+
+        constexpr VersionOption(GameVersion version, T value) : mVersion(version), mValue(value) {}
+    };
+
+    template<typename T>
+    const T& versionSelect(const std::initializer_list<VersionOption<T>> options) {
+        const auto version = getGameVersion();
+        for (const auto& opt : options) {
+            if (opt.mVersion == version) {
+                return opt.mValue;
+            }
+        }
+
+        // Unable to find value.
+        abort();
+    }
+
+    template<typename T>
+    const T& versionSelect(const std::initializer_list<VersionOption<T>> options, const T& defaultValue) {
+        const auto version = getGameVersion();
+        for (const auto& opt : options) {
+            if (opt.mVersion == version) {
+                return opt.mValue;
+            }
+        }
+
+        return defaultValue;
+    }
+}  // namespace dusk::version
+
+#endif  // DUSK_VERSION_HPP
@@ -25,7 +25,7 @@ typedef struct leafdraw_class : base_process_class {
 #endif
    /* 0xB8 */ leafdraw_method_class* leaf_methods;
    /* 0xBC */ s8 unk_0xBC;
-    /* 0xBD */ u8 unk_0xBD;
+    /* 0xBD */ u8 draw_interp_frame;
    /* 0xBE */ draw_priority_class draw_priority;
 } leafdraw_class;

@@ -18,6 +18,7 @@ typedef struct process_node_class {
    /* 0x0BC */ layer_class layer;
    /* 0x0E8 */ node_list_class layer_nodelist[16];
    /* 0x1A8 */ s8 unk_0x1A8;
+    /* 0x1A9 */ s8 draw_interp_frame;
 } process_node_class;

 typedef struct node_process_profile_definition {
@@ -73,6 +73,9 @@
 #endif

 #ifndef __MWERKS__
+#ifdef __cplusplus
+extern "C" {
+#endif
 // Silence clangd errors about MWCC PPC intrinsics by declaring them here.
 extern int __cntlzw(unsigned int);
 extern int __rlwimi(int, int, int, int, int);
@@ -80,7 +83,14 @@ extern void __dcbf(void*, int);
 extern void __dcbz(void*, int);
 extern void __sync();
 extern int __abs(int);
-void* __memcpy(void*, const void*, int);
+#if defined(__has_builtin) && __has_builtin(__builtin_memcpy)
+#define __memcpy __builtin_memcpy
+#else
+#define __memcpy memcpy
+#endif
+#ifdef __cplusplus
+}
+#endif
 #endif

 #ifndef M_PI
@@ -220,12 +230,16 @@ using std::isnan;
 // Some basic macros that are more convenient than putting down #if blocks for one-line changes.
 #if TARGET_PC
 #define IF_DUSK(statement) statement
+#define IF_DUSK_BLOCK(cond) if (cond) {
+#define IF_DUSK_BLOCK_END }
 #define IF_DUSK_ARG(expr) , expr
 #define IF_NOT_DUSK(statement)
 #define DUSK_IF_ELSE(dusk, orig) dusk
 #else
 #define IF_DUSK(statement)
 #define IF_DUSK_ARG(expr)
+#define IF_DUSK_BLOCK(cond)
+#define IF_DUSK_BLOCK_END
 #define IF_NOT_DUSK(statement) statement
 #define DUSK_IF_ELSE(dusk, orig) orig
 #endif
@@ -5,6 +5,7 @@
 #include "Z2AudioLib/Z2EnvSeMgr.h"
 #include "Z2AudioLib/Z2LinkMgr.h"
 #include "dusk/audio.h"
+#include "dusk/settings.h"

 class mDoAud_zelAudio_c : public Z2AudioMgr {
 public:
@@ -132,6 +133,18 @@ inline void mDoAud_seStart(u32 i_sfxID, const Vec* i_sePos, u32 param_2, s8 i_re
                                               -1.0f, -1.0f, 0);
 }

+#if TARGET_PC
+inline void mDoAud_seStartMenu(u32 i_sfxID) {
+    if (!mDoAud_zelAudio_c::isInitFlag()) {
+        return;
+    }
+    if (!dusk::getSettings().audio.menuSounds.getValue()) {
+        return;
+    }
+    mDoAud_seStart(i_sfxID, nullptr, 0, 0);
+}
+#endif
+
 inline void mDoAud_seStartLevel(u32 i_sfxID, const Vec* i_sePos, u32 param_2, s8 i_reverb) {
    DUSK_AUDIO_SKIP()
    Z2AudioMgr::getInterface()->seStartLevel(i_sfxID, i_sePos, param_2, i_reverb, 1.0f, 1.0f,
@@ -79,6 +79,10 @@ public:
    virtual void viewCalc();
    virtual ~J3DModel() {}

+#if TARGET_PC
+    static void interp_callback(bool isSimFrame, void* pUserWork);
+#endif
+
    J3DModelData* getModelData() { return mModelData; }

    void onFlag(u32 flag) { mFlags |= flag; }
@@ -105,9 +109,7 @@ public:
    void setAnmMtx(int jointNo, Mtx m) {
        mMtxBuffer->setAnmMtx(jointNo, m);
 #ifdef TARGET_PC
-        dusk::frame_interp::record_final_mtx_raw(
-            reinterpret_cast<const Mtx*>(mMtxBuffer->getAnmMtx(jointNo)),
-            mMtxBuffer->getAnmMtx(jointNo));
+        dusk::frame_interp::record_final_mtx(mMtxBuffer->getAnmMtx(jointNo));
 #endif
    }
    MtxP getAnmMtx(int jointNo) { return mMtxBuffer->getAnmMtx(jointNo); }
@@ -23,6 +23,10 @@ public:
    void syncJ3DSysPointers() const;
    void syncJ3DSysFlags() const;

+#if TARGET_PC
+    bool needsInterpCallBack() const;
+#endif
+
    virtual ~J3DModelData() {}

    void simpleCalcMaterial(Mtx mtx) { simpleCalcMaterial(0, mtx); }
@@ -33,6 +33,9 @@ public:
    void copy(J3DMaterial*);
    s32 newSharedDisplayList(u32);
    s32 newSingleSharedDisplayList(u32);
+#if TARGET_PC
+    bool needsInterpCallBack() const;
+#endif

    virtual void calc(f32 const (*)[4]);
    virtual void calcDiffTexMtx(f32 const (*)[4]);
@@ -46,7 +49,6 @@ public:
    virtual void change();

    J3DMaterial() { initialize(); }
-    ~J3DMaterial() {}
    J3DMaterial* getNext() { return mNext; }
    J3DShape* getShape() { return mShape; }
    J3DTevBlock* getTevBlock() { return mTevBlock; }
@@ -1,9 +1,9 @@
 #ifndef J3DSTRUCT_H
 #define J3DSTRUCT_H

+#include <cstring>
 #include <gx.h>
 #include <mtx.h>
-#include <mtx.h>
 #include "global.h"
 #include "JSystem/JMath/JMath.h"

@@ -11,7 +11,7 @@

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DLightInfo {
    bool operator==(J3DLightInfo& other) const;
@@ -28,7 +28,7 @@ struct J3DLightInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTextureSRTInfo {
    // NOTE: Big endian when loaded from file!
@@ -79,7 +79,7 @@ enum J3DTexMtxMode {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTexMtxInfo {
    bool operator==(J3DTexMtxInfo& other) const;
@@ -97,7 +97,7 @@ struct J3DTexMtxInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DIndTexMtxInfo {
    J3DIndTexMtxInfo& operator=(J3DIndTexMtxInfo const&);
@@ -107,7 +107,7 @@ struct J3DIndTexMtxInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DFogInfo {
    bool operator==(J3DFogInfo&) const;
@@ -126,7 +126,7 @@ struct J3DFogInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DNBTScaleInfo {
    bool operator==(const J3DNBTScaleInfo& other) const;
@@ -153,7 +153,7 @@ struct J3DIndTexOrderInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevSwapModeInfo {
    /* 0x0 */ u8 mRasSel;
@@ -164,7 +164,7 @@ struct J3DTevSwapModeInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevSwapModeTableInfo {
    /* 0x0 */ u8 field_0x0;
@@ -175,7 +175,7 @@ struct J3DTevSwapModeTableInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevStageInfo {
    /* 0x0 */ u8 field_0x0;
@@ -202,7 +202,7 @@ struct J3DTevStageInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DIndTevStageInfo {
    /* 0x0 */ u8 mIndStage;
@@ -219,7 +219,7 @@ struct J3DIndTevStageInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTexCoordInfo {
    /* 0x0 */ u8 mTexGenType;
@@ -265,7 +265,7 @@ struct J3DBlendInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevOrderInfo {
    void operator=(const J3DTevOrderInfo& other) {
@@ -59,6 +59,9 @@ public:
    bool isActive() const { return mSeqList.getNumLinks() != 0; }
    int getNumActiveSeqs() const { return mSeqList.getNumLinks(); }
    void pause(bool paused) { mActivity.field_0x0.flags.flag2 = paused; }
+    #if TARGET_PC
+    JSUList<JAISeq>* getSeqList() { return &mSeqList; }
+    #endif

 private:
    /* 0x08 */ JAIAudience* mAudience;
@@ -207,4 +207,11 @@ void JPARegistAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*);
 void JPARegistPrmAlpha(JPAEmitterWorkData*, JPABaseParticle*);
 void JPARegistPrmAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*);

+#if TARGET_PC
+void JPAInterpBillboard(JPAEmitterWorkData*, JPABaseParticle*);
+void JPAInterpRotBillboard(JPAEmitterWorkData*, JPABaseParticle*);
+void JPAInterpDirection(JPAEmitterWorkData*, JPABaseParticle*);
+void JPAInterpRotDirection(JPAEmitterWorkData*, JPABaseParticle*);
+#endif
+
 #endif /* JPABASESHAPE_H */
@@ -24,6 +24,9 @@ public:
    void init_c(JPAEmitterWorkData*, JPABaseParticle*);
    bool calc_p(JPAEmitterWorkData*);
    bool calc_c(JPAEmitterWorkData*);
+#if TARGET_PC
+    void interp(JPAEmitterWorkData*, void const* drawFunc);
+#endif
    bool canCreateChild(JPAEmitterWorkData*);
    f32 getWidth(JPABaseEmitter const*) const;
    f32 getHeight(JPABaseEmitter const*) const;
@@ -11,8 +11,10 @@
 class JUTFader {
 public:
    enum EStatus {
-        UNKSTATUS_M1 = -1,
-        UNKSTATUS_0 = 0,
+        None,
+        Wait,
+        FadeIn,
+        FadeOut,
    };

    JUTFader(int, int, int, int, JUtility::TColor);
@@ -29,12 +31,12 @@ public:
    void setColor(JUtility::TColor color) { mColor.set(color); }

    /* 0x04 */ s32 mStatus;
-    /* 0x08 */ u16 field_0x8;
-    /* 0x0A */ u16 field_0xa;
+    /* 0x08 */ u16 mDuration;
+    /* 0x0A */ u16 mTimer;
    /* 0x0C */ JUtility::TColor mColor;
    /* 0x10 */ JGeometry::TBox2<f32> mBox;
-    /* 0x20 */ int mEStatus;
-    /* 0x24 */ u32 field_0x24;
+    /* 0x20 */ int mStatusTimer;
+    /* 0x24 */ u32 mNextStatus;
 };

 #endif /* JUTFADER_H */
@@ -263,6 +263,9 @@ public:
    /* 0x9C */ u8 field_0x9c[4];
    /* 0xA0 */ OSTime mResetHoldStartTime;
    /* 0xA8 */ u8 field_0xa8;
+#if TARGET_PC
+    u32 mResetHoldFrameCount;
+#endif
 };

 /**
@@ -40,6 +40,9 @@ public:
    JUTTransparency getTransparency() const { return JUTTransparency(mTransparency); }
    u16 getNumColors() const { return mNumColors; }
    ResTLUT* getColorTable() const { return mColorTable; }
+#if TARGET_PC
+    void dataUploaded();
+#endif

 private:
    /* 0x00 */ GXTlutObj mTlutObj;
@@ -75,6 +75,7 @@ public:
    s32 getTransparency() const { return mTexInfo->alphaEnabled; }
    s32 getWidth() const { return mTexInfo->width; }
    s32 getHeight() const { return mTexInfo->height; }
+    JUTPalette* getPalette() const { return mPalette; }
    void setCaptureFlag(bool flag) { mFlags &= 2 | flag; }
    bool getCaptureFlag() const { return mFlags & 1; }
    bool getEmbPaletteDelFlag() const { return mFlags & 2; }
@@ -82,7 +83,7 @@ public:
    int getTlutName() const { return mTlutName; }
    bool operator==(const JUTTexture& other) {
        return mTexInfo == other.mTexInfo
-            && field_0x2c == other.field_0x2c
+            && mPalette == other.mPalette
            && mWrapS == other.mWrapS
            && mWrapT == other.mWrapT
            && mMinFilter == other.mMinFilter
@@ -100,7 +101,7 @@ private:
    /* 0x20 */ const ResTIMG* mTexInfo;
    /* 0x24 */ void* mTexData;
    /* 0x28 */ JUTPalette* mEmbPalette;
-    /* 0x2C */ JUTPalette* field_0x2c;
+    /* 0x2C */ JUTPalette* mPalette;
    /* 0x30 */ u8 mWrapS;
    /* 0x31 */ u8 mWrapT;
    /* 0x32 */ u8 mMinFilter;
@@ -97,6 +97,16 @@ s32 J3DModel::entryModelData(J3DModelData* pModelData, u32 mdlFlags, u32 mtxNum)
    return kJ3DError_Success;
 }

+#if TARGET_PC
+void J3DModel::interp_callback(bool isSimFrame, void* pUserWork) {
+    J3DModel* i_this = static_cast<J3DModel*>(pUserWork);
+    if (!isSimFrame) {
+        i_this->calcMaterial();
+        i_this->diff();
+    }
+}
+#endif
+
 s32 J3DModel::createShapePacket(J3DModelData* pModelData) {
    J3D_ASSERTMSG(173, pModelData != NULL, "Error : null pointer.");

@@ -452,11 +462,11 @@ void J3DModel::calc() {

 #ifdef TARGET_PC
    for (u16 i = 0; i < mModelData->getJointNum(); ++i) {
-        dusk::frame_interp::record_final_mtx_raw(reinterpret_cast<const Mtx*>(getAnmMtx(i)), getAnmMtx(i));
+        dusk::frame_interp::record_final_mtx(getAnmMtx(i));
    }

    for (u16 i = 0; i < mModelData->getWEvlpMtxNum(); ++i) {
-        dusk::frame_interp::record_final_mtx_raw(reinterpret_cast<const Mtx*>(getWeightAnmMtx(i)), getWeightAnmMtx(i));
+        dusk::frame_interp::record_final_mtx(getWeightAnmMtx(i));
    }
 #endif
 }
@@ -485,6 +495,11 @@ void J3DModel::entry() {
            joint->entryIn();
        }
    }
+
+#if TARGET_PC
+    if (mModelData->needsInterpCallBack())
+        dusk::frame_interp::add_interpolation_callback(&J3DModel::interp_callback, this);
+#endif
 }

 void J3DModel::viewCalc() {
@@ -496,7 +511,7 @@ void J3DModel::viewCalc() {
            J3DCalcViewBaseMtx(j3dSys.getViewMtx(), mBaseScale, mBaseTransformMtx,
                               (MtxP)&mInternalView);
 #ifdef TARGET_PC
-            dusk::frame_interp::record_final_mtx_raw(&mInternalView, mInternalView);
+            dusk::frame_interp::record_final_mtx(mInternalView);
 #endif
        }
    } else if (isCpuSkinningOn()) {
@@ -504,7 +519,7 @@ void J3DModel::viewCalc() {
            J3DCalcViewBaseMtx(j3dSys.getViewMtx(), mBaseScale, mBaseTransformMtx,
                               (MtxP)&mInternalView);
 #ifdef TARGET_PC
-            dusk::frame_interp::record_final_mtx_raw(&mInternalView, mInternalView);
+            dusk::frame_interp::record_final_mtx(mInternalView);
 #endif
        }
    } else if (checkFlag(J3DMdlFlag_SkinPosCpu)) {
@@ -528,7 +543,7 @@ void J3DModel::viewCalc() {

 #ifdef TARGET_PC
    for (u16 i = 0; i < mModelData->getDrawMtxNum(); ++i) {
-        dusk::frame_interp::record_final_mtx_raw(&getDrawMtxPtr()[i], getDrawMtxPtr()[i]);
+        dusk::frame_interp::record_final_mtx(getDrawMtxPtr()[i]);
    }
 #endif

@@ -84,6 +84,15 @@ void J3DModelData::simpleCalcMaterial(u16 idx, Mtx param_1) {
    }
 }

+#if TARGET_PC
+bool J3DModelData::needsInterpCallBack() const {
+    for (u16 i = 0, n = getMaterialNum(); i < n; i++)
+        if (getMaterialNodePointer(i)->needsInterpCallBack())
+            return true;
+    return false;
+}
+#endif
+
 void J3DModelData::syncJ3DSysPointers() const {
    j3dSys.setTexture(getTexture());
    j3dSys.setVtxPos(getVtxPosArray(), getVtxNum());
@@ -265,7 +265,7 @@ void J3DMaterial::diff(u32 diffFlags) {
 }

 void J3DMaterial::calc(f32 const (*param_0)[4]) {
-    if (j3dSys.checkFlag(0x40000000)) {
+    if (j3dSys.checkFlag(J3DSysFlag_PostTexMtx)) {
        mTexGenBlock->calcPostTexMtx(param_0);
    } else {
        mTexGenBlock->calc(param_0);
@@ -276,7 +276,7 @@ void J3DMaterial::calc(f32 const (*param_0)[4]) {
 }

 void J3DMaterial::calcDiffTexMtx(f32 const (*param_0)[4]) {
-    if (j3dSys.checkFlag(0x40000000)) {
+    if (j3dSys.checkFlag(J3DSysFlag_PostTexMtx)) {
        mTexGenBlock->calcPostTexMtxWithoutViewMtx(param_0);
    } else {
        mTexGenBlock->calcWithoutViewMtx(param_0);
@@ -288,7 +288,7 @@ void J3DMaterial::setCurrentMtx() {
 }

 void J3DMaterial::calcCurrentMtx() {
-    if (!j3dSys.checkFlag(0x40000000)) {
+    if (!j3dSys.checkFlag(J3DSysFlag_PostTexMtx)) {
        mCurrentMtx.setCurrentTexMtx(
            getTexCoord(0)->getTexGenMtx(),
            getTexCoord(1)->getTexGenMtx(),
@@ -371,6 +371,30 @@ s32 J3DMaterial::newSingleSharedDisplayList(u32 dlSize) {
    return kJ3DError_Success;
 }

+#if TARGET_PC
+bool J3DMaterial::needsInterpCallBack() const {
+    for (int i = 0, n = getTexGenNum(); i < n; i++) {
+        J3DTexMtx* pTexMtx = mTexGenBlock->getTexMtx(i);
+        if (pTexMtx != NULL) {
+            u32 texMtxMode = pTexMtx->getTexMtxInfo().mInfo & 0x3f;
+
+            // uses j3dSys.getViewMtx()
+            switch (texMtxMode) {
+            case J3DTexMtxMode_EnvmapBasic:
+            case J3DTexMtxMode_EnvmapOld:
+            case J3DTexMtxMode_Envmap:
+            case J3DTexMtxMode_ProjmapBasic:
+            case J3DTexMtxMode_Projmap:
+            case J3DTexMtxMode_ViewProjmap:
+            case J3DTexMtxMode_ViewProjmapBasic:
+                return true;
+            }
+        }
+    }
+    return false;
+}
+#endif
+
 void J3DPatchedMaterial::initialize() {
    J3DMaterial::initialize();
 }
@@ -37,9 +37,9 @@ void loadTexCoordGens(u32 texGenNum, J3DTexCoord* texCoords) {
    var_r28 = 61;
    J3DGDWriteXFCmdHdr(GX_XF_REG_DUALTEX0, texGenNum);

-    if (j3dSys.checkFlag(0x40000000)) {
+    if (j3dSys.checkFlag(J3DSysFlag_PostTexMtx)) {
        for (int i = 0; i < texGenNum; i++) {
-            if (texCoords[i].getTexGenMtx() != 60) {
+            if (texCoords[i].getTexGenMtx() != GX_IDENTITY) {
                var_r28 = i * 3;
            } else {
                var_r28 = 61;
@@ -556,8 +556,8 @@ void J3DModelLoader::readVertexData(const J3DVertexBlock& block, J3DVertexData&

        if (attr == GX_VA_POS) {
            // can be a little off due to 0x20 alignment, account for that
-            u32 expect = ((data.mVtxNum * vertStride) + 0x1F) & ~0x1F;
-            JUT_ASSERT(1234, expect == addrDiff);
+            // u32 expect = ((data.mVtxNum * vertStride) + 0x1F) & ~0x1F;
+            // JUT_ASSERT(1234, expect == addrDiff);
        } else if (attr == GX_VA_NRM) {
            data.mNrmNum = num;
        } else if (attr == GX_VA_CLR0) {
@@ -120,11 +120,19 @@ void JAISeqMgr::mixOut() {
 }

 JAISeq* JAISeqMgr::beginStartSeq_() {
-    JAISeq* seq = JKR_NEW JAISeq(this, field_0x10);
+#ifdef TARGET_PC
+    if (JAISeq::getFreeMemCount() == 0) {
+        JUT_WARN(273, "%s", "JASPoolAllocObject::<JAISeq>::operator new failed .\n");
+        return NULL;
+    }
+    return JKR_NEW JAISeq(this, field_0x10);
+#else
+    JAISeq* seq = new JAISeq(this, field_0x10);
    if (seq == NULL) {
        JUT_WARN(273, "%s", "JASPoolAllocObject::<JAISeq>::operator new failed .\n");
    }
    return seq;
+#endif
 }

 bool JAISeqMgr::endStartSeq_(JAISeq* seq, JAISoundHandle* handle) {
@@ -1,6 +1,9 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep

 #include "JSystem/JAudio2/JASChannel.h"
+#if TARGET_PC
+#include "dusk/audio/DuskDsp.hpp"
+#endif
 #include "JSystem/JAudio2/JASAiCtrl.h"
 #include "JSystem/JAudio2/JASCalc.h"
 #include "JSystem/JAudio2/JASDriverIF.h"
@@ -170,7 +173,12 @@ void JASChannel::updateEffectorParam(JASDsp::TChannel* i_channel, u16* i_mixerVo

    f32 pan = 0.5f;
    f32 dolby = 0.0f;
-    switch (JASDriver::getOutputMode()) {
+#if TARGET_PC
+    u32 effectiveOutputMode = dusk::audio::EnableHrtf ? JAS_OUTPUT_SURROUND : JASDriver::getOutputMode();
+#else
+    u32 effectiveOutputMode = JASDriver::getOutputMode();
+#endif
+    switch (effectiveOutputMode) {
    case JAS_OUTPUT_MONO:
        break;
    case JAS_OUTPUT_STEREO:
@@ -302,7 +302,6 @@ void JASKernel::setupRootHeap(JKRSolidHeap* heap, u32 size) {
    JKRHEAP_NAME(sSystemHeap, "JASKernel::sSystemHeap");
    JUT_ASSERT(787, sSystemHeap);
    sCommandHeap = JKR_NEW_ARGS (heap, 0) JASMemChunkPool<1024, JASThreadingModel::ObjectLevelLockable>;
-    JKRHEAP_NAME(sSystemHeap, "JASKernel::sCommandHeap");
    JUT_ASSERT(790, sCommandHeap);
    JASDram = heap;
 }
@@ -442,6 +442,7 @@ static JAUSectionHeap* JAUNewSectionHeap(JKRSolidHeap* heap, bool param_1) {
 JAUSectionHeap* JAUNewSectionHeap(bool param_0) {
    s32 freeSize = JASDram->getFreeSize();
    JKRSolidHeap* sectionHeap = JKRCreateSolidHeap(freeSize, JASDram, true);
+    JKRHEAP_NAME(sectionHeap, "sectionHeap");
    JUT_ASSERT(821, sectionHeap);
    return JAUNewSectionHeap(sectionHeap, param_0);
 }
@@ -18,6 +18,7 @@
 #include "dusk/logging.h"
 #include "dusk/settings.h"
 #include "dusk/time.h"
+#include "f_op/f_op_overlap_mng.h"

 #include "SDL3/SDL_timer.h"
 #include "tracy/Tracy.hpp"
@@ -219,7 +220,7 @@ void JFWDisplay::endGX() {
        if (dusk::frame_interp::get_ui_tick_pending()) {
            mFader->advance();
        }
-        if (mFader->getStatus() != 1) {
+        if (mFader->getStatus() != JUTFader::Wait) {
            mFader->draw();
        }
 #else
@@ -368,22 +369,30 @@ constexpr auto FRAME_PERIOD = std::chrono::duration_cast<std::chrono::nanosecond
    std::chrono::duration<double>(1001.0 / 30000.0));
 constexpr auto RETRACE_PERIOD = FRAME_PERIOD / 2;

-static void waitPrecise(Limiter& limiter, Uint64 targetNs) {
-    const auto sleepTime = limiter.SleepTime(std::chrono::nanoseconds(targetNs));
+static void waitPrecise(Limiter& limiter, Limiter::duration_t targetNs) {
+    const auto sleepTime = limiter.SleepTime(targetNs);
    dusk::frameUsagePct =
-        100.0f * (1.0f - static_cast<float>(sleepTime.count()) / static_cast<float>(targetNs));
-    limiter.Sleep(std::chrono::nanoseconds(targetNs));
+        100.0f * (1.0f - static_cast<float>(sleepTime) / static_cast<float>(targetNs));
+    limiter.Sleep(targetNs);
 }
 #endif

 static void waitForTick(u32 p1, u16 p2) {
 #if TARGET_PC
    if (dusk::getSettings().game.enableFrameInterpolation && !dusk::getTransientSettings().skipFrameRateLimit) {
+        dusk::frameUsagePct = 0.f;
        return;
    }
    if (dusk::getTransientSettings().skipFrameRateLimit) {
        p1 = OS_TIMER_CLOCK / 120;
    }
+    
+    #if TARGET_PC
+    if (fopOvlpM_IsPeek() && dusk::getTransientSettings().stateShareLoadActive) {
+        return;
+    }
+    #endif
+
    ZoneScopedC(tracy::Color::DimGray);
 #endif

@@ -222,16 +222,11 @@ void* JKRExpHeap::do_alloc(u32 size, int alignment) {
        OSReport_Error("Free block list as follows:\n");
        OSReport_Error("Start    | End      | Size    \n");

-        int i = 0;
        for (const CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
            if (block->mMagic) {
                // Allocated, ignore.
                continue;
            }
-            if (i++ > 10) {
-                OSReport_Error("<more>\n");
-                break;
-            }

            auto blockStart = (uintptr_t)block - (uintptr_t)mStart;
            auto blockEnd = (uintptr_t)block + block->size - (uintptr_t)mStart;
@@ -239,6 +234,14 @@ void* JKRExpHeap::do_alloc(u32 size, int alignment) {
            OSReport_Error("%08X | %08X | %08X\n", (u32) blockStart, (u32) blockEnd, (u32) blockSize);
        }

+        OSReport_Error("Child heaps as follows:\n");
+        OSReport_Error("Start    | End      | Name    \n");
+
+        const JSUTree<JKRHeap>& tree = getHeapTree();
+        for (JSUTreeIterator iter(tree.getFirstChild()); iter != tree.getEndChild(); ++iter) {
+            OSReport_Error("%08X | %08X | %s\n", iter->getStartAddr(), iter->getEndAddr(), iter->getName());
+        }
+
        CRASH("Aborting due to allocation failure!");
    }
 #else
@@ -9,6 +9,9 @@
 #include <mtx.h>
 #include <gx.h>

+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
 #include "tracy/Tracy.hpp"

 void JPASetPointSize(JPAEmitterWorkData* work) {
@@ -418,50 +421,95 @@ static projectionFunc p_prj[3] = {
    loadPrjAnm,
 };

-void JPADrawBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) {
-    if (param_1->checkStatus(JPAPtclStts_Invisible)) {
+#if TARGET_PC
+void JPAInterpBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    Mtx ptclPosMtx;
+    MTXTrans(ptclPosMtx, ptcl->mPosition.x, ptcl->mPosition.y, ptcl->mPosition.z);
+    dusk::frame_interp::record_final_mtx(ptclPosMtx, ptcl);
+}
+
+void JPAInterpRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    Mtx ptclPosMtx;
+    f32 sinRot = JMASSin(ptcl->mRotateAngle);
+    f32 cosRot = JMASCos(ptcl->mRotateAngle);
+    MTXTrans(ptclPosMtx, ptcl->mPosition.x, ptcl->mPosition.y, ptcl->mPosition.z);
+    ptclPosMtx[0][0] = cosRot;
+    ptclPosMtx[0][1] = -sinRot;
+    ptclPosMtx[1][0] = sinRot;
+    ptclPosMtx[1][1] = cosRot;
+    dusk::frame_interp::record_final_mtx(ptclPosMtx, ptcl);
+}
+#endif
+
+void JPADrawBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    if (ptcl->checkStatus(JPAPtclStts_Invisible)) {
        return;
    }

-    JGeometry::TVec3<f32> local_48;
-    MTXMultVec(work->mPosCamMtx, &param_1->mPosition, &local_48);
-    Mtx local_38;
-    local_38[0][0] = work->mGlobalPtclScl.x * param_1->mParticleScaleX;
-    local_38[0][3] = local_48.x;
-    local_38[1][1] = work->mGlobalPtclScl.y * param_1->mParticleScaleY;
-    local_38[1][3] = local_48.y;
-    local_38[2][2] = 1.0f;
-    local_38[2][3] = local_48.z;
-    local_38[0][1] = local_38[0][2] = local_38[1][0] = local_38[1][2] = local_38[2][0] = local_38[2][1] = 0.0f;
-    GXLoadPosMtxImm(local_38, 0);
-    p_prj[work->mPrjType](work, local_38);
+    JGeometry::TVec3<f32> pos;
+#if TARGET_PC
+    Mtx ptclPosMtx;
+    if (dusk::frame_interp::lookup_replacement(ptcl, ptclPosMtx)) {
+        pos.set(ptclPosMtx[0][3], ptclPosMtx[1][3], ptclPosMtx[2][3]);
+        MTXMultVec(work->mPosCamMtx, &pos, &pos);
+    } else
+#endif
+    {
+        MTXMultVec(work->mPosCamMtx, &ptcl->mPosition, &pos);
+    }
+    Mtx posMtx;
+    posMtx[0][0] = work->mGlobalPtclScl.x * ptcl->mParticleScaleX;
+    posMtx[0][3] = pos.x;
+    posMtx[1][1] = work->mGlobalPtclScl.y * ptcl->mParticleScaleY;
+    posMtx[1][3] = pos.y;
+    posMtx[2][2] = 1.0f;
+    posMtx[2][3] = pos.z;
+    posMtx[0][1] = posMtx[0][2] = posMtx[1][0] = posMtx[1][2] = posMtx[2][0] = posMtx[2][1] = 0.0f;
+    GXLoadPosMtxImm(posMtx, GX_PNMTX0);
+    p_prj[work->mPrjType](work, posMtx);
    GXCallDisplayList(jpa_dl, sizeof(jpa_dl));
 }

-void JPADrawRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) {
-    if (param_1->checkStatus(JPAPtclStts_Invisible)) {
+void JPADrawRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    if (ptcl->checkStatus(JPAPtclStts_Invisible)) {
        return;
    }

-    JGeometry::TVec3<f32> local_48;
-    MTXMultVec(work->mPosCamMtx, &param_1->mPosition, &local_48);
-    f32 sinRot = JMASSin(param_1->mRotateAngle);
-    f32 cosRot = JMASCos(param_1->mRotateAngle);
-    f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX;
-    f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY;
+    if (work->mpRes->getUsrIdx() == 0x89d7) {
+        int a = 0;
+    }

-    Mtx local_38;
-    local_38[0][0] = cosRot * particleX;
-    local_38[0][1] = -sinRot * particleY;
-    local_38[0][3] = local_48.x;
-    local_38[1][0] = sinRot * particleX;
-    local_38[1][1] = cosRot * particleY;
-    local_38[1][3] = local_48.y;
-    local_38[2][2] = 1.0f;
-    local_38[2][3] = local_48.z;
-    local_38[0][2] = local_38[1][2] = local_38[2][0] = local_38[2][1] = 0.0f;
-    GXLoadPosMtxImm(local_38, 0);
-    p_prj[work->mPrjType](work, local_38);
+    JGeometry::TVec3<f32> pos;
+    f32 sinRot, cosRot;
+#if TARGET_PC
+    Mtx ptclPosMtx;
+    MTXTrans(ptclPosMtx, ptcl->mPosition.x, ptcl->mPosition.y, ptcl->mPosition.z);
+    if (dusk::frame_interp::lookup_replacement(ptcl, ptclPosMtx)) {
+        pos.set(ptclPosMtx[0][3], ptclPosMtx[1][3], ptclPosMtx[2][3]);
+        sinRot = ptclPosMtx[1][0];
+        cosRot = ptclPosMtx[0][0];
+        MTXMultVec(work->mPosCamMtx, &pos, &pos);
+    } else
+#endif
+    {
+        MTXMultVec(work->mPosCamMtx, &ptcl->mPosition, &pos);
+        sinRot = JMASSin(ptcl->mRotateAngle);
+        cosRot = JMASCos(ptcl->mRotateAngle);
+    }
+    f32 particleX = work->mGlobalPtclScl.x * ptcl->mParticleScaleX;
+    f32 particleY = work->mGlobalPtclScl.y * ptcl->mParticleScaleY;
+    Mtx posMtx;
+    posMtx[0][0] = cosRot * particleX;
+    posMtx[0][1] = -sinRot * particleY;
+    posMtx[0][3] = pos.x;
+    posMtx[1][0] = sinRot * particleX;
+    posMtx[1][1] = cosRot * particleY;
+    posMtx[1][3] = pos.y;
+    posMtx[2][2] = 1.0f;
+    posMtx[2][3] = pos.z;
+    posMtx[0][2] = posMtx[1][2] = posMtx[2][0] = posMtx[2][1] = 0.0f;
+    GXLoadPosMtxImm(posMtx, GX_PNMTX0);
+    p_prj[work->mPrjType](work, posMtx);
    GXCallDisplayList(jpa_dl, sizeof(jpa_dl));
 }

@@ -484,7 +532,7 @@ void JPADrawYBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) {
    local_38[2][2] = work->mYBBCamMtx[2][2];
    local_38[2][3] = local_48.z;
    local_38[0][1] = local_38[0][2] = local_38[1][0] = local_38[2][0] = 0.0f;
-    GXLoadPosMtxImm(local_38, 0);
+    GXLoadPosMtxImm(local_38, GX_PNMTX0);
    p_prj[work->mPrjType](work, local_38);
    GXCallDisplayList(jpa_dl, sizeof(jpa_dl));
 }
@@ -517,7 +565,7 @@ void JPADrawRotYBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) {
    local_38[2][1] = local_94 * fVar1;
    local_38[2][2] = local_90;
    local_38[2][3] = local_48.z;
-    GXLoadPosMtxImm(local_38, 0);
+    GXLoadPosMtxImm(local_38, GX_PNMTX0);
    p_prj[work->mPrjType](work, local_38);
    GXCallDisplayList(jpa_dl, sizeof(jpa_dl));
 }
@@ -681,103 +729,197 @@ static u8* p_dl[2] = {
    jpa_dl_x,
 };

-void JPADrawDirection(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) {
-    if (param_1->checkStatus(JPAPtclStts_Invisible)) {
+#if TARGET_PC
+void JPAInterpDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    JGeometry::TVec3<f32> axisY;
+    JGeometry::TVec3<f32> axisZ;
+    p_direction[work->mDirType](work, ptcl, &axisY);
+
+    if (axisY.isZero()) {
        return;
    }

-    ZoneScoped;
+    axisY.normalize();
+    axisZ.cross(ptcl->mBaseAxis, axisY);

-    JGeometry::TVec3<f32> local_6c;
-    JGeometry::TVec3<f32> local_78;
-    p_direction[param_0->mDirType](param_0, param_1, &local_6c);
-
-    if (local_6c.isZero()) {
+    if (axisZ.isZero()) {
        return;
    }

-    local_6c.normalize();
-    local_78.cross(param_1->mBaseAxis, local_6c);
-
-    if (local_78.isZero()) {
-        return;
-    }
-
-    local_78.normalize();
-    param_1->mBaseAxis.cross(local_6c, local_78);
-    param_1->mBaseAxis.normalize();
-    Mtx local_60;
-    f32 fVar1 = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX;
-    f32 fVar2 = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY;
-    local_60[0][0] = param_1->mBaseAxis.x;
-    local_60[0][1] = local_6c.x;
-    local_60[0][2] = local_78.x;
-    local_60[0][3] = param_1->mPosition.x;
-    local_60[1][0] = param_1->mBaseAxis.y;
-    local_60[1][1] = local_6c.y;
-    local_60[1][2] = local_78.y;
-    local_60[1][3] = param_1->mPosition.y;
-    local_60[2][0] = param_1->mBaseAxis.z;
-    local_60[2][1] = local_6c.z;
-    local_60[2][2] = local_78.z;
-    local_60[2][3] = param_1->mPosition.z;
-    p_plane[param_0->mPlaneType](local_60, fVar1, fVar2);
-    MTXConcat(param_0->mPosCamMtx, local_60, local_60);
-    GXLoadPosMtxImm(local_60, 0);
-    p_prj[param_0->mPrjType](param_0, local_60);
-    GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl));
+    axisZ.normalize();
+    ptcl->mBaseAxis.cross(axisY, axisZ);
+    ptcl->mBaseAxis.normalize();
+    Mtx posMtx;
+    f32 scaleX = work->mGlobalPtclScl.x * ptcl->mParticleScaleX;
+    f32 scaleY = work->mGlobalPtclScl.y * ptcl->mParticleScaleY;
+    posMtx[0][0] = ptcl->mBaseAxis.x;
+    posMtx[0][1] = axisY.x;
+    posMtx[0][2] = axisZ.x;
+    posMtx[0][3] = ptcl->mPosition.x;
+    posMtx[1][0] = ptcl->mBaseAxis.y;
+    posMtx[1][1] = axisY.y;
+    posMtx[1][2] = axisZ.y;
+    posMtx[1][3] = ptcl->mPosition.y;
+    posMtx[2][0] = ptcl->mBaseAxis.z;
+    posMtx[2][1] = axisY.z;
+    posMtx[2][2] = axisZ.z;
+    posMtx[2][3] = ptcl->mPosition.z;
+    p_plane[work->mPlaneType](posMtx, scaleX, scaleY);
+    dusk::frame_interp::record_final_mtx(posMtx, ptcl);
 }

-void JPADrawRotDirection(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) {
-    if (param_1->checkStatus(JPAPtclStts_Invisible)) {
+void JPAInterpRotDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    f32 sinRot = JMASSin(ptcl->mRotateAngle);
+    f32 cosRot = JMASCos(ptcl->mRotateAngle);
+    JGeometry::TVec3<f32> axisY;
+    JGeometry::TVec3<f32> axisZ;
+    p_direction[work->mDirType](work, ptcl, &axisY);
+
+    if (axisY.isZero()) {
+        return;
+    }
+
+    axisY.normalize();
+    axisZ.cross(ptcl->mBaseAxis, axisY);
+
+    if (axisZ.isZero()) {
+        return;
+    }
+
+    axisZ.normalize();
+    ptcl->mBaseAxis.cross(axisY, axisZ);
+    ptcl->mBaseAxis.normalize();
+    f32 scaleX = work->mGlobalPtclScl.x * ptcl->mParticleScaleX;
+    f32 scaleY = work->mGlobalPtclScl.y * ptcl->mParticleScaleY;
+    Mtx mtx1;
+    Mtx mtx2;
+    p_rot[work->mRotType](sinRot, cosRot, mtx1);
+    p_plane[work->mPlaneType](mtx1, scaleX, scaleY);
+    mtx2[0][0] = ptcl->mBaseAxis.x;
+    mtx2[0][1] = axisY.x;
+    mtx2[0][2] = axisZ.x;
+    mtx2[0][3] = ptcl->mPosition.x;
+    mtx2[1][0] = ptcl->mBaseAxis.y;
+    mtx2[1][1] = axisY.y;
+    mtx2[1][2] = axisZ.y;
+    mtx2[1][3] = ptcl->mPosition.y;
+    mtx2[2][0] = ptcl->mBaseAxis.z;
+    mtx2[2][1] = axisY.z;
+    mtx2[2][2] = axisZ.z;
+    mtx2[2][3] = ptcl->mPosition.z;
+    MTXConcat(mtx2, mtx1, mtx1);
+    dusk::frame_interp::record_final_mtx(mtx1, ptcl);
+}
+#endif
+
+void JPADrawDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    if (ptcl->checkStatus(JPAPtclStts_Invisible)) {
        return;
    }

    ZoneScoped;

-    f32 sinRot = JMASSin(param_1->mRotateAngle);
-    f32 cosRot = JMASCos(param_1->mRotateAngle);
-    JGeometry::TVec3<f32> local_6c;
-    JGeometry::TVec3<f32> local_78;
-    p_direction[param_0->mDirType](param_0, param_1, &local_6c);
+    Mtx posMtx;
+#if TARGET_PC
+    if (!dusk::frame_interp::lookup_replacement(ptcl, posMtx))
+#endif
+    {
+        JGeometry::TVec3<f32> axisY;
+        JGeometry::TVec3<f32> axisZ;
+        p_direction[work->mDirType](work, ptcl, &axisY);

-    if (local_6c.isZero()) {
+        if (axisY.isZero()) {
+            return;
+        }
+
+        axisY.normalize();
+        axisZ.cross(ptcl->mBaseAxis, axisY);
+
+        if (axisZ.isZero()) {
+            return;
+        }
+
+        axisZ.normalize();
+        ptcl->mBaseAxis.cross(axisY, axisZ);
+        ptcl->mBaseAxis.normalize();
+        f32 scaleX = work->mGlobalPtclScl.x * ptcl->mParticleScaleX;
+        f32 scaleY = work->mGlobalPtclScl.y * ptcl->mParticleScaleY;
+        posMtx[0][0] = ptcl->mBaseAxis.x;
+        posMtx[0][1] = axisY.x;
+        posMtx[0][2] = axisZ.x;
+        posMtx[0][3] = ptcl->mPosition.x;
+        posMtx[1][0] = ptcl->mBaseAxis.y;
+        posMtx[1][1] = axisY.y;
+        posMtx[1][2] = axisZ.y;
+        posMtx[1][3] = ptcl->mPosition.y;
+        posMtx[2][0] = ptcl->mBaseAxis.z;
+        posMtx[2][1] = axisY.z;
+        posMtx[2][2] = axisZ.z;
+        posMtx[2][3] = ptcl->mPosition.z;
+        p_plane[work->mPlaneType](posMtx, scaleX, scaleY);
+    }
+
+    MTXConcat(work->mPosCamMtx, posMtx, posMtx);
+    GXLoadPosMtxImm(posMtx, GX_PNMTX0);
+    p_prj[work->mPrjType](work, posMtx);
+    GXCallDisplayList(p_dl[work->mDLType], sizeof(jpa_dl));
+}
+
+void JPADrawRotDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
+    if (ptcl->checkStatus(JPAPtclStts_Invisible)) {
        return;
    }

-    local_6c.normalize();
-    local_78.cross(param_1->mBaseAxis, local_6c);
+    ZoneScoped;

-    if (local_78.isZero()) {
-        return;
+    Mtx mtx1;
+    Mtx mtx2;
+#if TARGET_PC
+    if (!dusk::frame_interp::lookup_replacement(ptcl, mtx1))
+#endif
+    {
+        f32 sinRot = JMASSin(ptcl->mRotateAngle);
+        f32 cosRot = JMASCos(ptcl->mRotateAngle);
+        JGeometry::TVec3<f32> axisY;
+        JGeometry::TVec3<f32> axisZ;
+        p_direction[work->mDirType](work, ptcl, &axisY);
+
+        if (axisY.isZero()) {
+            return;
+        }
+
+        axisY.normalize();
+        axisZ.cross(ptcl->mBaseAxis, axisY);
+
+        if (axisZ.isZero()) {
+            return;
+        }
+
+        axisZ.normalize();
+        ptcl->mBaseAxis.cross(axisY, axisZ);
+        ptcl->mBaseAxis.normalize();
+        f32 scaleX = work->mGlobalPtclScl.x * ptcl->mParticleScaleX;
+        f32 scaleY = work->mGlobalPtclScl.y * ptcl->mParticleScaleY;
+        p_rot[work->mRotType](sinRot, cosRot, mtx1);
+        p_plane[work->mPlaneType](mtx1, scaleX, scaleY);
+        mtx2[0][0] = ptcl->mBaseAxis.x;
+        mtx2[0][1] = axisY.x;
+        mtx2[0][2] = axisZ.x;
+        mtx2[0][3] = ptcl->mPosition.x;
+        mtx2[1][0] = ptcl->mBaseAxis.y;
+        mtx2[1][1] = axisY.y;
+        mtx2[1][2] = axisZ.y;
+        mtx2[1][3] = ptcl->mPosition.y;
+        mtx2[2][0] = ptcl->mBaseAxis.z;
+        mtx2[2][1] = axisY.z;
+        mtx2[2][2] = axisZ.z;
+        mtx2[2][3] = ptcl->mPosition.z;
+        MTXConcat(mtx2, mtx1, mtx1);
    }
-
-    local_78.normalize();
-    param_1->mBaseAxis.cross(local_6c, local_78);
-    param_1->mBaseAxis.normalize();
-    f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX;
-    f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY;
-    Mtx auStack_80;
-    Mtx local_60;
-    p_rot[param_0->mRotType](sinRot, cosRot, auStack_80);
-    p_plane[param_0->mPlaneType](auStack_80, particleX, particleY);
-    local_60[0][0] = param_1->mBaseAxis.x;
-    local_60[0][1] = local_6c.x;
-    local_60[0][2] = local_78.x;
-    local_60[0][3] = param_1->mPosition.x;
-    local_60[1][0] = param_1->mBaseAxis.y;
-    local_60[1][1] = local_6c.y;
-    local_60[1][2] = local_78.y;
-    local_60[1][3] = param_1->mPosition.y;
-    local_60[2][0] = param_1->mBaseAxis.z;
-    local_60[2][1] = local_6c.z;
-    local_60[2][2] = local_78.z;
-    local_60[2][3] = param_1->mPosition.z;
-    MTXConcat(local_60, auStack_80, auStack_80);
-    MTXConcat(param_0->mPosCamMtx, auStack_80, local_60);
-    GXLoadPosMtxImm(local_60, 0);
-    p_prj[param_0->mPrjType](param_0, local_60);
-    GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl));
+    MTXConcat(work->mPosCamMtx, mtx1, mtx2);
+    GXLoadPosMtxImm(mtx2, GX_PNMTX0);
+    p_prj[work->mPrjType](work, mtx2);
+    GXCallDisplayList(p_dl[work->mDLType], sizeof(jpa_dl));
 }

 void JPADrawDBillboard(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) {
@@ -204,6 +204,28 @@ void JPABaseParticle::init_c(JPAEmitterWorkData* work, JPABaseParticle* parent)
    mTexAnmIdx = 0;
 }

+#if TARGET_PC
+void JPABaseParticle::interp(JPAEmitterWorkData* work, void const* drawFunc) {
+    static bool enable = false;
+    if (!enable)
+        return;
+
+    // don't interpolate the first frame
+    if (mAge == 0)
+        return;
+
+    if (drawFunc == JPADrawBillboard) {
+        JPAInterpBillboard(work, this);
+    } else if (drawFunc == JPADrawRotBillboard) {
+        JPAInterpRotBillboard(work, this);
+    } else if (drawFunc == JPADrawDirection) {
+        JPAInterpDirection(work, this);
+    } else if (drawFunc == JPADrawRotDirection) {
+        JPAInterpRotDirection(work, this);
+    }
+}
+#endif
+
 bool JPABaseParticle::calc_p(JPAEmitterWorkData* work) {
    if (++mAge >= mLifeTime) {
        return true;
@@ -247,6 +269,17 @@ bool JPABaseParticle::calc_p(JPAEmitterWorkData* work) {
                  mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y,
                  mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z);

+#if TARGET_PC
+    JPABaseShape* pBsp = work->mpRes->getBsp();
+    work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pBsp->getBaseSizeX();
+    work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pBsp->getBaseSizeY();
+    work->mDirType = pBsp->getDirType();
+    work->mRotType = pBsp->getRotType();
+    work->mDLType = pBsp->getType() == 4 || pBsp->getType() == 8;
+    work->mPlaneType = work->mDLType ? 2 : pBsp->getBasePlaneType();
+    interp(work, (void const*)work->mpRes->mpDrawParticleFuncList[0]);
+#endif
+
    return false;
 }

@@ -289,6 +322,23 @@ bool JPABaseParticle::calc_c(JPAEmitterWorkData* work) {
                  mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y,
                  mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z);

+#if TARGET_PC
+    JPABaseShape* pBsp = work->mpRes->getBsp();
+    JPAChildShape* pCsp = work->mpRes->getCsp();
+    if (pCsp->isScaleInherited()) {
+        work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pBsp->getBaseSizeX();
+        work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pBsp->getBaseSizeY();
+    } else {
+        work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pCsp->getScaleX();
+        work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pCsp->getScaleY();
+    }
+    work->mDirType = pCsp->getDirType();
+    work->mRotType = pCsp->getRotType();
+    work->mDLType = pCsp->getType() == 4 || pCsp->getType() == 8;
+    work->mPlaneType = work->mDLType ? 2 : pCsp->getBasePlaneType();
+    interp(work, (void const*)work->mpRes->mpDrawParticleChildFuncList[0]);
+#endif
+
    return false;
 }

@@ -8,53 +8,57 @@
 #include "JSystem/JUtility/JUTFader.h"
 #include "JSystem/J2DGraph/J2DOrthoGraph.h"

+#ifdef TARGET_PC
+#include <algorithm>
+#endif
+
 JUTFader::JUTFader(int x, int y, int width, int height, JUtility::TColor pColor)
    : mColor(pColor), mBox(x, y, x + width, y + height) {
-    mStatus = 0;
-    field_0x8 = 0;
-    field_0xa = 0;
-    field_0x24 = 0;
-    mEStatus = UNKSTATUS_M1;
+    mStatus = None;
+    mDuration = 0;
+    mTimer = 0;
+    mNextStatus = 0;
+    mStatusTimer = -1;
 }

 void JUTFader::advance() {
-    if (0 <= mEStatus && mEStatus-- == 0) {
-        mStatus = field_0x24;
+    if (0 <= mStatusTimer && mStatusTimer-- == 0) {
+        mStatus = mNextStatus;
    }

-    if (mStatus == 1) {
+    if (mStatus == Wait) {
        return;
    }

    switch (mStatus) {
-    case 0:
+    case None:
        mColor.a = 0xFF;
        break;
-    case 2:
+    case FadeIn:
 #if AVOID_UB
-        if (field_0x8 == 0) {
-            mStatus = 1;
+        if (mDuration == 0) {
+            mStatus = Wait;
            break;
        }
 #endif
-        mColor.a = 0xFF - ((++field_0xa * 0xFF) / field_0x8);
+        mColor.a = 0xFF - ((++mTimer * 0xFF) / mDuration);

-        if (field_0xa >= field_0x8) {
-            mStatus = 1;
+        if (mTimer >= mDuration) {
+            mStatus = Wait;
        }

        break;
-    case 3:
+    case FadeOut:
 #if AVOID_UB
-        if (field_0x8 == 0) {
-            mStatus = 0;
+        if (mDuration == 0) {
+            mStatus = None;
            break;
        }
 #endif
-        mColor.a = ((++field_0xa * 0xFF) / field_0x8);
+        mColor.a = ((++mTimer * 0xFF) / mDuration);

-        if (field_0xa >= field_0x8) {
-            mStatus = 0;
+        if (mTimer >= mDuration) {
+            mStatus = None;
        }

        break;
@@ -63,67 +67,77 @@ void JUTFader::advance() {

 void JUTFader::control() {
    advance();
-#ifndef TARGET_PC
-    // FRAME INTERP NOTE: Draw is called by JFWDisplay when interpolation is active
    draw();
-#endif
 }

 void JUTFader::draw() {
    if (mColor.a != 0) {
+#ifdef TARGET_PC
+        if (dusk::frame_interp::is_enabled() && mDuration != 0) {
+            const auto step = dusk::frame_interp::get_interpolation_step();
+            const auto progress = static_cast<f32>(mTimer) / static_cast<f32>(mDuration);
+            const auto timer = mTimer - 1 + step + progress;
+            auto alpha = timer / mDuration;
+            if (mStatus == FadeIn) {
+                alpha = 1.0f - alpha;
+            }
+            alpha = std::clamp(alpha, 0.0f, 1.0f);
+            mColor.a = static_cast<u8>(alpha * 255.0f);
+        }
+#endif
        J2DOrthoGraph orthograph;
        orthograph.setColor(mColor);
        orthograph.fillBox(mBox);
    }
 }

-bool JUTFader::startFadeIn(int param_0) {
+bool JUTFader::startFadeIn(int duration) {
    bool statusCheck = mStatus == 0;

    if (statusCheck) {
-        mStatus = 2;
-        field_0xa = 0;
-        field_0x8 = param_0;
+        mStatus = FadeIn;
+        mTimer = 0;
+        mDuration = duration;
    }

    return statusCheck;
 }

-bool JUTFader::startFadeOut(int param_0) {
+bool JUTFader::startFadeOut(int duration) {
    bool statusCheck = mStatus == 1;

    if (statusCheck) {
-        mStatus = 3;
-        field_0xa = 0;
-        field_0x8 = param_0;
+        mStatus = FadeOut;
+        mTimer = 0;
+        mDuration = duration;
    }

    return statusCheck;
 }

-void JUTFader::setStatus(JUTFader::EStatus i_status, int param_1) {
+void JUTFader::setStatus(JUTFader::EStatus i_status, int timer) {
    switch (i_status) {
-    case 0: 
-        if (param_1 != 0) {
-            field_0x24 = 0;
-            mEStatus = param_1;
+    case None: 
+        if (timer != 0) {
+            mNextStatus = None;
+            mStatusTimer = timer;
            break;
        }

-        mStatus = 0;
-        field_0x24 = 0;
-        mEStatus = 0;
+        mStatus = None;
+        mNextStatus = None;
+        mStatusTimer = 0;
        break;
-    case 1: 
-        if (param_1 != 0) {
-            field_0x24 = 1;
-            mEStatus = param_1;
+    case Wait:
+        if (timer != 0) {
+            mNextStatus = Wait;
+            mStatusTimer = timer;
            break;
        }

-        mStatus = 1;
-        field_0x24 = 1;
-        mEStatus = 0;
+        mStatus = Wait;
+        mNextStatus = Wait;
+        mStatusTimer = 0;
        break;
    }
 }
@@ -64,6 +64,9 @@ BOOL JUTGamePad::init() {
 void JUTGamePad::clear() {
    mButtonReset.mReset = false;
    field_0xa8 = 1;
+#if TARGET_PC
+    mResetHoldFrameCount = 0;
+#endif
 }

 PADStatus JUTGamePad::mPadStatus[4];
@@ -219,11 +222,19 @@ void JUTGamePad::update() {
            mButtonReset.mReset = false;
        } else if (!JUTGamePad::C3ButtonReset::sResetOccurred) {
            if (mButtonReset.mReset == true) {
+#if TARGET_PC
+                checkResetCallback(++mResetHoldFrameCount * (OS_TIMER_CLOCK / 30));
+#else
                OSTime hold_time = OSGetTime() - mResetHoldStartTime;
                checkResetCallback(hold_time);
+#endif
            } else {
                mButtonReset.mReset = true;
+#if TARGET_PC
+                mResetHoldFrameCount = 0;
+#else
                mResetHoldStartTime = OSGetTime();
+#endif
            }
        }

@@ -38,3 +38,9 @@ bool JUTPalette::load() {

    return check;
 }
+
+#if TARGET_PC
+void JUTPalette::dataUploaded() {
+    GXInitTlutObjData(&mTlutObj, (void*)mColorTable);
+}
+#endif
@@ -27,7 +27,7 @@ void JUTTexture::storeTIMG(ResTIMG const* param_0, u8 param_1) {
            mTexData = (void*)((intptr_t)mTexInfo + 0x20);
        }

-        field_0x2c = NULL;
+        mPalette = NULL;
        mTlutName = 0;
        mWrapS = mTexInfo->wrapS;
        mWrapT = mTexInfo->wrapT;
@@ -95,7 +95,7 @@ void JUTTexture::storeTIMG(ResTIMG const* param_0, JUTPalette* param_1, GXTlut p
    }
    mEmbPalette = param_1;
    setEmbPaletteDelFlag(false);
-    field_0x2c = NULL;
+    mPalette = NULL;
    if (param_1 != NULL) {
        mTlutName = param_2;
        if (param_2 != param_1->getTlutName()) {
@@ -120,11 +120,11 @@ void JUTTexture::storeTIMG(ResTIMG const* param_0, JUTPalette* param_1, GXTlut p
 void JUTTexture::attachPalette(JUTPalette* param_0) {
    if (mTexInfo->indexTexture) {
        if (param_0 == NULL && mEmbPalette != NULL) {
-            field_0x2c = mEmbPalette;
+            mPalette = mEmbPalette;
        } else {
-            field_0x2c = param_0;
+            mPalette = param_0;
        }
-        initTexObj(field_0x2c->getTlutName());
+        initTexObj(mPalette->getTlutName());
    }
 }

@@ -133,9 +133,9 @@ void JUTTexture::init() {
        initTexObj();
    } else {
        if (mEmbPalette != NULL) {
-            field_0x2c = mEmbPalette;
+            mPalette = mEmbPalette;

-            initTexObj(field_0x2c->getTlutName());
+            initTexObj(mPalette->getTlutName());
        } else {
            OS_REPORT("This texture is CI-Format, but EmbPalette is NULL.\n");
        }
@@ -179,8 +179,8 @@ void JUTTexture::initTexObj(GXTlut param_0) {
 }

 void JUTTexture::load(GXTexMapID param_0) {
-    if (field_0x2c) {
-        field_0x2c->load();
+    if (mPalette) {
+        mPalette->load();
    }
    GXLoadTexObj(&mTexObj, param_0);
 }
--- a/Show More
+++ b/Show More