Fix OSReport crash on linux, harden FormatToString against malformed strings (#640)

* Fix OSReport crash on linux, harden FormatToString against malformed strings

* Move size increment to after error check

* Update aurora and impl OSPanic

---------

Co-authored-by: Luke Street <luke@street.dev>

.clang-format

@@ -2,7 +2,7 @@
 Language: Cpp
 Standard: C++03
 AccessModifierOffset: -4
-AlignAfterOpenBracket: Align
+AlignAfterOpenBracket: DontAlign
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 AlignOperands:   true

CMakeLists.txt

@@ -100,6 +100,7 @@ if (CMAKE_SYSTEM_NAME STREQUAL Linux)
 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)
 
 add_subdirectory(libs/freeverb)
@@ -280,22 +281,16 @@ 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})
 
-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)
 
 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
@@ -312,6 +307,10 @@ 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 ()
+
 if (DUSK_MOVIE_SUPPORT)
     if (TARGET libjpeg-turbo::turbojpeg-static)
         list(APPEND GAME_LIBS libjpeg-turbo::turbojpeg-static)

README.md

@@ -1,10 +1,14 @@
-![DuskLogo](res/logo-mascot.webp)
+![DuskLogo](res/logo-mascot.png)
 
 - ### **[Official Website](https://twilitrealm.dev)**
 - ### **[Discord](https://discord.gg/QACynxeyna)**
 
+# 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.**
+**⚠️ 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.
@@ -22,29 +26,12 @@ First make sure your dump of the game is clean and supported by Dusk. You can do
 - Select Options, then set the ISO Path to your supported game dump
 - Press Start Game to play!
 
-![DuskOptions](assets/dusk_options.png)
+![Dusk options](assets/dusk_options.png)
 
 # 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.
 
-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).

cmake-variants.yaml

@@ -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

files.cmake

@@ -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
@@ -1429,6 +1429,7 @@ set(DUSK_FILES
         src/dusk/globals.cpp
         src/dusk/gyro.cpp
 		src/dusk/gamepad_color.cpp
+		src/dusk/autosave.cpp
         src/dusk/io.cpp
         src/dusk/layout.cpp
         src/dusk/logging.cpp
@@ -1460,10 +1461,57 @@ set(DUSK_FILES
         src/dusk/imgui/ImGuiSaveEditor.cpp
         src/dusk/imgui/ImGuiStateShare.hpp
         src/dusk/imgui/ImGuiStateShare.cpp
+        src/dusk/imgui/ImGuiAchievements.hpp
+        src/dusk/imgui/ImGuiAchievements.cpp
+        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/input.cpp
+        src/dusk/ui/input.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/popup.cpp
+        src/dusk/ui/popup.hpp
+        src/dusk/ui/prelaunch.cpp
+        src/dusk/ui/prelaunch.hpp
+        src/dusk/ui/prelaunch_options.cpp
+        src/dusk/ui/prelaunch_options.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_presence.cpp
+        src/dusk/version.cpp
 )

include/d/actor/d_a_b_gnd.h

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

include/d/actor/d_a_e_mb.h

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

include/d/actor/d_a_mirror.h

@@ -27,6 +27,7 @@ public:
     /* 0x17C */ cXyz mViewScale;
 #if TARGET_PC
     bool mbReset = false;
+    bool mbHadEntry = false;
 #endif
 };
 

include/d/actor/d_a_obj_klift00.h

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

include/d/actor/d_a_obj_lv8Lift.h

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

include/d/d_cam_param.h

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

include/d/d_camera.h

@@ -273,6 +273,8 @@ public:
         /* 0xA4 */ f32 field_0xa4;
         /* 0xA8 */ int field_0xa8;
         /* 0xAC */ f32 field_0xac;
+        f32 xAngle;
+        f32 yAngle;
     };
 
     struct LockOnData {
@@ -1024,6 +1026,9 @@ public:
     bool colosseumCamera(s32);
     bool test1Camera(s32);
     bool test2Camera(s32);
+    #if TARGET_PC
+    bool freeCamera();
+    #endif
     bool towerCamera(s32);
     bool hookshotCamera(s32);
     bool railCamera(s32);

include/d/d_menu_dmap.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; }

include/d/d_menu_fmap2D.h

@@ -81,6 +81,10 @@ public:
     void calcDrawPriority();
     void setArrowPosAxis(f32, f32);
 
+    #if TARGET_PC
+    void fMapBackWide();
+    #endif
+
     virtual void draw();
     virtual ~dMenu_Fmap2DBack_c();
 
@@ -330,6 +334,10 @@ public:
     void setHIO(bool);
     bool isWarpAccept();
 
+    #if TARGET_PC
+    void fMapTopWide();
+    #endif
+
     virtual void draw();
     virtual ~dMenu_Fmap2DTop_c();
 

include/d/d_meter_button.h

@@ -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 */

include/d/d_msg_object.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();

include/d/d_name.h

@@ -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

include/d/d_s_logo.h

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

include/dusk/achievements.h

@@ -0,0 +1,74 @@
+#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 {
+    Story,
+    Collection,
+    Challenge,
+    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;
+    bool hasPendingUnlock() const { return !m_pendingUnlocks.empty(); }
+    std::string consumePendingUnlock();
+
+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;
+    std::queue<std::string> m_pendingUnlocks;
+};
+
+} // namespace dusk

include/dusk/autosave.h

@@ -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

include/dusk/dvd_asset.hpp

@@ -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

include/dusk/livesplit.h

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

include/dusk/settings.h

@@ -13,12 +13,26 @@ 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,
+};
+
 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;
+};
 }
 
 // Persistent user settings
@@ -41,11 +55,14 @@ struct UserSettings {
         ConfigVar<int> soundEffectsVolume;
         ConfigVar<int> fanfareVolume;
         ConfigVar<bool> enableReverb;
+        ConfigVar<bool> enableHrtf;
     } audio;
 
     // Game settings
 
     struct {
+        ConfigVar<GameLanguage> language;
+
         // QoL
         ConfigVar<bool> enableQuickTransform;
         ConfigVar<bool> hideTvSettingsScreen;
@@ -60,16 +77,18 @@ 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> pauseOnFocusLost;
         ConfigVar<bool> enableLinkDollRotation;
+        ConfigVar<bool> enableAchievementNotifications;
 
 
         // Graphics
@@ -80,6 +99,7 @@ struct UserSettings {
         ConfigVar<int> internalResolutionScale;
         ConfigVar<int> shadowResolutionMultiplier;
         ConfigVar<bool> enableDepthOfField;
+        ConfigVar<bool> enableMapBackground;
 
         // Audio
         ConfigVar<bool> noLowHpSound;
@@ -95,6 +115,10 @@ struct UserSettings {
         ConfigVar<float> gyroDeadband;
         ConfigVar<bool> gyroInvertPitch;
         ConfigVar<bool> gyroInvertYaw;
+        ConfigVar<bool> freeCamera;
+        ConfigVar<bool> invertCameraXAxis;
+        ConfigVar<bool> invertCameraYAxis;
+        ConfigVar<float> freeCameraSensitivity;
 
         // Cheats
         ConfigVar<bool> infiniteHearts;
@@ -117,6 +141,10 @@ struct UserSettings {
 
         // Controls
         ConfigVar<bool> enableTurboKeybind;
+
+        // Tools
+        ConfigVar<bool> speedrunMode;
+        ConfigVar<bool> liveSplitEnabled;
     } game;
 
     struct {

include/dusk/version.hpp

@@ -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

include/global.h

@@ -230,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

libs/JSystem/include/JSystem/JAudio2/JAISeqMgr.h

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

libs/JSystem/include/JSystem/JParticle/JPABaseShape.h

@@ -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 */

libs/JSystem/include/JSystem/JParticle/JPAParticle.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;

libs/JSystem/include/JSystem/JUtility/JUTPalette.h

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

libs/JSystem/include/JSystem/JUtility/JUTTexture.h

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

libs/JSystem/src/JAudio2/JASChannel.cpp

@@ -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:

libs/JSystem/src/JAudio2/JASHeapCtrl.cpp

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

libs/JSystem/src/JAudio2/JAUSectionHeap.cpp

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

libs/JSystem/src/JKernel/JKRExpHeap.cpp

@@ -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

libs/JSystem/src/JParticle/JPABaseShape.cpp

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

libs/JSystem/src/JParticle/JPAParticle.cpp

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

libs/JSystem/src/JUtility/JUTPalette.cpp

@@ -38,3 +38,9 @@ bool JUTPalette::load() {
 
     return check;
 }
+
+#if TARGET_PC
+void JUTPalette::dataUploaded() {
+    GXInitTlutObjData(&mTlutObj, (void*)mColorTable);
+}
+#endif

libs/JSystem/src/JUtility/JUTTexture.cpp

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

res/rml/overlay.rcss

@@ -0,0 +1,147 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    overflow: visible;
+    width: 100%;
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    font-family: "Fira Sans Condensed";
+    font-size: 24dp;
+    color: #FFFFFF;
+    display: flex;
+    flex-direction: column;
+    justify-content: flex-end;
+    align-items: stretch;
+}
+
+.overlay-root {
+    width: 100%;
+    min-height: 45%;
+    display: flex;
+    flex-direction: column;
+    justify-content: flex-end;
+    align-items: stretch;
+    decorator: vertical-gradient(#00000000 #151610F2);
+    padding: 48dp 0 40dp 0;
+    filter: opacity(0);
+    transition: filter 0.2s linear-in-out;
+}
+
+.overlay-root[open] {
+    filter: opacity(1);
+}
+
+.overlay {
+    width: 100%;
+    max-width: 1216dp;
+    margin-left: auto;
+    margin-right: auto;
+    display: flex;
+    flex-direction: column;
+    gap: 24dp;
+    padding: 0 32dp;
+}
+
+@media (max-height: 800dp) {
+    .overlay-root {
+        min-height: 38%;
+        padding: 32dp 0 28dp 0;
+    }
+
+    .overlay {
+        gap: 16dp;
+        padding: 0 24dp;
+    }
+}
+
+.header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 24dp;
+}
+
+.carousel-container {
+    flex: 1 1 auto;
+    display: flex;
+    justify-content: flex-end;
+    min-width: 0;
+}
+
+.description {
+    font-size: 18dp;
+    line-height: 22dp;
+    color: rgba(255, 255, 255, 50%);
+}
+
+.divider {
+    margin: 1dp 0;
+    border-top: 1dp rgba(217, 217, 217, 50%);
+}
+
+.footer {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 24dp;
+}
+
+footer-button {
+    display: block;
+    width: 100%;
+    max-width: 220dp;
+    border: 0;
+    padding: 0;
+    background-color: transparent;
+    font-family: "Fira Sans Condensed";
+    font-weight: bold;
+    font-size: 20dp;
+    line-height: 24dp;
+    text-transform: uppercase;
+    color: #FFFFFF;
+    opacity: 1;
+    cursor: pointer;
+}
+
+footer-button.return {
+    text-align: left;
+}
+
+footer-button.reset {
+    text-align: right;
+}
+
+.stepped-carousel {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 16dp;
+    width: auto;
+    min-width: 246dp;
+    padding: 0;
+    background-color: transparent;
+    font-family: "Fira Sans Condensed";
+    font-weight: bold;
+}
+
+.stepped-carousel-value {
+    line-height: 29dp;
+    min-width: 166dp;
+    text-align: center;
+    white-space: nowrap;
+    opacity: 0.9;
+}
+
+.stepped-carousel-arrow {
+    width: 24dp;
+    height: 24dp;
+    min-width: 24dp;
+    padding: 0;
+    border: 0;
+    background-color: transparent;
+    opacity: 1;
+    cursor: pointer;
+}

res/rml/popup.rcss

@@ -0,0 +1,45 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    overflow: visible;
+    width: 100%;
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    font-family: "Fira Sans Condensed";
+    font-weight: bold;
+    font-size: 18dp;
+    color: #E0DBC8;
+}
+
+button {
+    cursor: pointer;
+    focus: auto;
+}
+
+popup {
+    width: 100%;
+    display: flex;
+    align-items: stretch;
+    height: 64dp;
+    background-color: rgba(21, 22, 16, 80%);
+    border-bottom: 2dp #92875B;
+    backdrop-filter: blur(5dp);
+    transform: translateY(-64dp);
+    transition: transform 0.2s cubic-in-out;
+}
+
+popup[open] {
+    transform: translateY(0);
+}
+
+popup tab-bar {
+    flex: 1 1 0;
+}
+
+popup tab-bar tab {
+    opacity: 0.35;
+    color: #E0DBC8;
+}

res/rml/prelaunch.rcss

@@ -0,0 +1,187 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    width: 100%;
+    height: 100%;
+    font-family: "Fira Sans";
+    font-weight: normal;
+    font-size: 20dp;
+    color: #FFFFFF;
+    background-color: #000000;
+    decorator: image(../prelaunch-bg.png cover left center);
+    filter: opacity(0);
+    transition: filter 1s 0.1s linear-in-out;
+}
+
+body[open] {
+    filter: opacity(1);
+}
+
+content {
+    display: block;
+    width: 100%;
+    height: 100%;
+    filter: opacity(0);
+    transition: filter 0.2s linear-in-out;
+}
+
+content[open] {
+    filter: opacity(1);
+}
+
+menu {
+    position: absolute;
+    left: 96dp;
+    top: 50%;
+    transform: translateY(-50%);
+    /* Scale based on a reference screen width, 428/1216 */
+    width: 35.230264vw;
+    min-width: 428dp;
+    max-width: 856dp;
+    height: auto;
+    display: flex;
+    flex-direction: column;
+    gap: 48dp;
+}
+
+hero {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: flex-start;
+    gap: 8dp;
+}
+
+hero img {
+    width: 100%;
+}
+
+.eyebrow {
+    font-family: "Alegreya SC";
+    font-size: 32dp;
+}
+
+@media (min-width: 1216dp) {
+    .eyebrow {
+        /* Same logic as .menu, 32/1216 */
+        font-size: 2.631579vw;
+    }
+}
+
+.eyebrow span {
+    font-weight: bold;
+}
+
+#menu-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12dp;
+}
+
+#menu-list button {
+    width: 428dp;
+    height: 54dp;
+    padding: 8dp 16dp;
+    border-radius: 8dp;
+    text-transform: uppercase;
+    font-family: "Fira Sans Condensed";
+    font-size: 32dp;
+    font-weight: normal;
+    cursor: pointer;
+    /* Define a fully transparent gradient as the default state, otherwise a white flash occurs */
+    decorator: horizontal-gradient(#00000000 #00000000);
+}
+
+#menu-list button.anim-done {
+    transition: decorator color 0.1s linear-in-out;
+}
+
+#menu-list button:hover,
+#menu-list button:focus-visible {
+    color: black;
+    decorator: horizontal-gradient(#FEE685FF #FEE68500);
+}
+
+disk-status {
+    position: absolute;
+    left: 96dp;
+    bottom: 72dp;
+    display: flex;
+    flex-direction: column;
+    gap: 8dp;
+}
+
+version-info {
+    position: absolute;
+    right: 96dp;
+    bottom: 72dp;
+    display: flex;
+    flex-direction: column;
+    gap: 8dp;
+    text-align: right;
+}
+
+.status,
+.version {
+    font-size: 24dp;
+}
+
+.status,
+.update {
+    color: #D8F999;
+}
+
+.status[bad] {
+    color: #FFC9C9;
+}
+
+/* TODO: Hidden until an actual update checker is introduced */
+.update {
+    display: none;
+    font-size: 16dp;
+    font-weight: bold;
+    cursor: pointer;
+}
+
+.detail,
+.update span {
+    color: #A6A09B;
+}
+
+/* Startup animation */
+.intro-item {
+    opacity: 0;
+    transform: translateY(10dp);
+    transition: opacity transform 0.3s 0.1s cubic-in-out;
+}
+
+body.animate-in .intro-item {
+    opacity: 1;
+    transform: translateY(0dp);
+}
+
+.delay-0 {
+    transition: opacity transform 0.3s 0.1s cubic-in-out;
+}
+
+.delay-1 {
+    transition: opacity transform 0.3s 0.2s cubic-in-out;
+}
+
+.delay-2 {
+    transition: opacity transform 0.3s 0.3s cubic-in-out;
+}
+
+.delay-3 {
+    transition: opacity transform 0.3s 0.4s cubic-in-out;
+}
+
+.delay-4 {
+    transition: opacity transform 0.3s 0.5s cubic-in-out;
+}
+
+.delay-5 {
+    transition: opacity transform 0.3s 0.6s cubic-in-out;
+}

res/rml/tabbing.rcss

@@ -0,0 +1,83 @@
+tab-bar {
+    display: flex;
+    position: relative;
+    min-width: 0;
+    overflow: auto hidden;
+    clip: always;
+    text-transform: uppercase;
+}
+
+tab-bar scrollbarhorizontal,
+tab-bar scrollbarhorizontal sliderarrowdec,
+tab-bar scrollbarhorizontal sliderarrowinc,
+tab-bar scrollbarhorizontal slidertrack,
+tab-bar scrollbarhorizontal sliderbar {
+    width: 0;
+    height: 0;
+}
+
+tab-bar tab {
+    flex: 0 0 auto;
+    padding: 0 24dp;
+    line-height: 64dp;
+    white-space: nowrap;
+    decorator: vertical-gradient(#c2a42d00 #c2a42d00);
+    transition: decorator 0.1s linear-in-out, opacity 0.1s linear-in-out;
+    cursor: pointer;
+}
+
+tab-bar tab:selected {
+    opacity: 1;
+    border-bottom: 4dp #C2A42D;
+    font-effect: glow(0dp 4dp 0dp 4dp black);
+}
+
+tab-bar tab:focus-visible,
+tab-bar tab:hover {
+    opacity: 1;
+    font-effect: glow(0dp 4dp 0dp 4dp black);
+    decorator: vertical-gradient(#c2a42d00 #c2a42d26);
+}
+
+tab-bar tab:active {
+    decorator: vertical-gradient(#c2a42d10 #c2a42d40);
+}
+
+tab-bar[closable] tab-end-spacer {
+    display: block;
+    flex: 0 0 64dp;
+    width: 64dp;
+    pointer-events: none;
+}
+
+tab-bar[closable] close {
+    display: block;
+    position: fixed;
+    top: 8dp;
+    right: 8dp;
+    z-index: 1;
+    width: 48dp;
+    height: 48dp;
+    font-family: "Material Symbols Rounded";
+    font-weight: normal;
+    font-size: 24dp;
+    line-height: 48dp;
+    text-align: center;
+    text-transform: none;
+    color: rgba(224, 219, 200, 70%);
+    backdrop-filter: blur(2dp);
+    border-radius: 6dp;
+    transition: color background-color 0.12s linear-in-out;
+    cursor: pointer;
+}
+
+tab-bar[closable] close:hover,
+tab-bar[closable] close:focus-visible {
+    color: #fff;
+    background-color: rgba(194, 164, 45, 24%);
+}
+
+tab-bar[closable] close:active {
+    color: #fff;
+    background-color: rgba(194, 164, 45, 40%);
+}

res/rml/window.rcss

@@ -0,0 +1,243 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    width: 100%;
+    height: 100%;
+    padding: 64dp;
+    font-family: "Fira Sans";
+    font-weight: normal;
+    font-style: normal;
+    font-size: 15dp;
+    color: #E0DBC8;
+}
+
+window {
+    display: flex;
+    flex-flow: column;
+    height: 100%;
+    max-width: 1088dp;
+    max-height: 768dp;
+    margin: auto;
+    border-radius: 14dp;
+    overflow: hidden;
+    border: 2dp #92875B;
+    backdrop-filter: blur(5dp);
+    box-shadow: 0 0 25dp 5dp;
+    background-color: rgba(21, 22, 16, 90%);
+    filter: opacity(0);
+    transform: scale(0.9);
+    transform-origin: center;
+    transition: filter transform 0.2s cubic-in-out;
+}
+
+window[open] {
+    filter: opacity(1);
+    transform: scale(1);
+}
+
+@media (max-height: 640dp) {
+    body {
+        padding: 16dp;
+    }
+    window {
+        box-shadow: none;
+    }
+}
+
+window tab-bar {
+    flex: 0 0 64dp;
+    height: 64dp;
+    background-color: rgba(217, 217, 217, 10%);
+    font-family: "Fira Sans Condensed";
+    font-weight: bold;
+    font-size: 18dp;
+    border-bottom: 2dp #92875B;
+}
+
+window tab-bar tab {
+    opacity: 0.25;
+}
+
+window content {
+    display: flex;
+    flex: 1 1 0;
+    min-width: 0;
+    min-height: 0;
+    overflow: hidden;
+}
+
+window content pane {
+    display: flex;
+    flex-flow: column;
+    flex: 1 1 0;
+    height: 100%;
+    min-width: 0;
+    min-height: 0;
+    padding: 24dp;
+    padding-bottom: 0dp;
+    gap: 8dp;
+    overflow: hidden auto;
+    font-size: 20dp;
+}
+
+window content pane:not(:last-of-type) {
+    border-right: 1dp #92875B;
+}
+
+window content pane > * {
+    flex: 0 0 auto;
+}
+
+window content pane > spacer {
+    display: block;
+    /* Completes the 24dp bottom inset after the pane's 8dp gap. */
+    flex: 0 0 16dp;
+    height: 16dp;
+    pointer-events: none;
+}
+
+scrollbarvertical {
+    width: 8dp;
+    margin: 4dp 4dp 4dp 0;
+}
+
+scrollbarvertical sliderarrowdec,
+scrollbarvertical sliderarrowinc {
+    width: 0;
+    height: 0;
+}
+
+scrollbarvertical slidertrack {
+    width: 8dp;
+}
+
+scrollbarvertical sliderbar {
+    width: 8dp;
+    min-height: 24dp;
+    background-color: rgba(224, 219, 200, 45%);
+    border-radius: 2dp;
+    transition: background-color 0.2s cubic-in-out;
+}
+
+scrollbarvertical sliderbar:hover,
+scrollbarvertical sliderbar:active {
+    background-color: rgba(194, 164, 45, 80%);
+}
+
+scrollbarhorizontal {
+    height: 0;
+}
+
+scrollbarhorizontal sliderarrowdec,
+scrollbarhorizontal sliderarrowinc {
+    width: 0;
+    height: 0;
+}
+
+scrollbarhorizontal slidertrack,
+scrollbarhorizontal sliderbar {
+    width: 0;
+    height: 0;
+}
+
+.section-heading {
+    font-family: "Fira Sans Condensed";
+    font-weight: bold;
+    text-transform: uppercase;
+    font-size: 22dp;
+    opacity: 0.25;
+}
+
+.section-heading:not(:first-of-type) {
+    padding-top: 12dp;
+}
+
+button {
+    text-align: center;
+    background-color: rgba(17, 16, 10, 20%);
+    opacity: 0.9;
+    padding: 8dp 16dp;
+    border-radius: 14dp;
+    box-shadow: rgba(146, 135, 91, 25%) 0 0 0 1dp;
+    font-size: 20dp;
+    transition: background-color 0.1s linear-in-out, opacity 0.1s linear-in-out;
+    cursor: pointer;
+    focus: auto;
+}
+
+button:not(:disabled):hover,
+button:not(:disabled):focus-visible {
+    background-color: rgba(204, 184, 119, 20%);
+    box-shadow: #C2A42D 0 0 0 2dp;
+}
+
+button:not(:disabled):selected {
+    opacity: 1;
+    background-color: rgba(204, 184, 119, 40%);
+}
+
+button:not(:disabled):active {
+    opacity: 1;
+    background-color: rgba(204, 184, 119, 40%);
+    box-shadow: #C2A42D 0 0 0 2dp;
+}
+
+select-button {
+    display: flex;
+    align-items: center;
+    gap: 8dp;
+    background-color: rgba(17, 16, 10, 20%);
+    opacity: 0.9;
+    padding: 8dp 16dp;
+    border-radius: 14dp;
+    box-shadow: rgba(146, 135, 91, 25%) 0 0 0 1dp;
+    transition: background-color 0.1s linear-in-out, opacity 0.1s linear-in-out;
+    cursor: pointer;
+    focus: auto;
+}
+
+select-button:not(:disabled):hover,
+select-button:not(:disabled):focus-visible {
+    background-color: rgba(204, 184, 119, 20%);
+    box-shadow: #C2A42D 0 0 0 2dp;
+}
+
+select-button:not(:disabled):selected {
+    opacity: 1;
+    background-color: rgba(204, 184, 119, 40%);
+}
+
+select-button:not(:disabled):active {
+    opacity: 1;
+    background-color: rgba(204, 184, 119, 40%);
+    box-shadow: #C2A42D 0 0 0 2dp;
+}
+
+select-button:disabled {
+    opacity: 0.35;
+    cursor: default;
+}
+
+select-button key {
+    font-family: "Fira Sans Condensed";
+    font-weight: bold;
+    font-size: 18dp;
+    text-transform: uppercase;
+    flex: 1 0 auto;
+}
+
+select-button value {
+    margin-left: auto;
+    font-size: 20dp;
+}
+
+select-button value.modified {
+    font-weight: bold;
+}
+
+select-button input {
+    text-align: right;
+    font-size: 20dp;
+}

src/SSystem/SComponent/c_lib.cpp

@@ -468,9 +468,20 @@ s16 cLib_targetAngleX(cXyz const* lhs, cXyz const* rhs) {
 void cLib_offsetPos(cXyz* pdest, cXyz const* psrc, s16 angle, cXyz const* vec) {
     f32 cos = cM_scos(angle);
     f32 sin = cM_ssin(angle);
+    // MWCC loads vec members into registers before writing to pdest; other compilers may not,
+    // which corrupts results when pdest and vec alias the same memory.
+#if !__MWERKS__
+    f32 vx = vec->x;
+    f32 vy = vec->y;
+    f32 vz = vec->z;
+    pdest->x = psrc->x + (vx * cos + vz * sin);
+    pdest->y = psrc->y + vy;
+    pdest->z = psrc->z + (vz * cos - vx * sin);
+#else
     pdest->x = psrc->x + (vec->x * cos + vec->z * sin);
     pdest->y = psrc->y + vec->y;
     pdest->z = psrc->z + (vec->z * cos - vec->x * sin);
+#endif
 }
 
 /**

src/Z2AudioLib/Z2Audience.cpp

@@ -1,5 +1,9 @@
 #include "Z2AudioLib/Z2Audience.h"
 #include "Z2AudioLib/Z2SoundInfo.h"
+#if TARGET_PC
+#include "dusk/audio/DuskDsp.hpp"
+#include <cmath>
+#endif
 #include "Z2AudioLib/Z2Calc.h"
 #include "Z2AudioLib/Z2Param.h"
 #include "JSystem/JAudio2/JAISound.h"
@@ -734,9 +738,22 @@ f32 Z2Audience::calcRelPosPan(const Vec& param_0, int camID) {
 
 f32 Z2Audience::calcRelPosDolby(const Vec& param_0, int camID) {
     f32 fVar1 = param_0.z + mAudioCamera[camID].getDolbyCenterZ();
+#if TARGET_PC
+    if (dusk::audio::EnableHrtf) {
+        // Normalize the direction so result is purely front/back orientation,
+        // independent of how far away the sound is
+        f32 lenSq = param_0.x * param_0.x + param_0.y * param_0.y + param_0.z * param_0.z;
+        if (lenSq < 0.0001f) {
+            return 0.5f;
+        }
+        f32 zNorm = param_0.z / sqrtf(lenSq);
+        f32 t = (zNorm + 1.0f) * 0.5f;
+        return 0.5f - 0.5f * cosf(t * static_cast<f32>(M_PI));
+    }
+#endif
     if (fVar1 > mSetting.field_0x48) {
         return 1.0f;
-    } 
+    }
 
     if (fVar1 < mSetting.field_0x44) {
         return 0.0f;

src/d/actor/d_a_alink.cpp

@@ -4962,13 +4962,16 @@ int daAlink_c::create() {
 
         setArcName(checkWolf());
         setOriginalHeap(&mpArcHeap, 0xA2800);
+        JKRHEAP_NAME(mpArcHeap, "Alink ArcHeap");
         if (dComIfG_resLoad(&mPhaseReq, mArcName, mpArcHeap) != cPhs_COMPLEATE_e) {
             return cPhs_INIT_e;
         }
 
         setShieldArcName();
         setOriginalHeap(&mpShieldArcHeap, 0x7000);
-        if (dComIfG_resLoad(&mShieldPhaseReq, mShieldArcName, mpShieldArcHeap) != cPhs_COMPLEATE_e) {
+        JKRHEAP_NAME(mpShieldArcHeap, "Alink ShieldArcHeap");
+        if (dComIfG_resLoad(&mShieldPhaseReq, mShieldArcName, mpShieldArcHeap) != cPhs_COMPLEATE_e)
+        {
             return cPhs_INIT_e;
         }
 
@@ -5877,6 +5880,11 @@ void daAlink_c::setItemMatrix(int param_0) {
     modelCalc(mSheathModel);
 
     int var_r26;
+
+    #if AVOID_UB
+    var_r26 = 0;
+    #endif
+
     if (!checkNoResetFlg3(FLG3_UNK_4000000)) {
         if (mEquipItem == 0x103 || param_0 != 0) {
             mSwordModel->setBaseTRMtx(mpLinkModel->getAnmMtx(mLeftItemJntNo));
@@ -18936,11 +18944,20 @@ void daAlink_c::setDrawHand() {
     mpLinkHandModel->setBaseTRMtx(mpLinkModel->getBaseTRMtx());
     mpLinkHandModel->calc();
 
+#if TARGET_PC
+    // FRAME INTERP NOTE: Always set these, otherwise the hands occasionally zip to origin.
+    // Doing it regardless of interpolation being active seems harmless.
+    mpLinkHandModel->setAnmMtx(1, mpLinkModel->getAnmMtx(9));
+    mpLinkHandModel->setAnmMtx(2, mpLinkModel->getAnmMtx(0xE));
+#endif
+
     if (var_r30 == 0xFE || var_r30 == 0xFB) {
         field_0x06d0 = field_0x06d8;
     } else {
         field_0x06d0 = mpLinkHandModel->getModelData()->getMaterialNodePointer(var_r30)->getShape();
+#if !TARGET_PC
         mpLinkHandModel->setAnmMtx(1, mpLinkModel->getAnmMtx(9));
+#endif
     }
 
     if (var_r30 == 0xFB) {
@@ -18959,7 +18976,9 @@ void daAlink_c::setDrawHand() {
         field_0x06d4 = field_0x06dc;
     } else {
         field_0x06d4 = mpLinkHandModel->getModelData()->getMaterialNodePointer(var_r29)->getShape();
+#if !TARGET_PC
         mpLinkHandModel->setAnmMtx(2, mpLinkModel->getAnmMtx(0xE));
+#endif
     }
 
     if (var_r29 == 0xFB) {

src/d/actor/d_a_alink_damage.inc

@@ -8,6 +8,10 @@
 #include "d/actor/d_a_horse.h"
 #include "d/actor/d_a_crod.h"
 #include "d/d_msg_object.h"
+#ifdef TARGET_PC
+#include "d/actor/d_a_obj_carry.h"
+#include "dusk/achievements.h"
+#endif
 
 #if DEBUG
 #include "d/d_s_menu.h"
@@ -677,6 +681,15 @@ BOOL daAlink_c::checkDamageAction() {
             }
 
             setDamagePoint(dmg, at_mtrl == dCcD_MTRL_FIRE || at_mtrl == dCcD_MTRL_ICE, TRUE, 0);
+            
+#ifdef TARGET_PC
+            if (tghit_ac_name == fpcNm_Obj_Carry_e) {
+                auto* carry = static_cast<daObjCarry_c*>(tghit_ac);
+                if (carry->prm_chk_type_ironball() && carry->checkCannon()) {
+                    dusk::AchievementSystem::get().signal("iron_ball_hit_player");
+                }
+            }
+#endif
 
             if (armor_no_dmg && at_mtrl != dCcD_MTRL_ELECTRIC && at_mtrl != dCcD_MTRL_ICE) {
                 setGuardSe(var_r29);

src/d/actor/d_a_alink_demo.inc

@@ -23,6 +23,7 @@
 #include "d/actor/d_a_npc_tkc.h"
 #include <cstring>
 
+#include "dusk/imgui/ImGuiConsole.hpp"
 #include "dusk/settings.h"
 
 BOOL daAlink_c::checkEventRun() const {
@@ -4005,6 +4006,15 @@ int daAlink_c::procGanonFinishInit() {
 
     field_0x37c8 = current.pos;
     onEndResetFlg1(ERFLG1_SHIELD_BACKBONE);
+
+#if TARGET_PC
+    if (dusk::getSettings().game.speedrunMode) {
+        if (dusk::m_speedrunInfo.m_isRunStarted) {
+            dusk::m_speedrunInfo.stopRun();
+        }
+    }
+#endif
+
     return 1;
 }
 

src/d/actor/d_a_alink_hook.inc

@@ -18,6 +18,10 @@ enum {
 };
 
 void daAlink_c::hsChainShape_c::draw() {
+    if (dusk::getSettings().game.superClawshot) {
+        return;
+    }
+
     static const int dummy = 0;
 
     daAlink_c* alink = (daAlink_c*)getUserArea();

src/d/actor/d_a_alink_swindow.inc

@@ -46,7 +46,6 @@ void daAlink_c::setOriginalHeap(JKRExpHeap** i_ppheap, u32 i_size) {
         JKRHeap* parent = mDoExt_getGameHeap();
 
         JKRExpHeap* heap = JKRExpHeap::create(size + (var_r29 + var_r28), parent, true);
-        JKRHEAP_NAME(heap, "Alink original");
         *i_ppheap = heap;
     }
 }

src/d/actor/d_a_b_gnd.cpp

@@ -17,6 +17,9 @@
 
 #include "Z2AudioLib/Z2Instances.h"
 
+#include "dusk/frame_interpolation.h"
+#include "dusk/settings.h"
+
 class daB_GND_HIO_c : public JORReflexible {
 public:
     daB_GND_HIO_c();
@@ -279,6 +282,30 @@ static int h_nodeCallBack(J3DJoint* i_joint, int param_2) {
     return 1;
 }
 
+#if TARGET_PC
+static void b_gnd_rein_interp_callback(bool isSimFrame, void* pUserWork) {
+    b_gnd_class* i_this = (b_gnd_class*)pUserWork;
+    if (!i_this->mReinsInterpPrevValid || !i_this->mReinsInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    for (int r = 0; r < 2; r++) {
+        cXyz* dst = i_this->mHorseReins[r].getPos(0);
+        for (int i = 0; i < 16; i++) {
+            const cXyz& p0 = i_this->mReinsInterpPrev[r][i];
+            const cXyz& p1 = i_this->mReinsInterpCurr[r][i];
+            dst[i] = p0 + (p1 - p0) * alpha;
+        }
+    }
+    cXyz* dst = i_this->field_0x21e8.getPos(0);
+    for (int i = 0; i < 2; i++) {
+        const cXyz& p0 = i_this->mReinsTexInterpPrev[i];
+        const cXyz& p1 = i_this->mReinsTexInterpCurr[i];
+        dst[i] = p0 + (p1 - p0) * alpha;
+    }
+}
+#endif
+
 static int daB_GND_Draw(b_gnd_class* i_this) {
     fopAc_ac_c* a_this = (fopAc_ac_c*)i_this;
     
@@ -366,6 +393,21 @@ static int daB_GND_Draw(b_gnd_class* i_this) {
 
         i_this->field_0x21e8.update(2, l_color, &a_this->tevStr);
         dComIfGd_set3DlineMat(&i_this->field_0x21e8);
+#if TARGET_PC
+        if (dusk::getSettings().game.enableFrameInterpolation) {
+            if (i_this->mReinsInterpCurrValid) {
+                memcpy(i_this->mReinsInterpPrev, i_this->mReinsInterpCurr, sizeof(i_this->mReinsInterpCurr));
+                memcpy(i_this->mReinsTexInterpPrev, i_this->mReinsTexInterpCurr, sizeof(i_this->mReinsTexInterpCurr));
+                i_this->mReinsInterpPrevValid = true;
+            }
+            for (int r = 0; r < 2; r++) {
+                memcpy(i_this->mReinsInterpCurr[r], i_this->mHorseReins[r].getPos(0), 16 * sizeof(cXyz));
+            }
+            memcpy(i_this->mReinsTexInterpCurr, i_this->field_0x21e8.getPos(0), 2 * sizeof(cXyz));
+            i_this->mReinsInterpCurrValid = true;
+            dusk::frame_interp::add_interpolation_callback(&b_gnd_rein_interp_callback, i_this);
+        }
+#endif
     }
     
     return 1;
@@ -1189,10 +1231,16 @@ static void b_gnd_h_end(b_gnd_class* i_this) {
 
             if (i_this->mDemoCamMode < 32) {
                 i_this->mDemoCamMode = 32;
+#if TARGET_PC
+                i_this->mDemoCamSyncTicks = 2;
+#endif
             } else {
                 i_this->mDemoCamMode = 34;
                 i_this->mDemoCamTimer = 0;
                 i_this->mMoveMode = 2;
+#if TARGET_PC
+                i_this->mDemoCamSyncTicks = 2;
+#endif
             }
         }
         break;
@@ -2887,6 +2935,9 @@ static void demo_camera(b_gnd_class* i_this) {
     cXyz spF0;
 
     s8 sp8 = false;
+#if TARGET_PC
+    const s16 entry_demo_cam_mode = i_this->mDemoCamMode;
+#endif
     switch (i_this->mDemoCamMode) {
     case 0:
         break;
@@ -3725,6 +3776,15 @@ static void demo_camera(b_gnd_class* i_this) {
             i_this->mDemoCamTimer = 10000;
         }
     }
+#if TARGET_PC
+    if (entry_demo_cam_mode != i_this->mDemoCamMode) {
+        i_this->mDemoCamSyncTicks = 2;
+    }
+    if (i_this->mDemoCamSyncTicks > 0) {
+        dusk::frame_interp::request_presentation_sync();
+        i_this->mDemoCamSyncTicks--;
+    }
+#endif
 }
 
 static void anm_se_set(b_gnd_class* i_this) {

src/d/actor/d_a_balloon_2D.cpp

@@ -6,6 +6,7 @@
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
 #include "d/actor/d_a_balloon_2D.h"
+#include "dusk/frame_interpolation.h"
 #include "JSystem/J2DGraph/J2DGrafContext.h"
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/J2DGraph/J2DTextBox.h"
@@ -438,7 +439,12 @@ void daBalloon2D_c::setComboAlpha() {
 void daBalloon2D_c::drawAddScore() {
     for (s32 i = 19; i >= 0; i--) {
         if (field_0x5f8[i].field_0xe != 0) {
-            field_0x5f8[i].field_0xe--;
+#ifdef TARGET_PC
+            if (dusk::frame_interp::get_ui_tick_pending())
+#endif
+            {
+                field_0x5f8[i].field_0xe--;
+            }
             s32 score3;
             s32 score2;
             s32 score = field_0x5f8[i].field_0xc;
@@ -446,8 +452,13 @@ void daBalloon2D_c::drawAddScore() {
             u8 local_88 = 0xff;
             f32 dVar11 = 30.0f;
             f32 dVar9 = 30.0f;
-            field_0x5f8[i].field_0x0.x += cM_ssin(temp0) * 0.3f;
-            field_0x5f8[i].field_0x0.y -= 1.0f;
+#ifdef TARGET_PC
+            if (dusk::frame_interp::get_ui_tick_pending())
+#endif
+            {
+                field_0x5f8[i].field_0x0.x += cM_ssin(temp0) * 0.3f;
+                field_0x5f8[i].field_0x0.y -= 1.0f;
+            }
             if (field_0x5f8[i].field_0xe < 10) {
                 f32 fVar5 = field_0x5f8[i].field_0xe / 10.0f;
                 local_88 = fVar5 * 255.0f;

src/d/actor/d_a_door_shutter.cpp

@@ -17,6 +17,11 @@
 #include <cstdio>
 #include <cstring>
 
+#if TARGET_PC
+#include <f_ap/f_ap_game.h>
+#include <dusk/autosave.h>
+#endif
+
 char* daDoor20_c::getStopBmdName() {
     switch (door_param2_c::getKind(this)) {
         case 3:
@@ -196,6 +201,7 @@ void daDoor20_c::setEventPrm() {
     } else {
         roomNo = FRoomNo;
     }
+
     if (dComIfGp_roomControl_checkStatusFlag(roomNo, 1)) {
         if (door_param2_c::getKind(this) == 9) {
             if (daPy_py_c::checkNowWolf()) {
@@ -564,6 +570,11 @@ int daDoor20_c::openEnd(int param_1) {
         openEnd_1();
         break;
     }
+
+    #if TARGET_PC
+    triggerAutoSave();
+    #endif
+
     return 1;
 }
 

src/d/actor/d_a_e_mb.cpp

@@ -12,6 +12,8 @@
 #include "d/d_bomb.h"
 #include "c/c_damagereaction.h"
 #include "Z2AudioLib/Z2Instances.h"
+#include "dusk/frame_interpolation.h"
+#include "dusk/settings.h"
 
 #define ACTION_STANDBY    0
 #define ACTION_WALK1      1
@@ -63,6 +65,22 @@ static void anm_init(e_mb_class* i_this, int i_anmID, f32 i_morf, u8 i_attr, f32
     i_this->mAnm = i_anmID;
 }
 
+#if TARGET_PC
+static void e_mb_rope_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_mb_class* i_this = (e_mb_class*)pUserWork;
+    if (!i_this->mRopeInterpPrevValid || !i_this->mRopeInterpCurrValid) {
+        return;
+    }
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    cXyz* dst = i_this->mRopeMat.getPos(0);
+    for (int i = 0; i < 16; i++) {
+        const cXyz& p0 = i_this->mRopeInterpPrev[i];
+        const cXyz& p1 = i_this->mRopeInterpCurr[i];
+        dst[i] = p0 + (p1 - p0) * alpha;
+    }
+}
+#endif
+
 static int daE_MB_Draw(e_mb_class* i_this) {
     fopAc_ac_c* a_this = (fopAc_ac_c*)i_this;
 
@@ -86,6 +104,17 @@ static int daE_MB_Draw(e_mb_class* i_this) {
     static GXColor l_color = {0x14, 0x0F, 0x00, 0xFF};
     i_this->mRopeMat.update(16, l_color, &a_this->tevStr);
     dComIfGd_set3DlineMat(&i_this->mRopeMat);
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (i_this->mRopeInterpCurrValid) {
+            memcpy(i_this->mRopeInterpPrev, i_this->mRopeInterpCurr, sizeof(i_this->mRopeInterpCurr));
+            i_this->mRopeInterpPrevValid = true;
+        }
+        memcpy(i_this->mRopeInterpCurr, i_this->mRopeMat.getPos(0), 16 * sizeof(cXyz));
+        i_this->mRopeInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&e_mb_rope_interp_callback, i_this);
+    }
+#endif
     return 1;
 }
 

src/d/actor/d_a_e_sm2.cpp

@@ -14,6 +14,10 @@
 #include "f_op/f_op_camera_mng.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
+
 class daE_SM2_HIO_c : public fOpAcm_HIO_entry_c {
 public:
     daE_SM2_HIO_c();
@@ -76,8 +80,62 @@ static int nodeCallBack(J3DJoint* i_joint, int param_1) {
     return 1;
 }
 
+#if TARGET_PC
+static void daE_SM2_interp_callback(bool isSimFrame, void* pUserWork) {
+    e_sm2_class* i_this = static_cast<e_sm2_class*>(pUserWork);
+    if (i_this == NULL) {
+        return;
+    }
+
+    fopAc_ac_c* actor = (fopAc_ac_c*)&i_this->enemy;
+    g_env_light.settingTevStruct(0, &actor->current.pos, &actor->tevStr);
+
+    if (!i_this->isPiece) {
+        if (i_this->modelMorf == NULL) {
+            return;
+        }
+        J3DModel* model = i_this->modelMorf->getModel();
+        if (model == NULL) {
+            return;
+        }
+        g_env_light.setLightTevColorType_MAJI(model, &actor->tevStr);
+
+        J3DMaterial* material = model->getModelData()->getMaterialNodePointer(0);
+        material->getTevKColor(1)->r = i_this->color_R;
+        material->getTevKColor(1)->g = i_this->color_G;
+        material->getTevKColor(1)->b = i_this->color_B;
+        material->getTevKColor(1)->a = 217.0f * i_this->color_alpha;
+
+        if (i_this->pbtk != NULL) {
+            i_this->pbtk->entry(model->getModelData());
+        }
+    } else {
+        if (i_this->pieceModelMorf == NULL) {
+            return;
+        }
+        J3DModel* model = i_this->pieceModelMorf->getModel();
+        if (model == NULL) {
+            return;
+        }
+
+        J3DMaterial* material = model->getModelData()->getMaterialNodePointer(0);
+        material->getTevKColor(1)->r = i_this->color_R;
+        material->getTevKColor(1)->g = i_this->color_G;
+        material->getTevKColor(1)->b = i_this->color_B;
+        material->getTevKColor(1)->a = 217.0f * i_this->color_alpha;
+
+        g_env_light.setLightTevColorType_MAJI(model, &actor->tevStr);
+    }
+}
+#endif
+
 static int daE_SM2_Draw(e_sm2_class* i_this) {
     fopAc_ac_c* actor = (fopAc_ac_c*)&i_this->enemy;
+
+#if TARGET_PC
+    dusk::frame_interp::add_interpolation_callback(&daE_SM2_interp_callback, i_this);
+#endif
+
     g_env_light.settingTevStruct(0, &actor->current.pos, &actor->tevStr);
 
     J3DModel* model;

src/d/actor/d_a_e_th.cpp

@@ -282,6 +282,11 @@ static void e_th_spin_B(e_th_class* i_this) {
     i_this->current.pos += spC;
 
     f32 speed_target;
+
+    #if AVOID_UB
+    speed_target = 0;
+    #endif
+
     f32 anm_frame = i_this->mpModelMorf->getFrame();
 
     switch (i_this->mMode) {

src/d/actor/d_a_e_ym.cpp

@@ -1069,7 +1069,7 @@ void daE_YM_c::executeDown() {
             if (mAcch.ChkGroundHit()) {
                 if (mFlyType != 1) {
                     #if TARGET_PC
-                    bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 2.0f : 1.0f);
+                    bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears ? 2.0f : 1.0f);
                     #else
                     bckSet(6, 0, 0.0f, 1.0f);
                     #endif
@@ -1093,7 +1093,7 @@ void daE_YM_c::executeDown() {
                 mSound.startCreatureSound(Z2SE_CM_BODYFALL_WATER_M, 0, -1);
                 mSound.startCreatureSound(Z2SE_EN_YM_MOGAKU, 0, -1);
                 #if TARGET_PC
-                bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 2.0f : 1.0f);
+                bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears ? 2.0f : 1.0f);
                 #else
                 bckSet(6, 0, 0.0f, 1.0f);
                 #endif
@@ -1115,7 +1115,7 @@ void daE_YM_c::executeDown() {
                     || dComIfG_Bgsp().GetGroundCode(gnd_chk) == 5)
             {
                     #if TARGET_PC
-                    bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 2.0f : 1.0f);
+                    bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears ? 2.0f : 1.0f);
                     #else
                     bckSet(6, 0, 0.0f, 1.0f);
                     #endif

src/d/actor/d_a_mant.cpp

@@ -13,9 +13,12 @@
 #if TARGET_PC
 #include "dusk/dvd_asset.hpp"
 #include "dusk/frame_interpolation.h"
-static u8* l_Egnd_mantTEX_get()   { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0x1C00, 0x4000), true); return buf; }
-static u8* l_Egnd_mantTEX_U_get() { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0x5C00, 0x4000), true); return buf; }
-static u8* l_Egnd_mantPAL_get()   { alignas(32) static u8 buf[0x60];   static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0x9C00, 0x60),   true); return buf; }
+
+using GameVersion = dusk::version::GameVersion;
+
+static u8* l_Egnd_mantTEX_get()   { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0x1C00}, {GameVersion::GcnPal, 0x1C00}}, 0x4000), true); return buf; }
+static u8* l_Egnd_mantTEX_U_get() { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0x5C00}, {GameVersion::GcnPal, 0x5C00}}, 0x4000), true); return buf; }
+static u8* l_Egnd_mantPAL_get()   { alignas(32) static u8 buf[0x60];   static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0x9C00}, {GameVersion::GcnPal, 0x9C00}}, 0x60),   true); return buf; }
 #define l_Egnd_mantTEX   (l_Egnd_mantTEX_get())
 #define l_Egnd_mantTEX_U (l_Egnd_mantTEX_U_get())
 #define l_Egnd_mantPAL   (l_Egnd_mantPAL_get())
@@ -251,7 +254,9 @@ static u32 l_texCoord[338] = {
 };
 
 #if TARGET_PC
-static u8* l_Egnd_mantDL_get() { alignas(32) static u8 buf[0x3EC]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0xA9A0, 0x3EC), true); return buf; }
+using GameVersion = dusk::version::GameVersion;
+
+static u8* l_Egnd_mantDL_get() { alignas(32) static u8 buf[0x3EC]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0xA9A0}, {GameVersion::GcnPal, 0xA9A0}}, 0x3EC), true); return buf; }
 #define l_Egnd_mantDL (l_Egnd_mantDL_get())
 #else
 #include "assets/l_Egnd_mantDL.h"

src/d/actor/d_a_mg_fish.cpp

@@ -22,6 +22,7 @@
 #include "d/d_s_play.h"
 #include "d/d_vibration.h"
 #include "f_op/f_op_kankyo_mng.h"
+#include "dusk/version.hpp"
 #include <cstring>
 
 #define ANM_MG_FISH_MOUTH_CLOSE     4
@@ -3230,7 +3231,17 @@ static int daMg_Fish_Execute(mg_fish_class* i_this) {
 
     daPy_py_c* player = daPy_getPlayerActorClass();
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        lit_1008 = 0;
+    } else if (dusk::version::isRegionPal()) {
+        if (dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH) {
+            lit_1008 = 2;
+        } else {
+            lit_1008 = 0;
+        }
+    }
+#elif VERSION == VERSION_GCN_JPN
     lit_1008 = 0;
 #elif VERSION == VERSION_GCN_PAL
     if (dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH) {
@@ -3843,7 +3854,19 @@ static int daMg_Fish_Create(fopAc_ac_c* i_this) {
         a_this->mResName = "O_gD_bott";
     }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        lit_1008 = 0;
+    } else if (dusk::version::isRegionPal()) {
+        if (dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH) {
+            lit_1008 = 2;
+        } else {
+            lit_1008 = 0;
+        }
+    } else {
+        lit_1008 = 1;
+    }
+#elif VERSION == VERSION_GCN_JPN
     lit_1008 = 0;
 #elif VERSION == VERSION_GCN_PAL
     if (dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH) {

src/d/actor/d_a_mg_fshop.cpp

@@ -5,14 +5,15 @@
 
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
+#include "Z2AudioLib/Z2Instances.h"
+#include "d/actor/d_a_mg_fish.h"
 #include "d/actor/d_a_mg_fshop.h"
 #include "d/actor/d_a_npc_henna.h"
-#include "d/actor/d_a_mg_fish.h"
 #include "d/actor/d_a_player.h"
-#include "f_op/f_op_camera_mng.h"
-#include "d/d_timer.h"
 #include "d/d_s_play.h"
-#include "Z2AudioLib/Z2Instances.h"
+#include "d/d_timer.h"
+#include "dusk/version.hpp"
+#include "f_op/f_op_camera_mng.h"
 
 #if TARGET_PC
 #include "dusk/gyro.h"
@@ -1742,7 +1743,18 @@ static int daFshop_Create(fopAc_ac_c* actor) {
         fopAcM_createChild(fpcNm_FSHOP_e, fopAcM_GetID(actor), 0xFFFFFF23, &actor->current.pos, fopAcM_GetRoomNo(actor), NULL, NULL, -1, NULL);
 
         u8 sp10;
-#if VERSION == VERSION_GCN_PAL || VERSION == VERSION_WII_PAL
+#if TARGET_PC
+        if (dusk::version::isRegionPal()) {
+            if (dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH) {
+                sp10 = 2;
+            } else {
+                sp10 = 0;
+            }
+        } else {
+            sp10 = 1;
+        }
+
+#elif VERSION == VERSION_GCN_PAL || VERSION == VERSION_WII_PAL
         if (dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH) {
             sp10 = 2;
         } else {

src/d/actor/d_a_mg_rod.cpp

@@ -25,6 +25,8 @@
 #include <cmath>
 #include <cstring>
 
+#include "dusk/version.hpp"
+
 class dmg_rod_HIO_c : public JORReflexible {
 public:
     dmg_rod_HIO_c();
@@ -5734,10 +5736,22 @@ static void play_camera_u(dmg_rod_class* i_this) {
 static int dmg_rod_Execute(dmg_rod_class* i_this) {
     fopAc_ac_c* actor = &i_this->actor;
 
+    #if TARGET_PC
+    if (dusk::version::isPalOrAtLeastWiiR2()) {
+        if (dComIfGs_getPalLanguage() == 0) {
+            data_804BBBD4 = 2;
+        } else {
+            data_804BBBD4 = 0;
+        }
+    } else if (dusk::version::isRegionJpn()) {
+        data_804BBBD4 = 0;
+    } else {
+        data_804BBBD4 = 1;
+    }
     //TODO: It seems possible that dComIfGs_getPalLanguage returns a constant value for non-PAL
     //      versions (causing the first block to be elided), and it's also possible that the value
     //      being compared against is an enum value with per-version definitions.
-    #if VERSION == VERSION_SHIELD_DEBUG
+    #elif VERSION == VERSION_SHIELD_DEBUG
     if (dComIfGs_getPalLanguage() == 1) {
         data_804BBBD4 = 2;
     } else {
@@ -6303,7 +6317,19 @@ static int dmg_rod_Create(fopAc_ac_c* i_this) {
         heap_size = 0xC9A0;
     }
 
-    #if VERSION == VERSION_SHIELD_DEBUG
+    #if TARGET_PC
+    if (dusk::version::isPalOrAtLeastWiiR2()) {
+        if (dComIfGs_getPalLanguage() == 0) {
+            data_804BBBD4 = 2;
+        } else {
+            data_804BBBD4 = 0;
+        }
+    } else if (dusk::version::isRegionJpn()) {
+        data_804BBBD4 = 0;
+    } else {
+        data_804BBBD4 = 1;
+    }
+    #elif VERSION == VERSION_SHIELD_DEBUG
     if (dComIfGs_getPalLanguage() == 1) {
         data_804BBBD4 = 2;
     } else {

src/d/actor/d_a_midna.cpp

@@ -463,6 +463,23 @@ int daMidna_c::createHeap() {
     JKRReadIdxResource(mBckHeap[0].getBuffer(), mBckHeap[0].getBufferSize(), 0x1DC, dComIfGp_getAnmArchive());
     J3DAnmTransform* md_anm = (J3DAnmTransform*)J3DAnmLoaderDataBase::load(mBckHeap[0].getBuffer());
     modelData = (J3DModelData*)dComIfG_getObjectRes(l_arcName, 14);
+
+#if TARGET_PC
+    J3DTexture* tex = modelData->getTexture();
+    JUTNameTab* nametable = modelData->getTextureName();
+    if (tex != NULL && nametable != NULL) {
+        for (u16 i = 0; i < tex->getNum(); i++) {
+            const char* name = nametable->getName(i);
+            if (name != NULL && strcmp(name, "midona_eye") == 0) {
+                ResTIMG* timg = tex->getResTIMG(i);
+                timg->mipmapEnabled = false;
+                tex->loadGXTexObj(i);
+                break;
+            }
+        }
+    }
+#endif
+
     JUT_ASSERT(852, modelData != NULL);
     mpMorf = JKR_NEW mDoExt_McaMorfSO(modelData, &mMorfCB, NULL, md_anm, J3DFrameCtrl::EMode_LOOP, 1.0f, 0, -1, NULL, 0, 0x11000284);
     if (mpMorf == NULL || mpMorf->getModel() == NULL) {

src/d/actor/d_a_mirror.cpp

@@ -40,6 +40,7 @@ dMirror_packet_c::dMirror_packet_c() {
 void dMirror_packet_c::reset() {
 #if TARGET_PC
     mbReset = true;
+    mbHadEntry = false;
 #else
     mModelCount = 0;
 #endif
@@ -96,6 +97,9 @@ int dMirror_packet_c::entryModel(J3DModel* i_model) {
     }
 
     mModels[mModelCount++] = i_model;
+#if TARGET_PC
+    mbHadEntry = true;
+#endif
     return 1;
 }
 
@@ -624,6 +628,12 @@ int daMirror_c::draw() {
         mDoExt_modelUpdateDL(mpModel);
     }
 
+#if TARGET_PC
+    if (mPacket.mbReset && !mPacket.mbHadEntry) {
+        mPacket.mModelCount = 0;
+    }
+    mPacket.mbHadEntry = true;
+#endif
     dComIfGd_getOpaListBG()->entryImm(&mPacket, 0);
     return 1;
 }

src/d/actor/d_a_npc_ne.cpp

@@ -956,7 +956,7 @@ static void npc_ne_tame(npc_ne_class* i_this) {
         i_this->mpMorf->setPlaySpeed(i_this->mAnmSpeed);
 
             /* dSv_event_flag_c::F_0470 - Fishing Pond - Reserved for fishing */
-        if (dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[470])) {
+        if (IF_DUSK(dusk::getSettings().game.no2ndFishForCat) || dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[470])) {
             if (fpcEx_Search(s_fish_sub, _this) != NULL) {
                 i_this->mAction = npc_ne_class::ACT_HOME;
                 i_this->mMode = 10;
@@ -2948,8 +2948,7 @@ static int daNpc_Ne_Execute(npc_ne_class* i_this) {
 
     if (i_this->mWantsFish && (i_this->mCounter & 0xf) == 0) {
             /* dSv_event_flag_c::F_0470 - Fishing Pond - Reserved for fishing */
-        if (dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[470])
-                                    && i_this->mDistToTarget < 1500.0f) {
+        if ((IF_DUSK(dusk::getSettings().game.no2ndFishForCat) || dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[470])) && i_this->mDistToTarget < 1500.0f) {
             if (fopAcM_SearchByName(fpcNm_MG_ROD_e) != NULL) {
                 i_this->mNoFollow = false;
             } else {

src/d/actor/d_a_npc_toby.cpp

@@ -14,6 +14,7 @@
 #include "d/actor/d_a_obj_automata.h"
 #include "d/d_msg_object.h"
 #include "d/actor/d_a_obj_scannon.h"
+#include "dusk/frame_interpolation.h"
 #include <cstring>
 
 const daNpc_Toby_HIOParam daNpc_Toby_Param_c::m = {
@@ -1398,6 +1399,7 @@ int daNpc_Toby_c::cutRepairSCannon(int arg0) {
                 old.pos = current.pos;
                 setAngle(cM_deg2s(5.0f * f32(mPath.getArg0())));
                 mEventTimer = mPath.getArg2();
+                dusk::frame_interp::request_presentation_sync();
             }
         } else if (!mHide) {
             mHide = 1;

src/d/actor/d_a_obj_balloon.cpp

@@ -62,6 +62,16 @@ void daObj_Balloon_c::saveBestScore() {
     dComIfGp_setMessageCountNumber(m_balloon_score);
 }
 
+#if TARGET_PC
+static void minigameReset() {
+    // !@bug d_a_obj_balloon.rel unload used to zero these file-statics; with static linking they dangle across scenes.
+    m_combo_type = 0xFFFFFFFF;
+    m_combo_count = 0;
+    m_combo_next_score = 0;
+    m_balloon_score = 0;
+}
+#endif
+
 static u8 hio_set;
 
 static daObj_Balloon_HIO_c l_HIO;
@@ -246,6 +256,7 @@ int daObj_Balloon_c::create() {
         }
 
         if (!hio_set) {
+            IF_DUSK(minigameReset());
             mHIOInit = true;
             hio_set = true;
             l_HIO.field_0x04 = -1;

src/d/actor/d_a_obj_drop.cpp

@@ -265,8 +265,8 @@ int daObjDrop_c::modeParentWait() {
         mModeAction = 1;
 
 #if TARGET_PC
-        mModeTimer = dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 20 : 40;
-        if (dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0) {
+        mModeTimer = dusk::getSettings().game.fastTears ? 0 : 40;
+        if (dusk::getSettings().game.fastTears) {
             current.pos.y += 100.0f;
         } else {
             current.pos.y += 300.0f;
@@ -285,7 +285,7 @@ int daObjDrop_c::modeParentWait() {
     case 2:
         createBodyEffect();
 #if TARGET_PC
-        mModeTimer = dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 5 : 45;
+        mModeTimer = dusk::getSettings().game.fastTears ? 0 : 45;
 #else
         mModeTimer = 45;
 #endif
@@ -331,7 +331,7 @@ int daObjDrop_c::modeWait() {
     case 2:
     case 50:
         #if TARGET_PC
-        if (dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0) {
+        if (dusk::getSettings().game.fastTears) {
             f32 player_dist = current.pos.abs(daPy_getPlayerActorClass()->current.pos);
             f32 home_dist = current.pos.abs(home.pos);
 

src/d/actor/d_a_obj_klift00.cpp

@@ -11,6 +11,8 @@
 #include "d/d_bg_w.h"
 #include "d/d_cc_uty.h"
 #include "d/d_com_inf_game.h"
+#include "dusk/frame_interpolation.h"
+#include "dusk/settings.h"
 
 struct daObjKLift00_HIO_c : public mDoHIO_entry_c {
     daObjKLift00_HIO_c();
@@ -295,6 +297,11 @@ int daObjKLift00_c::Create() {
     if(getLock())
         mStopSwingingFrames = 5;
 
+#if TARGET_PC
+    mChainInterpPrevValid = false;
+    mChainInterpCurrValid = false;
+#endif
+
     return 1;
 }
 
@@ -436,6 +443,34 @@ int daObjKLift00_c::Execute(Mtx** i_mtx) {
     return 1;
 }
 
+#if TARGET_PC
+static void klift00_interp_callback(bool isSimFrame, void* pUserWork) {
+    static_cast<daObjKLift00_c*>(pUserWork)->onInterpCallback();
+}
+
+void daObjKLift00_c::onInterpCallback() {
+    if (!mChainInterpPrevValid || !mChainInterpCurrValid) {
+        return;
+    }
+
+    const f32 alpha = dusk::frame_interp::get_interpolation_step();
+    cXyz savedPositions[64];
+
+    for (int i = 0; i < mNumChains; i++) {
+        savedPositions[i] = mChainPositions[i].mCurrentPos;
+        const cXyz& p0 = mChainInterpPrev[i];
+        const cXyz& p1 = mChainInterpCurr[i];
+        mChainPositions[i].mCurrentPos = p0 + (p1 - p0) * alpha;
+    }
+
+    setMtx();
+
+    for (int i = 0; i < mNumChains; i++) {
+        mChainPositions[i].mCurrentPos = savedPositions[i];
+    }
+}
+#endif
+
 int daObjKLift00_c::Draw() {
     g_env_light.settingTevStruct(16, &current.pos, &tevStr);
     g_env_light.setLightTevColorType_MAJI(mpLiftPlatform, &tevStr);
@@ -457,6 +492,22 @@ int daObjKLift00_c::Draw() {
 
     dComIfGd_setList();
 
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFrameInterpolation) {
+        if (mChainInterpCurrValid) {
+            memcpy(mChainInterpPrev, mChainInterpCurr, mNumChains * sizeof(cXyz));
+            mChainInterpPrevValid = true;
+        }
+
+        for (int i = 0; i < mNumChains; i++) {
+            mChainInterpCurr[i] = mChainPositions[i].mCurrentPos;
+        }
+        
+        mChainInterpCurrValid = true;
+        dusk::frame_interp::add_interpolation_callback(&klift00_interp_callback, this);
+    }
+#endif
+
     return 1;
 }
 

src/d/actor/d_a_obj_lv8Lift.cpp

@@ -10,6 +10,10 @@
 #include "d/d_path.h"
 #include "d/d_bg_w.h"
 
+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
+
 daL8Lift_HIO_c::daL8Lift_HIO_c() {
     mStopDisappearTime = 30;
     mStartMoveTime = 60;
@@ -380,7 +384,44 @@ void daL8Lift_c::setNextPoint() {
     mCurrentPoint = next_point;
 }
 
+#if TARGET_PC
+void daL8Lift_interp_callback(bool isSimFrame, void* pUserWork) {
+    daL8Lift_c* lift = static_cast<daL8Lift_c*>(pUserWork);
+    if (lift == NULL || lift->mpModel == NULL) {
+        return;
+    }
+
+    g_env_light.settingTevStruct(0x10, &lift->current.pos, &lift->tevStr);
+    g_env_light.setLightTevColorType_MAJI(lift->mpModel, &lift->tevStr);
+
+    J3DModelData* modelData = lift->mpModel->getModelData();
+    J3DMaterial* materialp = modelData->getMaterialNodePointer(0);
+
+    if (materialp->getTexGenBlock()->getTexMtx(1) != NULL) {
+        J3DTexMtxInfo* mtx_info = &materialp->getTexGenBlock()->getTexMtx(1)->getTexMtxInfo();
+        if (mtx_info != NULL) {
+            Mtx m;
+            C_MTXLightOrtho(m, 100.0f, -100.0f, -100.0f, 100.0f, 1.0f, 1.0f, 0.0f, 0.0f);
+            mDoMtx_stack_c::XrotS(0x4000);
+            mDoMtx_stack_c::transM(-lift->current.pos.x, -lift->current.pos.y, -lift->current.pos.z);
+            cMtx_concat(m, mDoMtx_stack_c::get(), mtx_info->mEffectMtx);
+        }
+    }
+
+    lift->mBtk.entry(modelData);
+
+    J3DGXColor* color = materialp->getTevKColor(1);
+    color->r = l_HIO.mColorR;
+    color->g = l_HIO.mColorG;
+    color->b = l_HIO.mColorB;
+}
+#endif
+
 int daL8Lift_c::Draw() {
+#if TARGET_PC
+    dusk::frame_interp::add_interpolation_callback(&daL8Lift_interp_callback, this);
+#endif
+
     g_env_light.settingTevStruct(16, &current.pos, &tevStr);
     g_env_light.setLightTevColorType_MAJI(mpModel, &tevStr);
     J3DModelData* modelData = mpModel->getModelData();

src/d/actor/d_a_obj_lv8OptiLift.cpp

@@ -11,6 +11,10 @@
 #include "d/d_com_inf_game.h"
 #include "d/d_path.h"
 
+#if TARGET_PC
+#include "dusk/frame_interpolation.h"
+#endif
+
 daOptiLift_HIO_c::daOptiLift_HIO_c() {
     mStopDisappearTime = 30;
     mStartMoveTime = 30;
@@ -412,7 +416,44 @@ void daOptiLift_c::setNextPoint() {
     mCurrentPoint = next_point;
 }
 
+#if TARGET_PC
+static void daOptiLift_interp_callback(bool isSimFrame, void* pUserWork) {
+    daOptiLift_c* lift = static_cast<daOptiLift_c*>(pUserWork);
+    if (lift == NULL || lift->mpModel == NULL) {
+        return;
+    }
+
+    g_env_light.settingTevStruct(0x10, &lift->current.pos, &lift->tevStr);
+    g_env_light.setLightTevColorType_MAJI(lift->mpModel, &lift->tevStr);
+
+    J3DModelData* modelData = lift->mpModel->getModelData();
+    J3DMaterial* materialp = modelData->getMaterialNodePointer(0);
+
+    if (materialp->getTexGenBlock()->getTexMtx(1) != NULL) {
+        J3DTexMtxInfo* mtx_info = &materialp->getTexGenBlock()->getTexMtx(1)->getTexMtxInfo();
+        if (mtx_info != NULL) {
+            Mtx m;
+            C_MTXLightOrtho(m, 100.0f, -100.0f, -100.0f, 100.0f, 1.0f, 1.0f, 0.0f, 0.0f);
+            mDoMtx_stack_c::XrotS(0x4000);
+            mDoMtx_stack_c::transM(-lift->current.pos.x, -lift->current.pos.y, -lift->current.pos.z);
+            cMtx_concat(m, mDoMtx_stack_c::get(), mtx_info->mEffectMtx);
+        }
+    }
+
+    lift->mBtk.entry(modelData);
+
+    J3DGXColor* color = materialp->getTevKColor(1);
+    color->r = l_HIO.mColorR;
+    color->g = l_HIO.mColorG;
+    color->b = l_HIO.mColorB;
+}
+#endif
+
 int daOptiLift_c::Draw() {
+#if TARGET_PC
+    dusk::frame_interp::add_interpolation_callback(&daOptiLift_interp_callback, this);
+#endif
+
     g_env_light.settingTevStruct(0x10, &current.pos, &tevStr);
     g_env_light.setLightTevColorType_MAJI(mpModel, &tevStr);
 

src/d/actor/d_a_player.cpp

@@ -369,18 +369,17 @@ JKRHeap* daPy_anmHeap_c::setAnimeHeap() {
 #if !PLATFORM_WII
 #if TARGET_PC
 #include "dusk/dvd_asset.hpp"
+using GameVersion = dusk::version::GameVersion;
 static const u8* l_sightDL_get() { 
     static u8 buf[0x89];
     static bool _ = (
         dusk::LoadDolAsset(
             buf,
-            #if VERSION == VERSION_GCN_PAL
-            0x803BBDA0,
-            #elif VERSION == VERSION_GCN_JPN
-            0x803B4220,
-            #elif VERSION == VERSION_GCN_USA
-            0x803BA0C0,
-            #endif
+{
+            {GameVersion::GcnUsa, 0x803BA0C0},
+            {GameVersion::GcnPal, 0x803BBDA0},
+            {GameVersion::GcnJpn, 0x803B4220}
+            },
             0x89
         ),
         true

src/d/actor/d_a_title.cpp

@@ -1,21 +1,22 @@
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
+#include "JSystem/J2DGraph/J2DScreen.h"
+#include "JSystem/J2DGraph/J2DTextBox.h"
+#include "JSystem/JKernel/JKRExpHeap.h"
+#include "JSystem/JKernel/JKRMemArchive.h"
 #include "d/actor/d_a_title.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_demo.h"
+#include "d/d_menu_collect.h"
+#include "d/d_pane_class_alpha.h"
 #include "d/d_s_logo.h"
 #include "d/d_s_play.h"
-#include "d/d_demo.h"
-#include "d/d_pane_class_alpha.h"
-#include "d/d_menu_collect.h"
+#include "dusk/version.hpp"
+#include "f_op/f_op_msg_mng.h"
+#include "f_op/f_op_overlap_mng.h"
+#include "f_op/f_op_scene_mng.h"
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_controller_pad.h"
-#include "d/d_com_inf_game.h"
-#include "JSystem/JKernel/JKRExpHeap.h"
-#include "f_op/f_op_overlap_mng.h"
-#include "f_op/f_op_msg_mng.h"
-#include "f_op/f_op_scene_mng.h"
-#include "JSystem/J2DGraph/J2DScreen.h"
-#include "JSystem/JKernel/JKRMemArchive.h"
-#include "JSystem/J2DGraph/J2DTextBox.h"
 #include "m_Do/m_Do_graphic.h"
 
 #ifdef TARGET_PC
@@ -49,7 +50,10 @@ static u8 const lit_3772[12] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-#if VERSION == VERSION_GCN_PAL
+#if TARGET_PC
+using namespace dusk::version;
+#define l_arcName versionSelect<const char*>({{GameVersion::GcnPal, "TitlePal"}}, "Title")
+#elif VERSION == VERSION_GCN_PAL
 static char const l_arcName[] = "TitlePal";
 #else
 static char const l_arcName[] = "Title";
@@ -59,7 +63,7 @@ daTit_HIO_c::daTit_HIO_c() {
     mPSScaleX = 1.0f;
     mPSScaleY = 1.0f;
 
-    #if VERSION == VERSION_GCN_PAL
+    #if TARGET_PC || VERSION == VERSION_GCN_PAL
     switch (OSGetLanguage()) {
     case OS_LANGUAGE_ENGLISH:
     case OS_LANGUAGE_GERMAN:

src/d/actor/d_flower.inc

@@ -7,17 +7,13 @@
 
 #include "dusk/frame_interpolation.h"
 
-#if TARGET_PC
-const u16 l_J_Ohana00_64TEX__width = 64;
-const u16 l_J_Ohana00_64TEX__height = 64;
-#else
 const u16 l_J_Ohana00_64TEX__width = 63;
 const u16 l_J_Ohana00_64TEX__height = 63;
-#endif
 
 #if TARGET_PC
 #include "dusk/dvd_asset.hpp"
-static u8* l_J_Ohana00_64TEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9060, 0x800), true); return buf; }
+using GameVersion = dusk::version::GameVersion;
+static u8* l_J_Ohana00_64TEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9060}, {GameVersion::GcnPal, 0x9060}}, 0x800), true); return buf; }
 #define l_J_Ohana00_64TEX (l_J_Ohana00_64TEX_get())
 #else
 #include "assets/l_J_Ohana00_64TEX.h"
@@ -113,10 +109,12 @@ static u8 l_flowerTexCoord[] = {
     0x3E, 0xA7, 0x72, 0xD6, 0xBD, 0x2F, 0x46, 0xAA};
 
 #if TARGET_PC
-static u8* l_J_hana00DL_get()   { static u8 buf[0x150]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9D20, 0x150), true); return buf; }
-static u8* l_J_hana00_cDL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9E80, 0xDE),  true); return buf; }
-static u8* l_matDL_get()        { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9F60, 0x99),  true); return buf; }
-static u8* l_matLight4DL_get()  { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xA000, 0x99),  true); return buf; }
+using GameVersion = dusk::version::GameVersion;
+
+static u8* l_J_hana00DL_get()   { static u8 buf[0x150]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9D20}, {GameVersion::GcnPal, 0x9D20}}, 0x150), true); return buf; }
+static u8* l_J_hana00_cDL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9E80}, {GameVersion::GcnPal, 0x9E80}}, 0xDE),  true); return buf; }
+static u8* l_matDL_get()        { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9F60}, {GameVersion::GcnPal, 0x9F60}}, 0x99),  true); return buf; }
+static u8* l_matLight4DL_get()  { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xA000}, {GameVersion::GcnPal, 0xA000}}, 0x99),  true); return buf; }
 #define l_J_hana00DL   (l_J_hana00DL_get())
 #define l_J_hana00_cDL (l_J_hana00_cDL_get())
 #define l_matDL        (l_matDL_get())
@@ -133,16 +131,12 @@ l_matDL__d_a_grass(l_J_Ohana00_64TEX)
 l_matLight4DL(l_J_Ohana00_64TEX)
 #endif
 
-#if TARGET_PC
-const u16 l_J_Ohana01_64128_0419TEX__width = 64;
-const u16 l_J_Ohana01_64128_0419TEX__height = 128;
-#else
 const u16 l_J_Ohana01_64128_0419TEX__width = 63;
 const u16 l_J_Ohana01_64128_0419TEX__height = 127;
-#endif
 
 #if TARGET_PC
-static u8* l_J_Ohana01_64128_0419TEX_get() { static u8 buf[0x1000]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xA0A0, 0x1000), true); return buf; }
+using GameVersion = dusk::version::GameVersion;
+static u8* l_J_Ohana01_64128_0419TEX_get() { static u8 buf[0x1000]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xA0A0}, {GameVersion::GcnPal, 0xA0A0}}, 0x1000), true); return buf; }
 #define l_J_Ohana01_64128_0419TEX (l_J_Ohana01_64128_0419TEX_get())
 #else
 #include "assets/l_J_Ohana01_64128_0419TEX.h"
@@ -274,11 +268,13 @@ static u8 l_flowerTexCoord2[] = {
     0x40, 0x1B, 0x7D, 0x52, 0x3F, 0x80, 0x3F, 0x79, 0x40, 0x1B, 0x7D, 0x52, 0x3F, 0x51, 0x10, 0x6F};
 
 #if TARGET_PC
-static u8* l_J_hana01DL_get()      { static u8 buf[0x138]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xB7C0, 0x138), true); return buf; }
-static u8* l_J_hana01_c_00DL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xB900, 0xDE),  true); return buf; }
-static u8* l_J_hana01_c_01DL_get() { static u8 buf[0x128]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xB9E0, 0x128), true); return buf; }
-static u8* l_mat2DL_get()          { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xBB20, 0x99),  true); return buf; }
-static u8* l_mat2Light4DL_get()    { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xBBC0, 0x99),  true); return buf; }
+using GameVersion = dusk::version::GameVersion;
+
+static u8* l_J_hana01DL_get()      { static u8 buf[0x138]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xB7C0}, {GameVersion::GcnPal, 0xB7C0}}, 0x138), true); return buf; }
+static u8* l_J_hana01_c_00DL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xB900}, {GameVersion::GcnPal, 0xB900}}, 0xDE),  true); return buf; }
+static u8* l_J_hana01_c_01DL_get() { static u8 buf[0x128]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xB9E0}, {GameVersion::GcnPal, 0xB9E0}}, 0x128), true); return buf; }
+static u8* l_mat2DL_get()          { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xBB20}, {GameVersion::GcnPal, 0xBB20}}, 0x99),  true); return buf; }
+static u8* l_mat2Light4DL_get()    { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xBBC0}, {GameVersion::GcnPal, 0xBBC0}}, 0x99),  true); return buf; }
 #define l_J_hana01DL      (l_J_hana01DL_get())
 #define l_J_hana01_c_00DL (l_J_hana01_c_00DL_get())
 #define l_J_hana01_c_01DL (l_J_hana01_c_01DL_get())
@@ -586,11 +582,11 @@ dFlower_packet_c::dFlower_packet_c() {
 
 #if TARGET_PC
     GXInitTexObj(&mTexObj_l_J_Ohana00_64TEX, l_J_Ohana00_64TEX,
-        l_J_Ohana00_64TEX__width, l_J_Ohana00_64TEX__height, GX_TF_CMPR, GX_MIRROR, GX_MIRROR, GX_FALSE
+        l_J_Ohana00_64TEX__width + 1, l_J_Ohana00_64TEX__height + 1, GX_TF_CMPR, GX_MIRROR, GX_MIRROR, GX_FALSE
     );
 
     GXInitTexObj(&mTexObj_l_J_Ohana01_64128_0419TEX, l_J_Ohana01_64128_0419TEX,
-        l_J_Ohana01_64128_0419TEX__width, l_J_Ohana01_64128_0419TEX__height, GX_TF_CMPR, GX_MIRROR, GX_MIRROR, GX_FALSE
+        l_J_Ohana01_64128_0419TEX__width + 1, l_J_Ohana01_64128_0419TEX__height + 1, GX_TF_CMPR, GX_MIRROR, GX_MIRROR, GX_FALSE
     );
 #endif
 
@@ -789,6 +785,10 @@ void dFlower_packet_c::draw() {
 
                 GXColor sp28;
 
+                #if AVOID_UB
+                sp28 = {1, 1, 1, 1};
+                #endif
+
                 //u8 sp26, sp25, sp24;
                 GXColor sp24;
                 sp24.r = -0.4f * temp_r29->AmbCol.r * var_f29;

src/d/actor/d_grass.inc

@@ -20,8 +20,9 @@ const u16 l_M_kusa05_RGBATEX__height = 31;
 
 #if TARGET_PC
 #include "dusk/dvd_asset.hpp"
-static u8* l_M_kusa05_RGBATEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x7680, 0x800), true); return buf; }
-static u8* l_M_Hijiki00TEX_get()    { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x7E80, 0x800), true); return buf; }
+using GameVersion = dusk::version::GameVersion;
+static u8* l_M_kusa05_RGBATEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x7680}, {GameVersion::GcnPal, 0x7680}}, 0x800), true); return buf; }
+static u8* l_M_Hijiki00TEX_get()    { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x7E80}, {GameVersion::GcnPal, 0x7E80}}, 0x800), true); return buf; }
 #define l_M_kusa05_RGBATEX (l_M_kusa05_RGBATEX_get())
 #define l_M_Hijiki00TEX    (l_M_Hijiki00TEX_get())
 #else
@@ -113,12 +114,14 @@ static u8 l_texCoord[160] = {
 };
 
 #if TARGET_PC
-static u8* l_M_Kusa_9qDL_get()     { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8B00, 0xCB),  true); return buf; }
-static u8* l_M_Kusa_9q_cDL_get()   { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8BE0, 0xCB),  true); return buf; }
-static u8* l_M_TenGusaDL_get()     { static u8 buf[0xD4]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8CC0, 0xD4),  true); return buf; }
-static u8* l_Tengusa_matDL_get()   { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8DA0, 0xA8),  true); return buf; }
-static u8* l_kusa9q_matDL_get()    { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8E60, 0xA8),  true); return buf; }
-static u8* l_kusa9q_l4_matDL_get() { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8F20, 0xA8),  true); return buf; }
+using GameVersion = dusk::version::GameVersion;
+
+static u8* l_M_Kusa_9qDL_get()     { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8B00}, {GameVersion::GcnPal, 0x8B00}}, 0xCB),  true); return buf; }
+static u8* l_M_Kusa_9q_cDL_get()   { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8BE0}, {GameVersion::GcnPal, 0x8BE0}}, 0xCB),  true); return buf; }
+static u8* l_M_TenGusaDL_get()     { static u8 buf[0xD4]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8CC0}, {GameVersion::GcnPal, 0x8CC0}}, 0xD4),  true); return buf; }
+static u8* l_Tengusa_matDL_get()   { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8DA0}, {GameVersion::GcnPal, 0x8DA0}}, 0xA8),  true); return buf; }
+static u8* l_kusa9q_matDL_get()    { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8E60}, {GameVersion::GcnPal, 0x8E60}}, 0xA8),  true); return buf; }
+static u8* l_kusa9q_l4_matDL_get() { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8F20}, {GameVersion::GcnPal, 0x8F20}}, 0xA8),  true); return buf; }
 #define l_M_Kusa_9qDL     (l_M_Kusa_9qDL_get())
 #define l_M_Kusa_9q_cDL   (l_M_Kusa_9q_cDL_get())
 #define l_M_TenGusaDL     (l_M_TenGusaDL_get())
@@ -491,11 +494,11 @@ dGrass_packet_c::dGrass_packet_c() {
 
 #if TARGET_PC
     GXInitTexObj(&mTexObj_l_M_kusa05_RGBATEX, l_M_kusa05_RGBATEX,
-        l_M_kusa05_RGBATEX__width, l_M_kusa05_RGBATEX__height, GX_TF_RGB5A3, GX_REPEAT, GX_CLAMP, GX_FALSE
+        l_M_kusa05_RGBATEX__width + 1, l_M_kusa05_RGBATEX__height + 1, GX_TF_RGB5A3, GX_REPEAT, GX_CLAMP, GX_FALSE
     );
 
     GXInitTexObj(&mTexObj_l_M_Hijiki00TEX, l_M_Hijiki00TEX,
-        l_M_Hijiki00TEX__width, l_M_Hijiki00TEX__height, GX_TF_RGB5A3, GX_REPEAT, GX_CLAMP, GX_FALSE
+        l_M_Hijiki00TEX__width + 1, l_M_Hijiki00TEX__height + 1, GX_TF_RGB5A3, GX_REPEAT, GX_CLAMP, GX_FALSE
     );
 #endif
 
@@ -643,18 +646,14 @@ void dGrass_packet_c::draw() {
             }
 
             if (var_r29->field_0x05 <= 3 || var_r29->field_0x05 >= 10) {
-#if TARGET_PC
-                GXLoadTexObj(&mTexObj_l_M_kusa05_RGBATEX, GX_TEXMAP0);
-#endif
+                IF_DUSK(GXLoadTexObj(&mTexObj_l_M_kusa05_RGBATEX, GX_TEXMAP0));
                 if (sp48 <= 3) {
                     GXCallDisplayList(mp_kusa9q_14_DL, m_kusa9q_DL_14_size);
                 } else {
                     GXCallDisplayList(mp_kusa9q_DL, m_kusa9q_DL_size);
                 }
             } else {
-#if TARGET_PC
-                GXLoadTexObj(&mTexObj_l_M_Hijiki00TEX, GX_TEXMAP0);
-#endif
+                IF_DUSK(GXLoadTexObj(&mTexObj_l_M_Hijiki00TEX, GX_TEXMAP0));
                 GXCallDisplayList(l_Tengusa_matDL, 0xA0);
             }
 
@@ -680,12 +679,14 @@ void dGrass_packet_c::draw() {
 
             while (var_r29 != NULL) {
                 if (var_r29->field_0x05 <= 3 || var_r29->field_0x05 >= 10) {
+                    IF_DUSK(GXLoadTexObj(&mTexObj_l_M_kusa05_RGBATEX, GX_TEXMAP0));
                     if (sp48 <= 2) {
                         GXCallDisplayList(mp_kusa9q_14_DL, m_kusa9q_DL_14_size);
                     } else {
                         GXCallDisplayList(mp_kusa9q_DL, m_kusa9q_DL_size);
                     }
                 } else {
+                    IF_DUSK(GXLoadTexObj(&mTexObj_l_M_Hijiki00TEX, GX_TEXMAP0));
                     GXCallDisplayList(l_Tengusa_matDL, 0xA0);
                 }
 

src/d/d_bright_check.cpp

@@ -9,6 +9,8 @@
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/J2DGraph/J2DTextBox.h"
 #include "d/d_msg_string.h"
+#include "dusk/livesplit.h"
+#include "dusk/imgui/ImGuiConsole.hpp"
 #include "m_Do/m_Do_controller_pad.h"
 
 dBrightCheck_c::dBrightCheck_c(JKRArchive* i_archive) {
@@ -138,6 +140,17 @@ void dBrightCheck_c::modeWait() {}
 void dBrightCheck_c::modeMove() {
     if (mDoCPd_c::getTrigA(PAD_1) || mDoCPd_c::getTrigStart(PAD_1)) {
         mDoAud_seStart(Z2SE_ENTER_GAME, NULL, 0, 0);
+#ifdef TARGET_PC
+        dusk::speedrun::start();
+
+        if (dusk::getSettings().game.speedrunMode && !dusk::getSettings().game.hideTvSettingsScreen) {
+            // start a new run if a run isn't already in progress
+            if (!dusk::m_speedrunInfo.m_isRunStarted) {
+                dusk::ImGuiMenuGame::resetForSpeedrunMode();
+                dusk::m_speedrunInfo.startRun();
+            }
+        }
+#endif
         mCompleteCheck = true;
         mMode = MODE_WAIT_e;
     }

src/d/d_camera.cpp

@@ -794,6 +794,9 @@ void dCamera_c::updatePad() {
 
     if (mTriggerLeftLast > mCamSetup.ManualEndVal()) {
         if (mLockLActive == 0) {
+            #if TARGET_PC
+            mCamParam.mManualMode = 0;
+            #endif
             mLockLJustActivated = 1;
         } else {
             mLockLJustActivated = 0;
@@ -833,6 +836,12 @@ void dCamera_c::updatePad() {
     mHoldB = mDoCPd_c::getHoldB(mPadID) ? true : false;
     mTrigB = mDoCPd_c::getTrigB(mPadID) ? true : false;
 
+    #if TARGET_PC
+    if (mCamParam.mManualMode) {
+        return;
+    }
+    #endif
+
     bool sp6B = true;
     bool sp6C = true;
     int temp1;
@@ -1166,7 +1175,14 @@ bool dCamera_c::Run() {
             clrFlag(0x200000);
         }
     } else {
+        #if TARGET_PC
+        if (mCamParam.Algorythmn(mCamStyle) != 1) {
+            mCamParam.mManualMode = 0;
+        }
+        #endif
+
         sp0F = (this->*engine_tbl[mCamParam.Algorythmn(mCamStyle)])(mCamStyle);
+
         field_0x170++;
         field_0x160++;
         mCurCamStyleTimer++;
@@ -1471,7 +1487,7 @@ void dCamera_c::CalcTrimSize() {
             mTrimHeight += -mTrimHeight * 0.25f;
             break;
         case 2:
-#if WIDESCREEN_SUPPORT
+#if !TARGET_PC && WIDESCREEN_SUPPORT
             if (mDoGph_gInf_c::isWide() && mDoGph_gInf_c::isWideZoom()) {
                 mTrimHeight += (16.0f - mTrimHeight) * 0.25f;
                 break;
@@ -3078,6 +3094,7 @@ bool dCamera_c::bumpCheck(u32 i_flags) {
                     } else {
                         field_0x968 *= mMonitor.field_0xc / 5.0f;
                     }
+
                     f32 tmp = field_0x96c * (mIsWolf == 1 ? 30.0f : 30.0f);
                     center += vec3.norm() * (tmp * globe.V().Sin());
                     cSGlobe globe2(vec2 - center);
@@ -4182,6 +4199,11 @@ bool dCamera_c::chaseCamera(s32 param_0) {
         chase->field_0x8 -= chase->field_0xc;
         chase->field_0x8c = 0;
         chase->field_0x90 = false;
+
+        #if TARGET_PC
+        freeCamera();
+        #endif
+
         return true;
     }
 
@@ -4604,6 +4626,7 @@ bool dCamera_c::chaseCamera(s32 param_0) {
 
     sp110 = mViewCache.mDirection.R();
     mViewCache.mDirection.R(mViewCache.mDirection.R() + (fVar55 - mViewCache.mDirection.R()) * chase->field_0x74);
+
     chase->field_0x64 = mViewCache.mCenter + mViewCache.mDirection.Xyz();
     mViewCache.mEye = chase->field_0x64;
 
@@ -4618,6 +4641,11 @@ bool dCamera_c::chaseCamera(s32 param_0) {
     if (chase->field_0x1c != 0) {
         chase->field_0x1c--;
     }
+
+    #if TARGET_PC
+    freeCamera();
+    #endif
+
     return true;
 }
 
@@ -7065,10 +7093,12 @@ bool dCamera_c::subjectCamera(s32 param_0) {
     cXyz sp1E0(val0, val2, val1);
 
 #if TARGET_PC
-    f32 aspect = mDoGph_gInf_c::getAspect();
-    f32 baseAspect = FB_WIDTH / FB_HEIGHT;
-    if (aspect > baseAspect) {
-        sp1E0.z += (aspect - baseAspect) * 4;
+    if (sp13) {
+        f32 aspect = mDoGph_gInf_c::getAspect();
+        f32 baseAspect = FB_WIDTH / FB_HEIGHT;
+        if (aspect > baseAspect) {
+            sp1E0.z += (aspect - baseAspect) * 4;
+        }
     }
 #endif
 
@@ -7444,6 +7474,53 @@ bool dCamera_c::test2Camera(s32 param_0) {
     return false;
 }
 
+#if TARGET_PC
+bool dCamera_c::freeCamera() {
+    if (dusk::getSettings().game.freeCamera && mGear == 1) {
+        mGear = 0;
+    }
+
+    if (!dusk::getSettings().game.freeCamera || mCamStyle == 70)
+    {
+        mCamParam.mManualMode = 0;
+        return false;
+    }
+
+    if (!mCamParam.mManualMode) {
+        mCamParam.freeXAngle = mViewCache.mDirection.mAzimuth.Degree();
+        mCamParam.freeYAngle = mViewCache.mDirection.mInclination.Degree();
+    }
+
+    cXyz camMovement = {mPadInfo.mCStick.mLastPosX, mPadInfo.mCStick.mLastPosY, 0.0f};
+    f32 magnitude = sqrt(mPadInfo.mCStick.mLastPosX * mPadInfo.mCStick.mLastPosX + mPadInfo.mCStick.mLastPosY * mPadInfo.mCStick.mLastPosY);
+
+    if (mPadInfo.mCStick.mLastPosX != 0 || mPadInfo.mCStick.mLastPosY != 0) {
+        mCamParam.mManualMode = 1;
+        camMovement = camMovement.normalize();
+        camMovement.y *= dusk::getSettings().game.invertCameraYAxis ? 1.0f : -1.0f;
+        mCamParam.freeXAngle += camMovement.x * magnitude * dusk::getSettings().game.freeCameraSensitivity * 5.0f;
+        mCamParam.freeYAngle += camMovement.y * magnitude * dusk::getSettings().game.freeCameraSensitivity * 5.0f;
+    }
+
+    fopAc_ac_c* player = dComIfGp_getPlayer(0);
+    if (!mCamParam.mManualMode || player == nullptr) {
+        return false;
+    }
+
+    f32 minYAngle = -30.0f;
+    f32 maxAngle = 50.0f;
+
+    mCamParam.freeYAngle = std::clamp(mCamParam.freeYAngle, minYAngle, maxAngle);
+    mViewCache.mDirection.mAzimuth = cSAngle(mCamParam.freeXAngle);
+    mViewCache.mDirection.mInclination = cSAngle(mCamParam.freeYAngle);
+
+    cXyz finalEye = mViewCache.mCenter + mViewCache.mDirection.Xyz();
+    mViewCache.mEye = finalEye;
+
+    return true;
+}
+#endif
+
 bool dCamera_c::towerCamera(s32 param_0) {
     cSAngle stack_444 = cSAngle(mCamSetup.ChargeLatitude());
     f32 sp224 = mCamSetup.ChargeBRatio();
@@ -11083,12 +11160,25 @@ static int camera_draw(camera_process_class* i_this) {
     }
 #endif
 
-    int trim_height = body->TrimHeight();
-
 #if TARGET_PC
+    auto trim_height = body->TrimHeight();
+
+    if (mDoGph_gInf_c::isWideZoom()) {
+        const auto target_ar = FB_WIDTH / (FB_HEIGHT - trim_height * 2.0f);
+        const auto current_ar = mDoGph_gInf_c::m_safeWidthF / mDoGph_gInf_c::m_safeHeightF;
+
+        if (current_ar < target_ar) {
+            trim_height = FB_HEIGHT / 2.0f * (1.0f - current_ar / target_ar);
+        } else {
+            trim_height = 0.0f;
+        }
+    }
+
     trim_height *= viewport->height / FB_HEIGHT;
     window->setScissor(0.0f, trim_height, viewport->width, viewport->height - trim_height * 2.0f);
 #else
+    int trim_height = body->TrimHeight();
+
     window->setScissor(0.0f, trim_height, FB_WIDTH, FB_HEIGHT - trim_height * 2.0f);
 #endif
 

src/d/d_drawlist.cpp

@@ -22,6 +22,10 @@
 #include "dusk/frame_interpolation.h"
 #include "dusk/gx_helper.h"
 #include "dusk/logging.h"
+
+static const void* getInterpKey(const void* base, int idx) {
+    return reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(base) ^ idx);
+}
 #endif
 
 class dDlst_2Dm_c {
@@ -1062,7 +1066,15 @@ void dDlst_shadowReal_c::reset() {
 }
 
 void dDlst_shadowReal_c::imageDraw(Mtx param_0) {
-    GXSetProjection(mRenderProjMtx, GX_ORTHOGRAPHIC);
+#ifdef TARGET_PC
+    Mtx render_proj_mtx;
+    if (dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 2), render_proj_mtx)) {
+        GXSetProjection(render_proj_mtx, GX_ORTHOGRAPHIC);
+    } else
+#endif
+    {
+        GXSetProjection(mRenderProjMtx, GX_ORTHOGRAPHIC);
+    }
     JUT_ASSERT(1916, mModelNum);
     J3DModelData* model_data;
     J3DModel** models = mpModels;
@@ -1075,7 +1087,15 @@ void dDlst_shadowReal_c::imageDraw(Mtx param_0) {
         for (u16 j = 0; j < model_data->getShapeNum(); j++) {
             if (!model_data->getShapeNodePointer(j)->checkFlag(1)) {
                 shape_pkt = (*models)->getShapePacket(j);
-                shape_pkt->setBaseMtxPtr(&mViewMtx);
+#ifdef TARGET_PC
+                Mtx view_mtx;
+                if (dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 1), view_mtx)) {
+                    shape_pkt->setBaseMtxPtr(&view_mtx);
+                } else
+#endif
+                {
+                    shape_pkt->setBaseMtxPtr(&mViewMtx);
+                }
                 shape_pkt->drawFast();
                 shape_pkt->setBaseMtxPtr((Mtx*)param_0);
             }
@@ -1096,7 +1116,18 @@ void dDlst_shadowReal_c::draw() {
     GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
     GXSetCurrentMtx(GX_PNMTX0);
-    GXLoadTexMtxImm(mReceiverProjMtx, GX_TEXMTX0, GX_MTX3x4);
+#ifdef TARGET_PC
+    Mtx view_mtx, recv_proj_mtx;
+    const auto have_view_mtx = dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 1), view_mtx);
+    const auto have_recv_proj_mtx = dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 3), recv_proj_mtx);
+    if (have_view_mtx && have_recv_proj_mtx) {
+        cMtx_concat(recv_proj_mtx, view_mtx, recv_proj_mtx);
+        GXLoadTexMtxImm(recv_proj_mtx, GX_TEXMTX0, GX_MTX3x4);
+    } else
+#endif
+    {
+        GXLoadTexMtxImm(mReceiverProjMtx, GX_TEXMTX0, GX_MTX3x4);
+    }
     mShadowRealPoly.draw();
 }
 
@@ -1253,6 +1284,13 @@ u8 dDlst_shadowReal_c::setShadowRealMtx(cXyz* param_0, cXyz* param_1, f32 param_
     cMtx_lookAt(mViewMtx, &local_64, param_1, 0);
     C_MTXOrtho(mRenderProjMtx, param_2, -param_2, -param_2, param_2, 1.0f, 10000.0f);
     C_MTXLightOrtho(mReceiverProjMtx, param_2, -param_2, -param_2, param_2, 0.5f, -0.5f, 0.5f, 0.5f);
+    
+#ifdef TARGET_PC
+    const auto keybase = mpModels[0];
+    dusk::frame_interp::record_final_mtx(mViewMtx, getInterpKey(keybase, 1));
+    dusk::frame_interp::record_final_mtx(mRenderProjMtx, getInterpKey(keybase, 2));
+    dusk::frame_interp::record_final_mtx(mReceiverProjMtx, getInterpKey(keybase, 3));
+#endif
     cMtx_concat(mReceiverProjMtx, mViewMtx, mReceiverProjMtx);
     return r29;
 }
@@ -1277,6 +1315,10 @@ u32 dDlst_shadowReal_c::set(u32 i_key, J3DModel* i_model, cXyz* param_2, f32 par
             }
         }
 
+#ifdef TARGET_PC
+        // provide a stable key for interpolation
+        mpModels[0] = i_model;
+#endif
         field_0x1 = setShadowRealMtx(&sp60, param_2, param_3, param_4, param_7, param_5);
 
         if (!field_0x1) {
@@ -1370,12 +1412,6 @@ void dDlst_shadowSimple_c::draw() {
     GXCallDisplayList(l_shadowVolumeDL, 0x40);
 }
 
-#if TARGET_PC
-static const void* getInterpKey(const void* base, int idx) {
-    return reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(base) ^ idx);
-}
-#endif
-
 void dDlst_shadowSimple_c::set(cXyz* param_0, f32 param_1, f32 param_2, cXyz* param_3,
                                    s16 param_4, f32 param_5, TGXTexObj* param_6) {
     if (param_5 < 0.0f) {

src/d/d_file_sel_info.cpp

@@ -14,6 +14,8 @@
 #include <cstdio>
 #include <cstring>
 
+#include "dusk/version.hpp"
+
 dFile_info_c::dFile_info_c(JKRArchive* i_archive, u8 param_1) {
     mArchive = i_archive;
     field_0x22 = param_1;
@@ -169,7 +171,18 @@ void dFile_info_c::setSaveDate(dSv_save_c* i_savedata) {
     OSCalendarTime time;
     OSTicksToCalendarTime(i_savedata->getPlayer().getPlayerStatusB().getDateIpl(), &time);
 
-    #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+    #if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        sprintf(mSaveDate, "%d.%02d.%02d %02d:%02d", time.year, time.mon + 1, time.mday,
+            time.hour, time.min);
+    } else if (dusk::version::isRegionPal() && dComIfGs_getPalLanguage() != dSv_player_config_c::LANGUAGE_ENGLISH) {
+        sprintf(mSaveDate, "%02d/%02d/%d %02d:%02d", time.mday, time.mon + 1, time.year, time.hour,
+            time.min);
+    } else {
+        sprintf(mSaveDate, "%02d/%02d/%d %02d:%02d", time.mon + 1, time.mday, time.year, time.hour,
+            time.min);
+    }
+    #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     sprintf(mSaveDate, "%d.%02d.%02d %02d:%02d", time.year, time.mon + 1, time.mday,
             time.hour, time.min);
     #elif VERSION == VERSION_GCN_PAL

src/d/d_kankyo_rain.cpp

@@ -5962,6 +5962,8 @@ static void dKyr_evil_draw2(Mtx drawMtx, u8** tex) {
     fopAc_ac_c* player = dComIfGp_getPlayer(0);
 
     if (evil_packet != NULL) {
+        IF_DUSK(GXPushDebugGroup("dKyr_evil_draw2"));
+
         j3dSys.reinitGX();
         if (dComIfGd_getView() != NULL) {
             MTXInverse(dComIfGd_getView()->viewMtxNoTrans, camMtx);
@@ -5986,7 +5988,12 @@ static void dKyr_evil_draw2(Mtx drawMtx, u8** tex) {
         TGXTexObj texobj;
         dKyr_set_btitex(&texobj, (ResTIMG*)tex[1]);
 
-        rot += 0.7f;
+#if TARGET_PC
+        if (dusk::frame_interp::get_ui_tick_pending())
+#endif
+        {
+            rot += 0.7f;
+        }
         MTXRotRad(rotMtx, 'Z', DEG_TO_RAD(rot));
         MTXConcat(camMtx, rotMtx, camMtx);
 
@@ -6037,7 +6044,14 @@ static void dKyr_evil_draw2(Mtx drawMtx, u8** tex) {
                         sp34.y = 80.0f;
                         sp34.z = 80.0f;
                         mDoLib_project(&sp7C, &proj);
-                        if (!(proj.x > -sp34.x) || !(proj.x < (FB_WIDTH + sp34.x)) ||
+#if TARGET_PC
+                        f32 cullMinX = mDoGph_gInf_c::getSafeMinXF() - sp34.x;
+                        f32 cullMaxX = mDoGph_gInf_c::getSafeMinXF() + mDoGph_gInf_c::getSafeWidthF() + sp34.x;
+#else
+                        f32 cullMinX = -sp34.x;
+                        f32 cullMaxX = FB_WIDTH + sp34.x;
+#endif
+                        if (!(proj.x > cullMinX) || !(proj.x < cullMaxX) ||
                             !(proj.y > -sp34.y) || !(proj.y < (458.0f + sp34.z)))
                         {
                             continue;
@@ -6150,6 +6164,8 @@ static void dKyr_evil_draw2(Mtx drawMtx, u8** tex) {
             }
         }
 
+        IF_DUSK(GXPopDebugGroup());
+
         GXSetClipMode(GX_CLIP_ENABLE);
         J3DShape::resetVcdVatCache();
     }
@@ -6187,6 +6203,8 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
     f32 sp60 = fabsf(cM_ssin(g_Counter.mCounter0 * 215));
 
     if (evil_packet != NULL) {
+        IF_DUSK(GXPushDebugGroup("dKyr_evil_draw"));
+
         j3dSys.reinitGX();
         if (dComIfGd_getView() != NULL) {
             MTXInverse(dComIfGd_getView()->viewMtxNoTrans, camMtx);
@@ -6208,14 +6226,19 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
         TGXTexObj texobj;
         dKyr_set_btitex(&texobj, (ResTIMG*)tex[0]);
 
-        rot += 1.0f;
+#if TARGET_PC
+        if (dusk::frame_interp::get_ui_tick_pending())
+#endif
+        {
+            rot += 1.0f;
+        }
         MTXRotRad(rotMtx, 'Z', DEG_TO_RAD(rot));
         MTXConcat(camMtx, rotMtx, camMtx);
 
         GXLoadPosMtxImm(drawMtx, GX_PNMTX0);
         GXSetCurrentMtx(GX_PNMTX0);
-        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
-        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGBA4, 8);
+        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_RGBA4, 8);
         GXClearVtxDesc();
         GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
         GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
@@ -6238,6 +6261,19 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
         GXSetClipMode(GX_CLIP_DISABLE);
         GXSetNumIndStages(0);
 
+#if TARGET_PC
+        // move color_reg0 to vtx for perf
+        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
+        GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
+        GXSetNumChans(1);
+        GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_VTX, 0, GX_DF_NONE, GX_AF_NONE);
+        GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
+        GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_C1, GX_CC_RASC, GX_CC_TEXC, GX_CC_ZERO);
+        GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+        GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_TEXA, GX_CA_RASA, GX_CA_ZERO);
+        GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+#endif
+
         dComIfG_Ccsp()->PrepareMass();
 
         for (int i = 0; i < g_env_light.field_0x1054; i++) {
@@ -6262,7 +6298,14 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
                         sp44.z = 80.0f;
 
                         mDoLib_project(&spA4, &proj);
-                        if (!(proj.x > -sp44.x) || !(proj.x < (FB_WIDTH + sp44.x)) ||
+#if TARGET_PC
+                        f32 cullMinX = mDoGph_gInf_c::getSafeMinXF() - sp44.x;
+                        f32 cullMaxX = mDoGph_gInf_c::getSafeMinXF() + mDoGph_gInf_c::getSafeWidthF() + sp44.x;
+#else
+                        f32 cullMinX = -sp44.x;
+                        f32 cullMaxX = FB_WIDTH + sp44.x;
+#endif
+                        if (!(proj.x > cullMinX) || !(proj.x < cullMaxX) ||
                             !(proj.y > -sp44.y) || !(proj.y < (458.0f + sp44.z)))
                         {
                             continue;
@@ -6349,7 +6392,7 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
                             color_reg0.b = (115.0f * sp28) + (15.0f * fabsf(sp2C - sp64));
                         }
 
-                        GXSetTevColor(GX_TEVREG0, color_reg0);
+                        IF_NOT_DUSK(GXSetTevColor(GX_TEVREG0, color_reg0));
                         GXSetTevColor(GX_TEVREG1, color_reg1);
 
                         spC8 = spA4;
@@ -6388,12 +6431,16 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
 
                         GXBegin(GX_QUADS, GX_VTXFMT0, 4);
                         GXPosition3f32(pos[0].x, pos[0].y, pos[0].z);
+                        IF_DUSK(GXColor4u8(color_reg0.r, color_reg0.g, color_reg0.b, color_reg0.a));
                         GXTexCoord2s16(0, 0);
                         GXPosition3f32(pos[1].x, pos[1].y, pos[1].z);
+                        IF_DUSK(GXColor4u8(color_reg0.r, color_reg0.g, color_reg0.b, color_reg0.a));
                         GXTexCoord2s16(0xFF, 0);
                         GXPosition3f32(pos[2].x, pos[2].y, pos[2].z);
+                        IF_DUSK(GXColor4u8(color_reg0.r, color_reg0.g, color_reg0.b, color_reg0.a));
                         GXTexCoord2s16(0xFF, 0xFF);
                         GXPosition3f32(pos[3].x, pos[3].y, pos[3].z);
+                        IF_DUSK(GXColor4u8(color_reg0.r, color_reg0.g, color_reg0.b, color_reg0.a));
                         GXTexCoord2s16(0, 0xFF);
                         GXEnd();
                     }
@@ -6401,6 +6448,8 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
             }
         }
 
+        IF_DUSK(GXPopDebugGroup());
+
         J3DShape::resetVcdVatCache();
         GXSetClipMode(GX_CLIP_ENABLE);
 

src/d/d_map.cpp

@@ -13,6 +13,9 @@
 #include "SSystem/SComponent/c_math.h"
 #include "d/actor/d_a_player.h"
 #include "d/d_com_inf_game.h"
+#if TARGET_PC
+#include <dolphin/gx/GXExtra.h>
+#endif
 #include <cstring>
 
 #if DEBUG
@@ -539,17 +542,14 @@ void renderingAmap_c::rendering(dDrawPath_c::poly_class const* i_poly) {
     }
 }
 
-/* Enabling the following definition will modify the following function to
- * make the map look worse for extra speed in the emulator, especially in large
- * areas such as hyrule field.
- */
-#define HYRULE_FIELD_SPEEDHACK
 
 bool renderingAmap_c::isDrawOutSideTrim() {
     bool rt = false;
 
-    #ifdef HYRULE_FIELD_SPEEDHACK
-    return 0;
+    #if TARGET_PC
+    if (!dusk::getSettings().game.enableMapBackground) {
+        return 0;
+    }
     #endif
 
     if (getDispType() == 0 || getDispType() == 4 || getDispType() == 3 || getDispType() == 2 ||
@@ -1218,6 +1218,9 @@ void dMap_c::changeTextureSize(int param_1, int param_2, int param_3) {
 
 void dMap_c::_remove() {
     if (mImage_p != NULL) {
+#if TARGET_PC
+        GXDestroyCopyTex(mImage_p);
+#endif
         JKR_DELETE_ARRAY(mImage_p);
         mImage_p = NULL;
     }

src/d/d_map_path.cpp

@@ -16,6 +16,7 @@
 
 #ifdef TARGET_PC
 constexpr u16 kMapResolutionMultiplier = 4;
+constexpr u16 kMapCircleSize = 16 * kMapResolutionMultiplier;
 #endif
 
 void dMpath_n::dTexObjAggregate_c::create() {
@@ -32,6 +33,48 @@ void dMpath_n::dTexObjAggregate_c::create() {
         JUT_ASSERT(74, image->magFilter == GX_NEAR);
         mDoLib_setResTimgObj(image, mp_texObj[lp1], 0, NULL);
     }
+
+#if TARGET_PC
+    auto hqCircle = JKR_NEW TGXTexObj();
+
+    static bool hqCircleDrawn = false;
+    static u8 hqCircleData[kMapCircleSize * kMapCircleSize];
+
+    if (!hqCircleDrawn) {
+        const auto center = kMapCircleSize / 2.0f;
+        const auto radiusSq = center * center;
+        const auto blocksAcross = kMapCircleSize >> 3;
+        const auto totalPixels = sizeof(hqCircleData);
+
+        for (size_t i = 0; i < totalPixels; i++) {
+            // 8x4 block swizzling for I8
+            const auto blockIdx = i >> 5;
+            const auto localIdx = i & 31;
+
+            const auto blockY = blockIdx / blocksAcross;
+            const auto blockX = blockIdx % blocksAcross;
+
+            const auto localY = localIdx >> 3;
+            const auto localX = localIdx & 7;
+
+            const auto x = (blockX << 3) + localX;
+            const auto y = (blockY << 2) + localY;
+
+            const auto dx = (x + 0.5f) - center;
+            const auto dy = (y + 0.5f) - center;
+
+            // the original texture is in I4 format and uses 1 to indicate if inside the circle
+            // so we scale to I8 range: 255 / 15 = 17
+            hqCircleData[i] = (dx * dx + dy * dy < radiusSq) ? 17 : 0;
+        }
+        hqCircleDrawn = true;
+    }
+
+    GXInitTexObj(hqCircle, hqCircleData, kMapCircleSize, kMapCircleSize, GX_TF_I8, GX_CLAMP,
+                 GX_CLAMP, GX_FALSE);
+    GXInitTexObjLOD(hqCircle, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
+    mp_texObj[6] = hqCircle;
+#endif
 }
 
 void dMpath_n::dTexObjAggregate_c::remove() {
@@ -497,12 +540,6 @@ void dRenderingFDAmap_c::postRenderingMap() {
 
 dMpath_n::dTexObjAggregate_c dMpath_n::m_texObjAgg;
 
-/* Enabling the following definition will modify the following function to
- * make the map look worse for extra speed in the emulator, especially in large
- * areas such as hyrule field.
- */
-#define HYRULE_FIELD_SPEEDHACK
-
 void dRenderingFDAmap_c::renderingDecoration(dDrawPath_c::line_class const* p_line) {
     s32 width = getDecorationLineWidth(p_line->field_0x1);
     if (width <= 0) {
@@ -527,8 +564,32 @@ void dRenderingFDAmap_c::renderingDecoration(dDrawPath_c::line_class const* p_li
     lineColor.r = lineColor.r - 4;
     GXSetTevColor(GX_TEVREG1, lineColor);
 
+#if TARGET_PC
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_KONST);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXBegin(GX_LINESTRIP, GX_VTXFMT0, 2 * (data_num - 1));
+    for (int i = 0; i < data_num - 1; i++) {
+        GXPosition1x16(data_p[i]);
+        GXTexCoord2f32(0, 0);
+        GXPosition1x16(data_p[i + 1]);
+        GXTexCoord2f32(0, 0);
+    }
+    GXEnd();
+
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_KONST, GX_CC_TEXC, GX_CC_C1);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_TEXA);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXBegin(GX_POINTS, GX_VTXFMT0, data_num);
+    for (int i = 0; i < data_num; i++) {
+        GXPosition1x16(data_p[i]);
+        GXTexCoord2f32(0, 0);
+    }
+    GXEnd();
+#else
     for (int i = 0; i < data_num; i++) {
-#ifndef HYRULE_FIELD_SPEEDHACK
         if (i < data_num - 1) {
             GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
             GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE,
@@ -547,7 +608,6 @@ void dRenderingFDAmap_c::renderingDecoration(dDrawPath_c::line_class const* p_li
         GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
         GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_TEXA);
         GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
-#endif
 
         GXBegin(GX_POINTS, GX_VTXFMT0, 1);
         GXPosition1x16(data_p[0]);
@@ -555,6 +615,7 @@ void dRenderingFDAmap_c::renderingDecoration(dDrawPath_c::line_class const* p_li
         GXEnd();
         data_p++;
     }
+#endif
 
     setTevSettingNonTextureDirectColor();
     GXClearVtxDesc();

src/d/d_menu_dmap.cpp

@@ -856,7 +856,46 @@ void dMenu_DmapBg_c::decGoldFrameAlphaRate() {
     setGoldFrameAlphaRate(rate);
 }
 
+void dMenu_DmapBg_c::dMapBgWide() {
+    // Scale Base HUD
+    mBaseScreen->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mBaseScreen->translate(mDoGph_gInf_c::getSafeMinXF(), 0.0f);
+
+    // Boss Key, Compass & Map icons
+    mBaseScreen->search(MULTI_CHAR('key_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBaseScreen->search(MULTI_CHAR('con_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBaseScreen->search(MULTI_CHAR('map_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Text Header
+    mBaseScreen->search(MULTI_CHAR('t_t00'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBaseScreen->search(MULTI_CHAR('f_t_00'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // C Button
+    mBaseScreen->search(MULTI_CHAR('c_btn2'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Scale Buttons HUD
+    mButtonScreen->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mButtonScreen->translate(mDoGph_gInf_c::getSafeMinXF(), 0.0f);
+
+    // Buttons
+    mButtonScreen->search(MULTI_CHAR('cont_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // C Button
+    mButtonScreen->search(MULTI_CHAR('c_btn'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mButtonScreen->search(MULTI_CHAR('c_text_s'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mButtonScreen->search(MULTI_CHAR('c_text'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mButtonScreen->search(MULTI_CHAR('f_text_s'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mButtonScreen->search(MULTI_CHAR('f_text'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Decorations
+    mButtonScreen->search(MULTI_CHAR('kazari_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+}
+
 void dMenu_DmapBg_c::draw() {
+    #if TARGET_PC
+    dMapBgWide();
+    #endif
+
     u32 scissor_left;
     u32 scissor_top;
     u32 scissor_width;

src/d/d_menu_dmap_map.cpp

@@ -11,6 +11,9 @@
 #include "d/d_menu_dmap_map.h"
 #include "f_op/f_op_msg_mng.h"
 #include "m_Do/m_Do_graphic.h"
+#if TARGET_PC
+#include <dolphin/gx/GXExtra.h>
+#endif
 
 struct dMdm_HIO_prm_res_dst_s {
     static void* m_res;
@@ -291,6 +294,9 @@ void dMenu_DmapMap_c::_create(u16 param_0, u16 param_1, u16 param_2, u16 param_3
 void dMenu_DmapMap_c::_delete() {
     for (int i = 0; i < 2; i++) {
         if (mMapImage_p[i] != NULL) {
+#if TARGET_PC
+            GXDestroyCopyTex(mMapImage_p[i]);
+#endif
             JKR_DELETE_ARRAY(mMapImage_p[i]);
         }
 

src/d/d_menu_fishing.cpp

@@ -16,6 +16,8 @@
 #include "m_Do/m_Do_graphic.h"
 #include <cstring>
 
+#include "dusk/version.hpp"
+
 typedef void (dMenu_Fishing_c::*initFunc)();
 initFunc map_init_process[] = {
     &dMenu_Fishing_c::wait_init,
@@ -135,9 +137,9 @@ bool dMenu_Fishing_c::isSync() {
 }
 
 void dMenu_Fishing_c::init() {
-    #if VERSION == VERSION_GCN_PAL
+    #if TARGET_PC || VERSION == VERSION_GCN_PAL
     BOOL isEnglish = FALSE;
-    if (dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH) {
+    if (dusk::version::isRegionUsa() || (dusk::version::isRegionPal() && dComIfGs_getPalLanguage() == dSv_player_config_c::LANGUAGE_ENGLISH)) {
         isEnglish = TRUE;
     }
     #endif
@@ -145,7 +147,7 @@ void dMenu_Fishing_c::init() {
     for (int i = 0; i < MAX_FINDABLE_FISHES; i++) {
         if (dComIfGs_getFishNum(i) != 0) {
             // Fish has been caught once, display it along with it's params
-            #if VERSION == VERSION_GCN_PAL
+            #if TARGET_PC || VERSION == VERSION_GCN_PAL
             if (isEnglish) {
                 setFishParam(i, dComIfGs_getFishNum(i), dComIfGs_getFishSize(i) / 2.54f);
             } else {

src/d/d_menu_fmap2D.cpp

@@ -20,6 +20,15 @@
 #include "dusk/frame_interpolation.h"
 #include <cstring>
 
+#if TARGET_PC
+void dMenu_Fmap2DBack_c::fMapBackWide() {
+    mpBaseScreen->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mpBaseScreen->translate(mDoGph_gInf_c::getSafeMinXF(), 0.0f);
+    mpBackScreen->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mpBackScreen->translate(mDoGph_gInf_c::getSafeMinXF(), 0.0f);
+}
+#endif
+
 dMenu_Fmap2DBack_c::dMenu_Fmap2DBack_c() {
     dMeter2Info_setMapDrugFlag(0);
 
@@ -267,6 +276,10 @@ dMenu_Fmap2DBack_c::~dMenu_Fmap2DBack_c() {
 }
 
 void dMenu_Fmap2DBack_c::draw() {
+    #if TARGET_PC
+    fMapBackWide();
+    #endif
+
     calcBlink();
 
     J2DGrafContext* grafPort = dComIfGp_getCurrentGrafPort();
@@ -1199,7 +1212,7 @@ f32 dMenu_Fmap2DBack_c::getMapScissorAreaSizeX() {
 }
 
 f32 dMenu_Fmap2DBack_c::getMapScissorAreaSizeRealX() {
-#if PLATFORM_GCN && !TARGET_PC
+#if PLATFORM_GCN
     return getMapScissorAreaSizeX();
 #else
     return getMapScissorAreaSizeX() * mDoGph_gInf_c::getScale();
@@ -1407,6 +1420,11 @@ void dMenu_Fmap2DBack_c::stageTextureDraw() {
         mpSpotTexture->setAlpha(mAlphaRate * 255.0f * field_0xfa8 * mSpotTextureFadeAlpha);
     }
 
+#if TARGET_PC
+    JUTPalette* pPalette = mpSpotTexture->getTexture(0)->getPalette();
+    pPalette->dataUploaded();
+#endif
+
     mpSpotTexture->draw(mTransX + getMapScissorAreaLX(), mTransZ + getMapScissorAreaLY(),
                         getMapScissorAreaSizeRealX(), getMapScissorAreaSizeRealY(), false, false,
                         false);
@@ -2179,6 +2197,17 @@ void dMenu_Fmap2DBack_c::setArrowPosAxis(f32 i_posX, f32 i_posZ) {
     control_ypos = 0.0f;
 }
 
+#if TARGET_PC
+void dMenu_Fmap2DTop_c::fMapTopWide() {
+    mpTitleScreen->search(MULTI_CHAR('spot0_n'))->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mpTitleScreen->search(MULTI_CHAR('spot2_n'))->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mpTitleScreen->search(MULTI_CHAR('name_n'))->translate(mDoGph_gInf_c::ScaleHUDXLeft(-243.0f), -169.0f);
+    mpTitleScreen->search(MULTI_CHAR('sub_n_n'))->translate(mDoGph_gInf_c::ScaleHUDXLeft(-80.0f), -154.0f);
+    mpTitleScreen->search(MULTI_CHAR('btn_i_n'))->translate(mDoGph_gInf_c::ScaleHUDXLeft(-241.0f), 177.0f);
+    mpTitleScreen->search(MULTI_CHAR('cont_n'))->translate(mDoGph_gInf_c::ScaleHUDXRight(515.0f), 83.0f);
+}
+#endif
+
 dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     mpHeap = i_heap;
     mTransX = 0.0f;
@@ -2572,6 +2601,10 @@ void dMenu_Fmap2DTop_c::setAllAlphaRate(f32 i_rate, bool i_init) {
 }
 
 void dMenu_Fmap2DTop_c::draw() {
+    #if TARGET_PC
+    fMapTopWide();
+    #endif
+
     u32 scissor_left, scissor_top, scissor_width, scissor_height;
     J2DOrthoGraph* ctx = static_cast<J2DOrthoGraph*>(dComIfGp_getCurrentGrafPort());
     ctx->setup2D();

src/d/d_menu_fmap_map.cpp

@@ -8,6 +8,9 @@
 #include "d/d_debug_viewer.h"
 #include "d/d_menu_fmap_map.h"
 #include "m_Do/m_Do_graphic.h"
+#if TARGET_PC
+#include <dolphin/gx/GXExtra.h>
+#endif
 #include <cstring>
 
 static u8 twoValueLineInterpolation(u8 i_value1, u8 i_value2, f32 i_param) {
@@ -494,6 +497,9 @@ void dMenu_FmapMap_c::_delete() {
         mResTIMG = NULL;
     }
     if (mMapImage_p != NULL) {
+#if TARGET_PC
+        GXDestroyCopyTex(mMapImage_p);
+#endif
         JKR_DELETE_ARRAY(mMapImage_p);
         mMapImage_p = NULL;
     }

src/d/d_menu_letter.cpp

@@ -17,6 +17,10 @@
 #include "d/d_msg_scrn_arrow.h"
 #include "d/d_lib.h"
 
+#ifdef TARGET_PC
+#include "dusk/achievements.h"
+#endif
+
 #if VERSION == VERSION_GCN_JPN
 #define D_MENU_LETTER_LINE_MAX 9
 #else
@@ -514,6 +518,10 @@ void dMenu_Letter_c::read_open_init() {
     setAButtonString(0);
     setBButtonString(0);
     mpBlackTex->setAlpha(0);
+
+    #ifdef TARGET_PC
+        dusk::AchievementSystem::get().signal("open_letter");
+    #endif
 }
 
 void dMenu_Letter_c::read_open_move() {

src/d/d_meter2.cpp

@@ -316,6 +316,12 @@ int dMeter2_c::_execute() {
 }
 
 int dMeter2_c::_draw() {
+    #if TARGET_PC
+    if (dusk::getSettings().game.disableMainHUD) {
+        return 1;
+    }
+    #endif
+
     if (mpMap != NULL) {
         mpMap->_draw();
     }
@@ -424,12 +430,6 @@ void dMeter2_c::setLifeZero() {
 void dMeter2_c::checkStatus() {
     mStatus = 0;
 
-    #if TARGET_PC
-    if (dusk::getSettings().game.disableMainHUD) {
-        mStatus |= 0xF0000000;
-    }
-    #endif
-
     field_0x12c = field_0x128;
 
     field_0x128 = daPy_py_c::checkNowWolf();

src/d/d_meter_HIO.cpp

@@ -2306,6 +2306,10 @@ void dMeter_drawHIO_c::updateOnWide() {
     // River Canoe Minigame
     g_drawHIO.mMiniGame.mCounterPosX[1] = mDoGph_gInf_c::ScaleHUDXRight(g_drawHIO.mMiniGame.mCounterPosX[1]);
     g_drawHIO.mMiniGame.mIconPosX[1] = mDoGph_gInf_c::ScaleHUDXRight(g_drawHIO.mMiniGame.mIconPosX[1]);
+
+    // Bulblin Count in Hidden Village
+    g_drawHIO.mMiniGame.mCounterPosX[2] = mDoGph_gInf_c::ScaleHUDXRight(g_drawHIO.mMiniGame.mCounterPosX[2]);
+    g_drawHIO.mMiniGame.mIconPosX[2] = mDoGph_gInf_c::ScaleHUDXRight(g_drawHIO.mMiniGame.mIconPosX[2]);
 #endif
 }