Merge branch 'main' into improvement/toggle_owl_statue_markers

include/d/d_meter_button.h

@@ -1,6 +1,7 @@
 #ifndef D_METER_D_METER_BUTTON_H
 #define D_METER_D_METER_BUTTON_H
 
+#include "global.h"
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/J2DGraph/J2DTextBox.h"
 #include "d/d_drawlist.h"
@@ -194,7 +195,7 @@ public:
     /* 0x0FC */ CPaneMgr* field_0x0fc[4];
     /* 0x10C */ JKRHeap* mpHeap;
     /* 0x110 */ void* mpFishingTex;
-    /* 0x114 */ char mButtonText[2][15];
+    /* 0x114 */ char mButtonText[2][DUSK_IF_ELSE(32, 15)];
     /* 0x132 */ u8 field_0x132[0x134 - 0x132];
     /* 0x134 */ f32 field_0x134;
     /* 0x138 */ f32 field_0x138;

include/dusk/action_bindings.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "dusk/config_var.hpp"
+
+namespace dusk {
+
+enum class ActionBinds {
+    FIRST_PERSON_CAMERA,
+    CALL_MIDNA,
+    OPEN_DUSKLIGHT_MENU,
+    TURBO_SPEED_BUTTON,
+    COUNT,
+};
+
+struct ActionBindData {
+    std::array<config::ActionBindConfigVar, 4>* configVars{};
+    std::string actionName{};
+};
+
+struct ActionBindPressData {
+    bool pressedCurFrame{false};
+    bool pressedPrevFrame{false};
+};
+
+using ActionBindsMap = std::unordered_map<ActionBinds, ActionBindData>;
+
+ActionBindsMap& getActionBinds();
+
+bool isActionBound(ActionBinds action, u32 port);
+
+void updateActionBindings();
+
+bool getActionBindTrig(ActionBinds action, u32 port);
+
+bool getActionBindHold(ActionBinds action, u32 port);
+
+bool getActionBindHoldAnyPort(ActionBinds action);
+
+int getActionBindButton(ActionBinds action, u32 port);
+
+}

include/dusk/audio/DuskAudioSystem.h

@@ -1,8 +1,19 @@
 #pragma once
 
+#include <cmath>
 #include <dolphin/types.h>
 
 namespace dusk::audio {
+
+    // Converts a 0-1 volume to a linear amplitude multiplier.
+    // The curve is -4 dB per 10% step: 100% = 0 dB, 90% = -4 dB, ..., 0% = -inf dB
+    inline f32 MasterVolumeToLinear(f32 v) {
+        if (v <= 0.0f) {
+            return 0.0f;
+        }
+        return std::pow(10.0f, (v - 1.0f) * 2.0f);
+    }
+
     /**
      * Initialize the audio system and start playing audio.
      */

include/dusk/autosave.h

@@ -5,6 +5,7 @@
 
 #include <m_Do/m_Do_MemCardRWmng.h>
 #include <m_Do/m_Do_MemCard.h>
+#include <d/actor/d_a_alink.h>
 
 void noAutoSave();
 void triggerAutoSave();
@@ -13,5 +14,6 @@ void enterAutoSave();
 void autoSaving();
 void waitingForWrite();
 void endAutoSave();
+void toggleAutoSave(bool enabled);
 
 #endif

include/dusk/config.hpp

@@ -112,6 +112,13 @@ void Save();
  */
 ConfigVarBase* GetConfigVar(std::string_view name);
 
+/**
+ * \brief Resets all custom action bindings for a specific port to nothing
+ *
+ * @param port The port to be cleared of action bindings
+ */
+void ClearAllActionBindings(int port);
+
 /**
  * \brief Call a function on every registered CVar.
  */

include/dusk/config_var.hpp

@@ -175,6 +175,7 @@ class ConfigVar : public ConfigVarBase {
     T defaultValue;
     T value;
     T overrideValue;
+    ConfigVarLayer priorLayer = ConfigVarLayer::Default;
 
 public:
     /**
@@ -265,6 +266,7 @@ public:
     void setSpeedrunValue(T newValue) {
         checkRegistered();
         if (layer != ConfigVarLayer::Override) {
+            priorLayer = layer;
             overrideValue = std::move(newValue);
             layer = ConfigVarLayer::Speedrun;
         }
@@ -282,11 +284,24 @@ public:
         checkRegistered();
         if (layer == ConfigVarLayer::Speedrun) {
             overrideValue = {};
-            layer = ConfigVarLayer::Value;
+            layer = priorLayer;
         }
     }
+
+    /**
+     * \brief Get the user-persisted value, ignoring any temporary overrides.
+     *
+     * Used by Save() to write the correct value even when a speedrun override is active.
+     */
+    [[nodiscard]] constexpr const T& getValueForSave() const noexcept {
+        checkRegistered();
+        const ConfigVarLayer effectiveLayer = (layer == ConfigVarLayer::Speedrun) ? priorLayer : layer;
+        return effectiveLayer == ConfigVarLayer::Default ? defaultValue : value;
+    }
 };
 
+using ActionBindConfigVar = ConfigVar<int>;
+
 }
 
 #endif  // DUSK_CONFIG_VAR_HPP

include/dusk/endian.h

@@ -227,6 +227,28 @@ struct BE<Mtx> {
     }
 };
 
+typedef f32 Mtx23[2][3];
+template <>
+struct BE<Mtx23> {
+    BE<f32> contents[2][3];
+
+    auto& operator[](int x) {
+        return contents[x];
+    }
+
+    auto& operator[](int x) const {
+        return contents[x];
+    }
+
+    void to_host(Mtx23& mtx) const {
+        for (int i = 0; i < 2; i++) {
+            for (int j = 0; j < 3; j++) {
+                mtx[i][j] = contents[i][j];
+            }
+        }
+    }
+};
+
 template<typename T>
 void be_swap(T& val) {
     val = BE<T>::swap(val);

include/dusk/frame_interpolation.h

@@ -4,6 +4,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include "settings.h"
 
 class camera_process_class;
 class view_class;
@@ -17,7 +18,8 @@ void ensure_initialized();
 void begin_record();
 void end_record();
 void begin_sim_tick();
-void begin_frame(bool enabled, bool is_sim_frame, float step);
+uint64_t sim_tick_seq();
+void begin_frame(FrameInterpMode mode, bool is_sim_frame, float step);
 void interpolate();
 float get_interpolation_step();
 

include/dusk/hotkeys.h

@@ -14,7 +14,6 @@ constexpr const char* SHOW_DEBUG_OVERLAY = "F3";
 constexpr const char* SHOW_HEAP_VIEWER = "F4";
 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";

include/dusk/main.h

@@ -10,6 +10,7 @@ extern bool IsShuttingDown;
 extern bool IsGameLaunched;
 extern bool RestartRequested;
 extern std::filesystem::path ConfigPath;
+extern std::filesystem::path CachePath;
 
 #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) ||                           \
     (defined(TARGET_OS_TV) && TARGET_OS_TV)

include/dusk/settings.h

@@ -1,6 +1,8 @@
 #ifndef DUSK_CONFIG_H
 #define DUSK_CONFIG_H
 
+#include <array>
+
 #include "dusk/config_var.hpp"
 
 namespace dusk {
@@ -13,6 +15,11 @@ enum class BloomMode : int {
     Dusk = 2,
 };
 
+enum class Resampler : int {
+    Bilinear = 0,
+    Area = 1,
+};
+
 enum class GameLanguage : u8 {
     English = OS_LANGUAGE_ENGLISH,
     German = OS_LANGUAGE_GERMAN,
@@ -32,6 +39,12 @@ enum class GyroMode : u8 {
     Mouse = 1,
 };
 
+enum class FrameInterpMode : u8 {
+    Off = 0,
+    Capped = 1,
+    Unlimited = 2,
+};
+
 namespace config {
 template <>
 struct ConfigEnumRange<BloomMode> {
@@ -39,6 +52,12 @@ struct ConfigEnumRange<BloomMode> {
     static constexpr auto max = BloomMode::Dusk;
 };
 
+template <>
+struct ConfigEnumRange<Resampler> {
+    static constexpr auto min = Resampler::Bilinear;
+    static constexpr auto max = Resampler::Area;
+};
+
 template <>
 struct ConfigEnumRange<GameLanguage> {
     static constexpr auto min = GameLanguage::English;
@@ -56,7 +75,13 @@ struct ConfigEnumRange<GyroMode> {
     static constexpr auto min = GyroMode::Sensor;
     static constexpr auto max = GyroMode::Mouse;
 };
-}
+
+template <>
+struct ConfigEnumRange<FrameInterpMode> {
+    static constexpr auto min = FrameInterpMode::Off;
+    static constexpr auto max = FrameInterpMode::Unlimited;
+};
+}  // namespace config
 
 // Persistent user settings
 
@@ -70,6 +95,7 @@ struct UserSettings {
         ConfigVar<bool> lockAspectRatio;
         ConfigVar<bool> enableFpsOverlay;
         ConfigVar<int> fpsOverlayCorner;
+        ConfigVar<int> maxFrameRate;
     } video;
 
     struct {
@@ -115,14 +141,17 @@ struct UserSettings {
         ConfigVar<bool> enableLinkDollRotation;
         ConfigVar<bool> enableAchievementToasts;
         ConfigVar<bool> enableControllerToasts;
+        ConfigVar<bool> enableDiscordPresence;
 
         // Graphics
         ConfigVar<BloomMode> bloomMode;
         ConfigVar<float> bloomMultiplier;
         ConfigVar<bool> disableWaterRefraction;
-        ConfigVar<bool> enableFrameInterpolation;
+        ConfigVar<bool> enableTextureReplacements;
+        ConfigVar<FrameInterpMode> enableFrameInterpolation;
         ConfigVar<int> internalResolutionScale;
         ConfigVar<int> shadowResolutionMultiplier;
+        ConfigVar<Resampler> resampler;
         ConfigVar<bool> enableDepthOfField;
         ConfigVar<bool> enableMapBackground;
         ConfigVar<bool> disableCutscenePillarboxing;
@@ -155,6 +184,7 @@ struct UserSettings {
         // Cheats
         ConfigVar<bool> infiniteHearts;
         ConfigVar<bool> infiniteArrows;
+        ConfigVar<bool> infiniteSeeds;
         ConfigVar<bool> infiniteBombs;
         ConfigVar<bool> infiniteOil;
         ConfigVar<bool> infiniteOxygen;
@@ -168,12 +198,14 @@ struct UserSettings {
         ConfigVar<bool> fastRoll;
         ConfigVar<bool> fastSpinner;
         ConfigVar<bool> freeMagicArmor;
+        ConfigVar<bool> invincibleEnemies;
 
         // Technical
         ConfigVar<bool> restoreWiiGlitches;
 
         // Controls
         ConfigVar<bool> enableTurboKeybind;
+        ConfigVar<bool> enableResetKeybind;
 
         // Tools
         ConfigVar<bool> speedrunMode;
@@ -181,6 +213,8 @@ struct UserSettings {
         ConfigVar<bool> showSpeedrunRTATimer;
         ConfigVar<bool> recordingMode;
         ConfigVar<bool> removeQuestMapMarkers;
+        ConfigVar<bool> showInputViewer;
+        ConfigVar<bool> showInputViewerGyro;
     } game;
 
     struct {
@@ -194,6 +228,14 @@ struct UserSettings {
         ConfigVar<int> cardFileType;
         ConfigVar<bool> enableAdvancedSettings;
     } backend;
+
+    // Arrays of size 4 for 4 ports
+    struct {
+        std::array<ActionBindConfigVar, 4> firstPersonCamera;
+        std::array<ActionBindConfigVar, 4> callMidna;
+        std::array<ActionBindConfigVar, 4> openDusklightMenu;
+        std::array<ActionBindConfigVar, 4> turboSpeedButton;
+    } actionBindings;
 };
 
 UserSettings& getSettings();

include/dusk/time.h

@@ -17,16 +17,24 @@
 #include <shellapi.h>
 #include <intrin.h>
 #endif
+#ifdef __APPLE__
+#include <mach/mach_time.h>
+#if defined(__x86_64__) || defined(__i386__)
+#include <immintrin.h>
+#endif
+#endif
 
 class Limiter {
 public:
   using duration_t = Uint64;
 
-  void Reset() { m_oldTime = SDL_GetTicksNS(); }
+  void Reset() { 
+    m_oldTime = SDL_GetTicksNS(); 
+  }
 
-  void Sleep(duration_t targetFrameTime) {
+  duration_t Sleep(duration_t targetFrameTime) {
     if (targetFrameTime == 0) {
-      return;
+      return 0;
     }
 
     const Uint64 start = SDL_GetTicksNS();
@@ -41,6 +49,8 @@ public:
       }
     }
     Reset();
+
+    return adjustedSleepTime;
   }
 
   duration_t SleepTime(duration_t targetFrameTime) {
@@ -74,7 +84,6 @@ private:
     if (!initialized || numSleeps++ % 1000 == 0) {
       LARGE_INTEGER freq;
       if (QueryPerformanceFrequency(&freq) == 0) {
-        DuskLog.warn("QueryPerformanceFrequency failed: {}", GetLastError());
         return;
       }
       countPerNs = static_cast<double>(freq.QuadPart) / 1e9;
@@ -98,6 +107,33 @@ private:
 #endif
     } while (current.QuadPart - start.QuadPart < ticksToWait);
   }
+#elif defined (__APPLE__)
+  void NanoSleep(const duration_t duration) {
+      // Hybrid approach using Apple Mach
+      uint64_t start_mach = mach_absolute_time();
+
+      mach_timebase_info_data_t timebase_info;
+      mach_timebase_info(&timebase_info);
+
+      uint64_t total_mach_ticks = (duration * timebase_info.denom) / timebase_info.numer;
+      uint64_t target_mach = start_mach + total_mach_ticks;
+
+      uint64_t buffer_ns = 2'000'000ULL;
+      uint64_t buffer_mach_ticks = (buffer_ns * timebase_info.denom) / timebase_info.numer;
+
+      if (total_mach_ticks > buffer_mach_ticks) {
+          uint64_t sleep_until_mach = target_mach - buffer_mach_ticks;
+          mach_wait_until(sleep_until_mach);
+      }
+
+      while (mach_absolute_time() < target_mach) {
+#if defined(__aarch64__) || defined(__arm__)
+          asm volatile("yield" ::: "memory");  // Hardware hint, not a scheduler hint.
+#else
+          _mm_pause();
+#endif
+      }
+  }
 #else
   void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration); }
 #endif

include/f_op/f_op_actor_mng.h

@@ -108,7 +108,7 @@ struct fopAcM_search_prm {
 struct fOpAcm_HIO_entry_c : public mDoHIO_entry_c {
     virtual ~fOpAcm_HIO_entry_c() {}
 
-    #if DEBUG
+    #if DEBUG && !TARGET_PC
     void removeHIO(const fopAc_ac_c* i_this) { removeHIO(*i_this); }
     void removeHIO(const fopAc_ac_c& i_this) { removeHIO(i_this.base); }
     void removeHIO(const fopEn_enemy_c& i_this) { removeHIO(i_this.base); }