Merge branch 'main' of github.com:TwilitRealm/dusk into speedrun-timer

include/d/actor/d_a_alink.h

@@ -4551,7 +4551,7 @@ public:
 #if TARGET_PC
     void handleWolfHowl();
     void handleQuickTransform();
-    bool checkGyroAimItemContext();
+    bool checkGyroAimContext();
 #endif
 };  // Size: 0x385C
 

include/d/actor/d_a_balloon_2D.h

@@ -44,6 +44,9 @@ public:
     int draw();
     int execute();
     void drawMeter();
+    #if TARGET_PC
+    void updateOnWide();
+    #endif
     void setComboCount(u8, u8);
     void setScoreCount(u32);
     void addScoreCount(cXyz*, u32, u8);

include/d/actor/d_a_e_wb.h

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

include/d/actor/d_a_mirror.h

@@ -25,6 +25,9 @@ public:
     /* 0x164 */ cXyz mMinVal;
     /* 0x170 */ cXyz mMaxVal;
     /* 0x17C */ cXyz mViewScale;
+#if TARGET_PC
+    bool mbReset = false;
+#endif
 };
 
 /**

include/d/actor/d_a_movie_player.h

@@ -94,6 +94,12 @@ static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr);
 #define THP_TEXTURE_SET_COUNT  3
 #endif
 
+#if TARGET_PC
+namespace dusk {
+    void MoviePlayerShutdown();
+}
+#endif
+
 struct daMP_THPPlayer {
     /* 0x000 */ DVDFileInfo fileInfo;
 	/* 0x03C */ THPHeader header;

include/d/actor/d_a_obj_sw.h

@@ -68,10 +68,8 @@ public:
     /* 0x904 */ cXyz field_0x904[2];
     /* 0x91C */ int field_0x91c;
     /* 0x920 */ cXyz field_0x920[63];
-    /* 0xC14 */ f32 field_0xc14[4];
-    /* 0xC24 */ u8 field_0xc24[0xd10 - 0xc24];
-    /* 0xD10 */ s8 field_0xd10[4];
-    /* 0xD14 */ u8 field_0xd14[0xd50 - 0xd14];
+    /* 0xC14 */ f32 field_0xc14[63];
+    /* 0xD10 */ s8 field_0xd10[64];
     /* 0xD50 */ mDoExt_3DlineMat1_c field_0xd50;
     /* 0xD8C */ int field_0xd8c;
 };

include/d/d_com_inf_game.h

@@ -4834,8 +4834,7 @@ inline void dComIfGd_drawXluListDark() {
 inline void dComIfGd_drawXluListInvisible() {
     ZoneScoped;
 #ifdef TARGET_PC
-    if (dusk::getSettings().game.enableWaterRefraction &&
-        !dusk::getSettings().game.enableFrameInterpolation) {
+    if (!dusk::getSettings().game.disableWaterRefraction) {
 #endif
         g_dComIfG_gameInfo.drawlist.drawXluListInvisible();
 #ifdef TARGET_PC
@@ -4846,8 +4845,7 @@ inline void dComIfGd_drawXluListInvisible() {
 inline void dComIfGd_drawOpaListInvisible() {
     ZoneScoped;
 #ifdef TARGET_PC
-    if (dusk::getSettings().game.enableWaterRefraction &&
-        !dusk::getSettings().game.enableFrameInterpolation) {
+    if (!dusk::getSettings().game.disableWaterRefraction) {
 #endif
         g_dComIfG_gameInfo.drawlist.drawOpaListInvisible();
 #ifdef TARGET_PC

include/d/d_drawlist.h

@@ -209,6 +209,10 @@ public:
     /* 0x04 */ TGXTexObj* mpTexObj;
     /* 0x08 */ Mtx mVolumeMtx;
     /* 0x38 */ Mtx mMtx;
+#if TARGET_PC
+    const void* mVolumeMtxKey;
+    const void* mMtxKey;
+#endif
 };  // Size: 0x68
 
 struct cBgD_Vtx_t;

include/d/d_file_select.h

@@ -10,6 +10,7 @@
 #include "JSystem/J3DGraphLoader/J3DAnmLoader.h"
 
 class dFile_info_c;
+class J2DPicture;
 
 class dDlst_FileSel_c : public dDlst_base_c {
 public:
@@ -113,6 +114,14 @@ public:
     /* 0x04 */ J2DScreen* Scr3m;
 };
 
+class dDlst_FileSelFade_c : public dDlst_base_c {
+public:
+    void draw();
+    virtual ~dDlst_FileSelFade_c() {}
+
+    /* 0x04 */ J2DPicture* mpPict;
+};
+
 class dFs_HIO_c : public JORReflexible {
 public:
     dFs_HIO_c();
@@ -676,6 +685,9 @@ public:
     #if PLATFORM_GCN
     /* 0x2378 */ J2DPicture* mpFadePict;
     #endif
+#ifdef TARGET_PC
+    dDlst_FileSelFade_c mFadeDlst;
+#endif
 
     #if PLATFORM_WII || PLATFORM_SHIELD
     /* 0x2376 */ u8 field_0x2376[SAVEFILE_SIZE];
@@ -684,6 +696,10 @@ public:
     #endif
 };
 
+#ifdef TARGET_PC
+STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C + sizeof(dDlst_FileSelFade_c));
+#else
 STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C);
+#endif
 
 #endif /* D_FILE_D_FILE_SELECT_H */

include/d/d_menu_dmap.h

@@ -103,6 +103,10 @@ public:
         field_0xd98 = param_1;
     }
 
+#if TARGET_PC
+    void resetScrollArrowMask() { field_0xdda = 0; }
+#endif
+
     /* 0xC98 */ JKRExpHeap* mpHeap;
     /* 0xC9C */ JKRExpHeap* mpTalkHeap;
     /* 0xCA0 */ STControl* mpStick;

include/d/d_menu_fmap.h

@@ -75,7 +75,9 @@ public:
         /* 0x8 */ BE(u16) mAreaName;
         /* 0xA */ u8 mCount;
 #ifdef _MSVC_LANG
-        u8* __get_mRoomNos() const { return (u8*)(this + 1); }
+        // Room numbers start at offset 0xB (right after mCount), NOT at sizeof(data)=12.
+        // (u8*)(this+1) would give offset 12 because MSVC sizeof=12; use &mCount+1 instead.
+        u8* __get_mRoomNos() const { return (u8*)&mCount + 1; }
         __declspec(property(get = __get_mRoomNos)) u8* mRoomNos;
 #else
         /* 0xB */ u8 mRoomNos[0];

include/d/d_menu_ring.h

@@ -204,6 +204,18 @@ private:
     /* 0x6D1 */ u8 field_0x6d1;
     /* 0x6D2 */ u8 field_0x6d2;
     /* 0x6D3 */ u8 field_0x6d3;
+#if TARGET_PC
+    f32 mSelectItemSlideElapsed[4];
+    f32 mCursorInterpPrevX;
+    f32 mCursorInterpPrevY;
+    f32 mCursorInterpCurrX;
+    f32 mCursorInterpCurrY;
+    s16 mCursorInterpPrevAngle;
+    s16 mCursorInterpCurrAngle;
+    bool mCursorInterpPrevAngular;
+    bool mCursorInterpCurrAngular;
+    bool mCursorInterpInit;
+#endif
 };
 
 #endif /* D_MENU_D_MENU_RING_H */

include/d/d_msg_scrn_howl.h

@@ -110,6 +110,10 @@ struct dMsgScrnHowl_c : public dMsgScrnBase_c {
     /* 0x27A0 */ f32 field_0x27a0;
     /* 0x27A4 */ f32 field_0x27a4;
     /* 0x27A8 */ f32 field_0x27a8;
+
+#if TARGET_PC
+    u8 showCursor;
+#endif
 };
 
 #endif /* MSG_SCRN_D_MSG_SCRN_HOWL_H */

include/d/d_save.h

@@ -487,19 +487,31 @@ public:
         }
     }
     char* getPlayerName() const { return const_cast<char*>(mPlayerName); }
-    void setPlayerName(const char* i_name) { strcpy(mPlayerName, i_name); }
+    void setPlayerName(const char* i_name) {
+#if AVOID_UB
+        strncpy(mPlayerName, i_name, sizeof(mPlayerName) - 1);
+        mPlayerName[sizeof(mPlayerName) - 1] = '\0';
+#else
+        strcpy(mPlayerName, i_name);
+#endif
+    }
     char* getHorseName() const { return const_cast<char*>(mHorseName); }
-    void setHorseName(const char* i_name) { strcpy(mHorseName, i_name); }
+    void setHorseName(const char* i_name) {
+#if AVOID_UB
+        strncpy(mHorseName, i_name, sizeof(mHorseName) - 1);
+        mHorseName[sizeof(mHorseName) - 1] = '\0';
+#else
+        strcpy(mHorseName, i_name);
+#endif
+    }
     u8 getClearCount() const { return mClearCount; }
 
     /* 0x00 */ BE(u64) unk0;
     /* 0x08 */ BE(s64) mTotalTime;
     /* 0x10 */ BE(u16) unk16;
     /* 0x12 */ BE(u16) mDeathCount;
-    /* 0x14 */ char mPlayerName[16];
-    /* 0x24 */ u8 unk36;
-    /* 0x25 */ char mHorseName[16];
-    /* 0x35 */ u8 unk53;
+    /* 0x14 */ char mPlayerName[17];
+    /* 0x25 */ char mHorseName[17];
     /* 0x36 */ u8 mClearCount;
     /* 0x37 */ u8 unk55[5];
 };  // Size: 0x40

include/d/d_select_cursor.h

@@ -47,6 +47,13 @@ public:
         mPositionY = y;
     }
 
+#ifdef TARGET_PC
+    f32 getPositionX() const { return mPositionX; }
+    f32 getPositionY() const { return mPositionY; }
+
+    void refreshAspectScale();
+#endif
+
     void onUpdateFlag() { mUpdateFlag = true; }
 
     void resetUpdateFlag() { mUpdateFlag = false; }
@@ -79,6 +86,9 @@ private:
     /* 0x58 */ f32 mPositionX;
     /* 0x5C */ f32 mPositionY;
     /* 0x60 */ f32 mParam1;
+#ifdef TARGET_PC
+    f32 mBaseParam1;
+#endif
     /* 0x64 */ f32 mParam2;
     /* 0x68 */ f32 mParam3;
     /* 0x6C */ f32 mParam4;

include/dusk/audio/DuskAudioSystem.h

@@ -12,6 +12,8 @@ namespace dusk::audio {
 
     void SetMasterVolume(f32 value);
 
+    void SetPaused(bool paused);
+
     u32 GetResetCount(int channelIdx);
 
     f32 VolumeFromU16(u16 value);

include/dusk/discord_presence.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifdef DUSK_DISCORD_RPC
+
+namespace dusk {
+namespace discord {
+
+void Initialize();
+
+void RunCallbacks();
+
+void UpdatePresence();
+
+void Shutdown();
+}
+}
+
+#endif // DUSK_DISCORD_RPC

include/dusk/dusk.h

@@ -6,7 +6,6 @@
 #include "aurora/gfx.h"
 
 extern AuroraInfo auroraInfo;
-extern const char* configPath;
 
 namespace dusk {
     extern AuroraStats lastFrameAuroraStats;

include/dusk/frame_interpolation.h

@@ -1,13 +1,12 @@
-#ifndef DUSK_FRAME_INTERP_H
-#define DUSK_FRAME_INTERP_H
+#pragma once
 
 #include <dolphin/mtx.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
-struct cXyz;
 class camera_process_class;
+class view_class;
 
 #ifdef __cplusplus
 namespace dusk {
@@ -15,34 +14,39 @@ namespace frame_interp {
 
 void ensure_initialized();
 
-void begin_record_camera();
 void begin_record();
 void end_record();
-void interpolate(float step);
+void begin_sim_tick();
+void begin_frame(bool enabled, bool is_sim_frame, float step);
+void interpolate();
 float get_interpolation_step();
 
-void notify_presentation_frame();
 void request_presentation_sync();
 bool presentation_sync_active();
 
-void notify_sim_tick_complete();
-uint32_t begin_presentation_ui_pass();
-uint32_t get_presentation_ui_advance_ticks();
-void end_presentation_ui_pass();
+bool is_enabled();
+
+// TODO: These should be phased out as UI is progressively updated to use game_clock
+void set_ui_tick_pending(bool value);
+bool get_ui_tick_pending();
+
+bool is_sim_frame();
 
-void open_child(const void* key, int32_t id);
-void close_child();
 void record_camera(::camera_process_class* cam, int camera_id);
-void record_final_mtx_raw(const Mtx* dest, const Mtx src);
+void interp_view(::view_class* view);
+void record_final_mtx(Mtx m, const void *key);
+void record_final_mtx(Mtx m);
 
-bool lookup_replacement(const void* source, Mtx out);
+bool lookup_replacement(const void* key, Mtx out);
 bool lookup_concat_replacement(const void* lhs, const void* rhs, Mtx out);
 
-void camera_eye_from_view_mtx(MtxP view_mtx, cXyz* o_eye);
-bool build_star_view(Mtx o_view, Mtx o_cam_billboard_base, cXyz* o_anchor_eye, float* o_fovy);
+typedef void (*InterpolationCallBack)(bool isSimFrame, void* pUserWork);
+// call on a sim tick, will get called during presentation
+void add_interpolation_callback(InterpolationCallBack pCallBack, void* pUserWork);
+
+void begin_presentation_camera();
+void end_presentation_camera();
 
 }  // namespace frame_interp
 }  // namespace dusk
 #endif
-
-#endif

include/dusk/game_clock.h

@@ -0,0 +1,26 @@
+#pragma once
+
+namespace dusk::game_clock {
+
+void ensure_initialized();
+void reset_frame_timer();
+
+constexpr float sim_pace() { return 1.0f / 30.0f; }
+constexpr float period_for_original_frames(float frame_count) { return frame_count * sim_pace(); }
+constexpr float ui_maximum_dt() { return 0.05f; }
+constexpr float ui_initial_dt() { return 1.0f / 60.0f; }
+
+struct MainLoopPacer {
+    float presentation_dt_seconds;
+    bool is_interpolating;
+    int sim_ticks_to_run;
+    float sim_pace;
+};
+
+MainLoopPacer advance_main_loop();
+void commit_sim_tick();
+float sample_interpolation_step();
+
+float consume_interval(const void* consumer);
+
+} // namespace dusk::game_clock

include/dusk/gamepad_color.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#ifndef GAMEPAD_COLOR_H
+#define GAMEPAD_COLOR_H
+
+void handleGamepadColor();
+
+#endif

include/dusk/gyro.h

@@ -0,0 +1,17 @@
+#ifndef DUSK_GYRO_H
+#define DUSK_GYRO_H
+
+namespace dusk::gyro {
+void read(float dt);
+void getAimDeltas(float& out_yaw, float& out_pitch);
+bool queryGyroAimContext();
+
+void rollgoalTick(bool play_active, s16 camera_yaw);
+void rollgoalTableOffset(s16& out_ax, s16& out_az);
+
+extern bool s_sensor_keep_alive;
+bool get_sensor_keep_alive();
+void set_sensor_keep_alive(bool value);
+}  // namespace dusk::gyro
+
+#endif

include/dusk/gyro_aim.h

@@ -1,10 +0,0 @@
-#ifndef DUSK_GYRO_AIM_H
-#define DUSK_GYRO_AIM_H
-
-namespace dusk::gyro_aim {
-void read(float dt, bool context_active);
-void consumeAimDeltas(float& out_yaw_rad, float& out_pitch_rad);
-bool queryGyroAimItemContext();
-}  // namespace dusk::gyro_aim
-
-#endif

include/dusk/hotkeys.h

@@ -9,15 +9,17 @@ constexpr const char* DO_RESET = "Cmd+R";
 constexpr const char* DO_RESET = "Ctrl+R";
 #endif
 
-constexpr const char* TOGGLE_FULLSCREEN = "F11";
-
 constexpr const char* SHOW_PROCESS_MANAGEMENT = "F2";
 constexpr const char* SHOW_DEBUG_OVERLAY = "F3";
 constexpr const char* SHOW_HEAP_VIEWER = "F4";
-constexpr const char* SHOW_STUB_LOG = "F5";
-constexpr const char* SHOW_CAMERA_DEBUG = "F6";
-constexpr const char* SHOW_AUDIO_DEBUG = "F7";
+constexpr const char* SHOW_PLAYER_INFO = "F5";
+constexpr const char* SHOW_SAVE_EDITOR = "F6";
+constexpr const char* SHOW_MAP_LOADER = "F7";
 constexpr const char* SHOW_STATE_SHARE = "F8";
+constexpr const char* SHOW_DEBUG_CAMERA = "F9";
+constexpr const char* SHOW_AUDIO_DEBUG = "F10";
+
+constexpr const char* TOGGLE_FULLSCREEN = "F11";
 
 constexpr const char* TURBO = "Tab";
 

include/dusk/logging.h

@@ -4,10 +4,12 @@
 #include <aurora/aurora.h>
 #include <aurora/lib/logging.hpp>
 
+#include <filesystem>
+
 void aurora_log_callback(AuroraLogLevel level, const char* module, const char* message, unsigned int len);
 
 namespace dusk {
-    void InitializeFileLogging(const char* configDir, AuroraLogLevel logLevel);
+    void InitializeFileLogging(const std::filesystem::path& configDir, AuroraLogLevel logLevel);
     void ShutdownFileLogging();
     const char* GetLogFilePath();
     void SendToStubLog(AuroraLogLevel level, const char* module, const char* message);

include/dusk/main.h

@@ -1,10 +1,14 @@
 #ifndef DUSK_MAIN_H
 #define DUSK_MAIN_H
 
+#include <filesystem>
+
 namespace dusk {
     extern bool IsRunning;
     extern bool IsShuttingDown;
     extern bool IsGameLaunched;
+    extern bool IsFocusPaused;
+    extern std::filesystem::path ConfigPath;
 }
 
 #endif  // DUSK_MAIN_H

include/dusk/scope_guard.hpp

@@ -0,0 +1,20 @@
+#ifndef DUSK_SCOPE_GUARD_HPP
+#define DUSK_SCOPE_GUARD_HPP
+
+#include <functional>
+
+class SimpleScopeGuard {
+public:
+    // Store the function in the constructor
+    explicit SimpleScopeGuard(const std::function<void()>& func) : m_func(func) {}
+
+    // Run the function when the object goes out of scope
+    ~SimpleScopeGuard() {
+        if (m_func) m_func();
+    }
+
+private:
+    std::function<void()> m_func;
+};
+
+#endif //DUSK_SCOPE_GUARD_HPP

include/dusk/settings.h

@@ -61,18 +61,25 @@ struct UserSettings {
         ConfigVar<bool> noMissClimbing;
         ConfigVar<bool> fastTears;
         ConfigVar<bool> instantSaves;
+        ConfigVar<bool> instantText;
         ConfigVar<bool> sunsSong;
 
         // Preferences
         ConfigVar<bool> enableMirrorMode;
         ConfigVar<bool> invertCameraXAxis;
+        ConfigVar<bool> disableMainHUD;
+        ConfigVar<bool> pauseOnFocusLost;
+        ConfigVar<bool> enableLinkDollRotation;
+
 
         // Graphics
         ConfigVar<BloomMode> bloomMode;
         ConfigVar<float> bloomMultiplier;
-        ConfigVar<bool> enableWaterRefraction;
+        ConfigVar<bool> disableWaterRefraction;
         ConfigVar<bool> enableFrameInterpolation;
+        ConfigVar<int> internalResolutionScale;
         ConfigVar<int> shadowResolutionMultiplier;
+        ConfigVar<bool> enableDepthOfField;
 
         // Audio
         ConfigVar<bool> noLowHpSound;
@@ -80,12 +87,26 @@ struct UserSettings {
 
         // Input
         ConfigVar<bool> enableGyroAim;
-        ConfigVar<float> gyroAimSensitivityX;
-        ConfigVar<float> gyroAimSensitivityY;
-        ConfigVar<bool> gyroAimInvertPitch;
-        ConfigVar<bool> gyroAimInvertYaw;
+        ConfigVar<bool> enableGyroRollgoal;
+        ConfigVar<float> gyroSensitivityX;
+        ConfigVar<float> gyroSensitivityY;
+        ConfigVar<float> gyroSensitivityRollgoal;
+        ConfigVar<float> gyroSmoothing;
+        ConfigVar<float> gyroDeadband;
+        ConfigVar<bool> gyroInvertPitch;
+        ConfigVar<bool> gyroInvertYaw;
 
         // Cheats
+        ConfigVar<bool> infiniteHearts;
+        ConfigVar<bool> infiniteArrows;
+        ConfigVar<bool> infiniteBombs;
+        ConfigVar<bool> infiniteOil;
+        ConfigVar<bool> infiniteOxygen;
+        ConfigVar<bool> infiniteRupees;
+        ConfigVar<bool> enableIndefiniteItemDrops;
+        ConfigVar<bool> moonJump;
+        ConfigVar<bool> superClawshot;
+        ConfigVar<bool> alwaysGreatspin;
         ConfigVar<bool> enableFastIronBoots;
         ConfigVar<bool> canTransformAnywhere;
         ConfigVar<bool> fastSpinner;
@@ -110,6 +131,8 @@ struct UserSettings {
         ConfigVar<bool> showPipelineCompilation;
         ConfigVar<bool> wasPresetChosen;
         ConfigVar<bool> enableCrashReporting;
+        ConfigVar<bool> duskMenuOpen;
+        ConfigVar<int> cardFileType;
     } backend;
 };
 
@@ -134,6 +157,7 @@ struct TransientSettings {
     CollisionViewSettings collisionView;
     bool skipFrameRateLimit;
     bool moveLinkActive;
+    bool stateShareLoadActive;
 };
 
 TransientSettings& getTransientSettings();

include/dusk/time.h

@@ -1,9 +1,10 @@
 #ifndef DUSK_TIME_H
 #define DUSK_TIME_H
 
-#include <chrono>
-#include <numeric>
 #include <array>
+#include <numeric>
+
+#include "SDL3/SDL_timer.h"
 
 #ifdef _WIN32
 #ifndef WIN32_LEAN_AND_MEAN
@@ -15,28 +16,26 @@
 #include <Windows.h>
 #include <shellapi.h>
 #include <intrin.h>
-#else
-#include "SDL3/SDL_timer.h"
 #endif
 
 class Limiter {
-  using delta_clock = std::chrono::high_resolution_clock;
-  using duration_t = std::chrono::nanoseconds;
-
 public:
-  void Reset() { m_oldTime = delta_clock::now(); }
+  using duration_t = Uint64;
+
+  void Reset() { m_oldTime = SDL_GetTicksNS(); }
 
   void Sleep(duration_t targetFrameTime) {
-    if (targetFrameTime.count() == 0) {
+    if (targetFrameTime == 0) {
       return;
     }
 
-    auto start = delta_clock::now();
+    const Uint64 start = SDL_GetTicksNS();
     duration_t adjustedSleepTime = SleepTime(targetFrameTime);
-    if (adjustedSleepTime.count() > 0) {
+    if (adjustedSleepTime > 0) {
       NanoSleep(adjustedSleepTime);
-      duration_t overslept = TimeSince(start) - adjustedSleepTime;
-      if (overslept < duration_t{targetFrameTime}) {
+      const duration_t elapsed = TimeSince(start);
+      const duration_t overslept = elapsed > adjustedSleepTime ? elapsed - adjustedSleepTime : 0;
+      if (overslept < targetFrameTime) {
         m_overheadTimes[m_overheadTimeIdx] = overslept;
         m_overheadTimeIdx = (m_overheadTimeIdx + 1) % m_overheadTimes.size();
       }
@@ -45,23 +44,23 @@ public:
   }
 
   duration_t SleepTime(duration_t targetFrameTime) {
-    const auto sleepTime = duration_t{targetFrameTime} - TimeSince(m_oldTime);
-    m_overhead = std::accumulate(m_overheadTimes.begin(), m_overheadTimes.end(), duration_t{}) / m_overheadTimes.size();
+    const duration_t elapsed = TimeSince(m_oldTime);
+    const duration_t sleepTime = elapsed < targetFrameTime ? targetFrameTime - elapsed : 0;
+    m_overhead = std::accumulate(m_overheadTimes.begin(), m_overheadTimes.end(), duration_t{0}) /
+                 m_overheadTimes.size();
     if (sleepTime > m_overhead) {
       return sleepTime - m_overhead;
     }
-    return duration_t{0};
+    return 0;
   }
 
 private:
-  delta_clock::time_point m_oldTime;
+  Uint64 m_oldTime = 0;
   std::array<duration_t, 4> m_overheadTimes{};
   size_t m_overheadTimeIdx = 0;
-  duration_t m_overhead = duration_t{0};
+  duration_t m_overhead = 0;
 
-  duration_t TimeSince(delta_clock::time_point start) {
-    return std::chrono::duration_cast<duration_t>(delta_clock::now() - start);
-  }
+  duration_t TimeSince(Uint64 start) const { return SDL_GetTicksNS() - start; }
 
 #if _WIN32
   void NanoSleep(const duration_t duration) {
@@ -85,9 +84,10 @@ private:
 
     LARGE_INTEGER start, current;
     QueryPerformanceCounter(&start);
-    LONGLONG ticksToWait = static_cast<LONGLONG>(duration.count() * countPerNs);
-    if (DWORD ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count(); ms > 1) {
-      ::Sleep(ms - 1);
+    const LONGLONG ticksToWait = static_cast<LONGLONG>(duration * countPerNs);
+    const Uint64 ms = duration / 1'000'000ULL;
+    if (ms > 1) {
+      ::Sleep(static_cast<DWORD>(ms - 1));
     }
     do {
       QueryPerformanceCounter(&current);
@@ -99,7 +99,7 @@ private:
     } while (current.QuadPart - start.QuadPart < ticksToWait);
   }
 #else
-  void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration.count()); }
+  void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration); }
 #endif
 };
 

include/f_pc/f_pc_leaf.h

@@ -25,7 +25,7 @@ typedef struct leafdraw_class : base_process_class {
 #endif
     /* 0xB8 */ leafdraw_method_class* leaf_methods;
     /* 0xBC */ s8 unk_0xBC;
-    /* 0xBD */ u8 unk_0xBD;
+    /* 0xBD */ u8 draw_interp_frame;
     /* 0xBE */ draw_priority_class draw_priority;
 } leafdraw_class;
 

include/f_pc/f_pc_node.h

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

include/global.h

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

include/m_Do/m_Do_graphic.h

@@ -125,8 +125,15 @@ public:
 #if TARGET_PC
     static f32 hudAspectScaleDown;
     static f32 hudAspectScaleUp;
-    static f32 ScaleHUDXLeft(f32 baseX) { return getMinXF() + baseX; }
-    static f32 ScaleHUDXRight(f32 baseX) { return -getMinXF() + baseX; }
+    static void updateSafeAreaBounds();
+    static f32 getSafeMinXF() { return m_safeMinXF; }
+    static f32 getSafeMinYF() { return m_safeMinYF; }
+    static f32 getSafeWidthF() { return m_safeWidthF; }
+    static f32 getSafeHeightF() { return m_safeHeightF; }
+    static f32 getSafeMaxXF() { return m_safeMaxXF; }
+    static f32 getSafeMaxYF() { return m_safeMaxYF; }
+    static f32 ScaleHUDXLeft(f32 baseX) { return getSafeMinXF() + baseX; }
+    static f32 ScaleHUDXRight(f32 baseX) { return getSafeMaxXF() - FB_WIDTH_BASE + baseX; }
 #endif
 
     static void setBlureMtx(const Mtx m) {
@@ -279,12 +286,7 @@ public:
     #if WIDESCREEN_SUPPORT
     static void setTvSize();
 
-    #if TARGET_PC
-    static void onWide(f32 width, f32 height);
-    #else
     static void onWide();
-    #endif
-
     static void offWide();
     static u8 isWide();
 
@@ -297,7 +299,7 @@ public:
     #endif
 
     #if TARGET_PC
-    static void setWindowSize(AuroraWindowSize const& size);
+    static void updateRenderSize();
     #endif
 
     static TGXTexObj mFrameBufferTexObj;
@@ -369,6 +371,15 @@ public:
     static int m_height;
     static f32 m_heightF;
     static f32 m_widthF;
+
+    #if TARGET_PC
+    static f32 m_safeMinXF;
+    static f32 m_safeMinYF;
+    static f32 m_safeMaxXF;
+    static f32 m_safeMaxYF;
+    static f32 m_safeWidthF;
+    static f32 m_safeHeightF;
+    #endif
     #endif
 };
 

include/m_Do/m_Do_lib.h

@@ -43,10 +43,6 @@ struct mDoLib_clipper {
 };
 
 void mDoLib_project(Vec* src, Vec* dst);
-#if TARGET_PC
-void mDoLib_project(Vec* src, Vec* dst, JGeometry::TBox2<f32> viewport);
-#endif
-
 u32 mDoLib_setResTimgObj(ResTIMG const* res, TGXTexObj* o_texObj, u32 tlut_name,
                           GXTlutObj* o_tlutObj);
 void mDoLib_pos2camera(Vec* src, Vec* dst);