From ad53af5c78dd0dba1e878d4582f03d276503b044 Mon Sep 17 00:00:00 2001 From: Luke Street Date: Mon, 15 Jun 2026 12:48:04 -0600 Subject: [PATCH] Touch controls (#2053) * WIP touch controls * Action icons * Updates * Don't mutate freeCamera config; allow switching between touch and controller cam * Wow * Fix build & add Skip button * Fix build & add settings * RCSS cleanup * Dpad and fishing, might redo * Add menu mouse controls * More pointer & fix icons * Optimizations & introduce layout system * Update aurora * Implement touch controls layout editor * Cleanup & fixes * Allow disabling mouse/touch in menus * More fixes --- extern/aurora | 2 +- files.cmake | 12 + include/d/d_camera.h | 2 +- include/d/d_file_select.h | 4 + include/d/d_menu_collect.h | 2 + include/d/d_menu_insect.h | 4 + include/d/d_menu_letter.h | 4 + include/d/d_menu_option.h | 3 + include/d/d_menu_ring.h | 3 + include/d/d_menu_save.h | 2 + include/d/d_menu_skill.h | 4 + include/d/d_msg_scrn_3select.h | 4 + include/dusk/action_bindings.h | 8 + include/dusk/config_var.hpp | 11 +- include/dusk/menu_pointer.h | 60 + include/dusk/settings.h | 31 +- include/dusk/touch_camera.h | 12 + .../include/JSystem/J2DGraph/J2DPicture.h | 3 + res/rml/overlay.rcss | 2 +- res/rml/touch_controls.rcss | 340 ++++ res/rml/touch_controls_editor.rcss | 138 ++ src/d/actor/d_a_alink_link.inc | 27 + src/d/d_camera.cpp | 49 +- src/d/d_file_select.cpp | 260 ++++ src/d/d_menu_collect.cpp | 91 ++ src/d/d_menu_fmap2D.cpp | 13 + src/d/d_menu_insect.cpp | 43 + src/d/d_menu_letter.cpp | 67 + src/d/d_menu_option.cpp | 132 ++ src/d/d_menu_ring.cpp | 81 + src/d/d_menu_save.cpp | 155 +- src/d/d_menu_skill.cpp | 38 + src/d/d_meter2.cpp | 8 + src/d/d_meter2_draw.cpp | 35 + src/d/d_meter_map.cpp | 53 +- src/d/d_msg_class.cpp | 15 + src/d/d_msg_object.cpp | 20 +- src/d/d_msg_scrn_3select.cpp | 55 + src/d/d_msg_scrn_explain.cpp | 4 + src/dusk/action_bindings.cpp | 81 +- src/dusk/config.cpp | 274 +++- src/dusk/gyro.cpp | 11 +- src/dusk/menu_pointer.cpp | 386 +++++ src/dusk/mouse.cpp | 14 +- src/dusk/settings.cpp | 30 + src/dusk/touch_camera.cpp | 26 + src/dusk/ui/button.hpp | 2 - src/dusk/ui/controller_config.cpp | 14 + src/dusk/ui/controls.hpp | 192 +++ src/dusk/ui/document.cpp | 36 +- src/dusk/ui/document.hpp | 11 +- src/dusk/ui/icon_provider.cpp | 899 +++++++++++ src/dusk/ui/icon_provider.hpp | 23 + src/dusk/ui/overlay.cpp | 4 +- src/dusk/ui/preset.cpp | 2 + src/dusk/ui/settings.cpp | 39 + src/dusk/ui/touch_controls.cpp | 1372 +++++++++++++++++ src/dusk/ui/touch_controls.hpp | 133 ++ src/dusk/ui/touch_controls_common.cpp | 359 +++++ src/dusk/ui/touch_controls_common.hpp | 45 + src/dusk/ui/touch_controls_editor.cpp | 630 ++++++++ src/dusk/ui/touch_controls_editor.hpp | 98 ++ src/dusk/ui/ui.cpp | 11 +- src/f_ap/f_ap_game.cpp | 3 + src/m_Do/m_Do_controller_pad.cpp | 14 + src/m_Do/m_Do_main.cpp | 2 + 66 files changed, 6372 insertions(+), 136 deletions(-) create mode 100644 include/dusk/menu_pointer.h create mode 100644 include/dusk/touch_camera.h create mode 100644 res/rml/touch_controls.rcss create mode 100644 res/rml/touch_controls_editor.rcss create mode 100644 src/dusk/menu_pointer.cpp create mode 100644 src/dusk/touch_camera.cpp create mode 100644 src/dusk/ui/controls.hpp create mode 100644 src/dusk/ui/icon_provider.cpp create mode 100644 src/dusk/ui/icon_provider.hpp create mode 100644 src/dusk/ui/touch_controls.cpp create mode 100644 src/dusk/ui/touch_controls.hpp create mode 100644 src/dusk/ui/touch_controls_common.cpp create mode 100644 src/dusk/ui/touch_controls_common.hpp create mode 100644 src/dusk/ui/touch_controls_editor.cpp create mode 100644 src/dusk/ui/touch_controls_editor.hpp diff --git a/extern/aurora b/extern/aurora index e3fd6b1900..f49d3c5f58 160000 --- a/extern/aurora +++ b/extern/aurora @@ -1 +1 @@ -Subproject commit e3fd6b19008e40ba3888099e3c4555c9958e1c21 +Subproject commit f49d3c5f58aa2fd3e21f73a129e07c1df68aaa98 diff --git a/files.cmake b/files.cmake index a920db2e4f..715622a495 100644 --- a/files.cmake +++ b/files.cmake @@ -1434,6 +1434,8 @@ set(DUSK_FILES src/dusk/game_clock.cpp src/dusk/globals.cpp src/dusk/gyro.cpp + include/dusk/menu_pointer.h + src/dusk/menu_pointer.cpp src/dusk/mouse.cpp src/dusk/gamepad_color.cpp src/dusk/autosave.cpp @@ -1447,6 +1449,7 @@ set(DUSK_FILES src/dusk/stubs.cpp include/dusk/texture_replacements.hpp src/dusk/texture_replacements.cpp + src/dusk/touch_camera.cpp src/dusk/update_check.cpp src/dusk/update_check.hpp #src/dusk/m_Do_ext_dusk.cpp @@ -1476,6 +1479,7 @@ set(DUSK_FILES src/dusk/ui/button.hpp src/dusk/ui/component.cpp src/dusk/ui/component.hpp + src/dusk/ui/controls.hpp src/dusk/ui/controller_config.cpp src/dusk/ui/controller_config.hpp src/dusk/ui/document.cpp @@ -1488,6 +1492,8 @@ set(DUSK_FILES src/dusk/ui/graphics_tuner.hpp src/dusk/ui/input.cpp src/dusk/ui/input.hpp + src/dusk/ui/icon_provider.cpp + src/dusk/ui/icon_provider.hpp src/dusk/ui/modal.cpp src/dusk/ui/modal.hpp src/dusk/ui/nav_types.hpp @@ -1513,6 +1519,12 @@ set(DUSK_FILES src/dusk/ui/string_button.hpp src/dusk/ui/tab_bar.cpp src/dusk/ui/tab_bar.hpp + src/dusk/ui/touch_controls_common.cpp + src/dusk/ui/touch_controls_common.hpp + src/dusk/ui/touch_controls.cpp + src/dusk/ui/touch_controls.hpp + src/dusk/ui/touch_controls_editor.cpp + src/dusk/ui/touch_controls_editor.hpp src/dusk/ui/ui.cpp src/dusk/ui/ui.hpp src/dusk/ui/warp.cpp diff --git a/include/d/d_camera.h b/include/d/d_camera.h index 0698bbbe5a..f98667d988 100644 --- a/include/d/d_camera.h +++ b/include/d/d_camera.h @@ -1037,7 +1037,7 @@ public: bool test1Camera(s32); bool test2Camera(s32); #if TARGET_PC - static bool canUseFreeCam(); + static bool isAimActive(); bool freeCamera(); bool executeDebugFlyCam(); void deactivateDebugFlyCam(); diff --git a/include/d/d_file_select.h b/include/d/d_file_select.h index 75fbb63fd9..634c0db352 100644 --- a/include/d/d_file_select.h +++ b/include/d/d_file_select.h @@ -416,6 +416,10 @@ public: bool yesnoWakuAlpahAnm(u8); #if TARGET_PC void fileSelectWide(); + bool pointerDataSelect(); + bool pointerMenuSelect(); + bool pointerCopyDataToSelect(); + bool pointerYesNoSelect(bool errorSelect); #endif void _draw(); void errorMoveAnmInitSet(int, int); diff --git a/include/d/d_menu_collect.h b/include/d/d_menu_collect.h index 28a095896e..d99b8f17cb 100644 --- a/include/d/d_menu_collect.h +++ b/include/d/d_menu_collect.h @@ -74,6 +74,8 @@ public: #if TARGET_PC void menuCollectWide(); + bool pointerWait(); + void pointerActivateCurrent(); #endif void _create(); diff --git a/include/d/d_menu_insect.h b/include/d/d_menu_insect.h index 6b23a3845d..90cfca7d5a 100644 --- a/include/d/d_menu_insect.h +++ b/include/d/d_menu_insect.h @@ -51,6 +51,10 @@ public: void setBButtonString(u16); void setHIO(bool); +#if TARGET_PC + bool pointerWait(); +#endif + virtual void draw() { _draw(); } virtual ~dMenu_Insect_c(); diff --git a/include/d/d_menu_letter.h b/include/d/d_menu_letter.h index 163c381699..208f8b65a9 100644 --- a/include/d/d_menu_letter.h +++ b/include/d/d_menu_letter.h @@ -55,6 +55,10 @@ public: u8 getLetterNum(); void setHIO(bool); +#if TARGET_PC + bool pointerWait(); +#endif + virtual void draw() { _draw(); } virtual ~dMenu_Letter_c(); diff --git a/include/d/d_menu_option.h b/include/d/d_menu_option.h index 7204d62974..03aca42808 100644 --- a/include/d/d_menu_option.h +++ b/include/d/d_menu_option.h @@ -80,6 +80,9 @@ public: void setBButtonString(u16); bool isRumbleSupported(); bool dpdMenuMove(); +#if TARGET_PC + bool pointerConfirmSelect(); +#endif void paneResize(u64); void initialize(); void yesnoMenuMoveAnmInitSet(int, int); diff --git a/include/d/d_menu_ring.h b/include/d/d_menu_ring.h index 74624eac80..f2137a9748 100644 --- a/include/d/d_menu_ring.h +++ b/include/d/d_menu_ring.h @@ -74,6 +74,9 @@ public: void clacEllipsePlotAverage(int, f32, f32); bool dpdMove(); u8 openExplain(u8); +#if TARGET_PC + bool pointerMove(); +#endif virtual void draw() { _draw(); } virtual ~dMenu_Ring_c(); diff --git a/include/d/d_menu_save.h b/include/d/d_menu_save.h index 116795f7be..d9d052aa33 100644 --- a/include/d/d_menu_save.h +++ b/include/d/d_menu_save.h @@ -266,6 +266,8 @@ public: #if TARGET_PC void menuSaveWide(); + bool pointerSaveSelect(); + bool pointerYesNoSelect(bool errorSelect, u8 errParam = 0, u8 soundParam = 0); #endif void _draw2(); diff --git a/include/d/d_menu_skill.h b/include/d/d_menu_skill.h index 9ea305163e..2f9097b165 100644 --- a/include/d/d_menu_skill.h +++ b/include/d/d_menu_skill.h @@ -49,6 +49,10 @@ public: u8 getSkillNum(); void setHIO(bool); +#if TARGET_PC + bool pointerWait(); +#endif + virtual void draw() { _draw(); } virtual ~dMenu_Skill_c(); diff --git a/include/d/d_msg_scrn_3select.h b/include/d/d_msg_scrn_3select.h index 949db3f130..1cb92e5be6 100644 --- a/include/d/d_msg_scrn_3select.h +++ b/include/d/d_msg_scrn_3select.h @@ -49,6 +49,10 @@ public: void selectScale(); void selectTrans(); void selectAnimeTransform(int); +#if TARGET_PC + bool pointerMove(); + bool consumePointerClick(); +#endif void setOffsetX(f32 i_offsetX) { mOffsetX = i_offsetX; } bool isAnimeUpdate(int param_0) { return (field_0x114 & (u8)(1 << param_0)) ? TRUE : FALSE; } diff --git a/include/dusk/action_bindings.h b/include/dusk/action_bindings.h index 7eba412fe8..a71dac5dfe 100644 --- a/include/dusk/action_bindings.h +++ b/include/dusk/action_bindings.h @@ -9,6 +9,8 @@ namespace dusk { enum class ActionBinds { FIRST_PERSON_CAMERA, CALL_MIDNA, + OPEN_MAP_SCREEN, + TOGGLE_MINIMAP, OPEN_DUSKLIGHT_MENU, TURBO_SPEED_BUTTON, COUNT, @@ -32,6 +34,12 @@ bool isActionBound(ActionBinds action, u32 port); void updateActionBindings(); +void setVirtualActionBind(ActionBinds action, u32 port, bool pressed, bool available = true); + +void clearVirtualActionBind(ActionBinds action, u32 port); + +void clearAllVirtualActionBinds(); + bool getActionBindTrig(ActionBinds action, u32 port); bool getActionBindHold(ActionBinds action, u32 port); diff --git a/include/dusk/config_var.hpp b/include/dusk/config_var.hpp index 0bae27bfd3..258bf4143c 100644 --- a/include/dusk/config_var.hpp +++ b/include/dusk/config_var.hpp @@ -4,6 +4,7 @@ #include "dolphin/types.h" #include #include +#include #include /** @@ -139,11 +140,16 @@ concept ConfigValueInteger = || std::is_same_v || std::is_same_v; +template +struct ConfigValueTraits { + static constexpr bool enabled = false; +}; + /** * \brief Concept that defines the legal set of types that can be used for CVar values. * * Valid types cannot be cv-qualified and must be basic primitive types (int, float, bool), - * strings, or enums of the basic primitives. + * strings, enums of the basic primitives, or explicitly-enabled structured settings. */ template concept ConfigValue = @@ -154,7 +160,8 @@ concept ConfigValue = || std::is_same_v || std::is_same_v || std::is_same_v - || (std::is_enum_v && ConfigValueInteger>)); + || (std::is_enum_v && ConfigValueInteger>) + || ConfigValueTraits::enabled); template const ConfigImplBase* GetConfigImpl(); diff --git a/include/dusk/menu_pointer.h b/include/dusk/menu_pointer.h new file mode 100644 index 0000000000..17546877d6 --- /dev/null +++ b/include/dusk/menu_pointer.h @@ -0,0 +1,60 @@ +#pragma once + +#include "dolphin/types.h" + +class CPaneMgr; + +namespace dusk::menu_pointer { + +enum class Context { + None, + FileSelect, + Save, + ItemWheel, + Collection, + Options, + Dialog, +}; + +enum class Phase { + Move, + Press, + Release, + Cancel, +}; + +struct State { + f32 x = 0.0f; + f32 y = 0.0f; + bool valid = false; + bool down = false; + bool pressed = false; + bool released = false; + bool clicked = false; + bool touch = false; +}; + +void begin_game_frame() noexcept; +void end_game_frame() noexcept; +void begin_context(Context context) noexcept; +bool handle_fallthrough_pointer(f32 x, f32 y, Phase phase, bool touch, s32 mouseButton = -1) noexcept; + +bool active() noexcept; +bool enabled() noexcept; +bool mouse_capture_active() noexcept; +const State& state() noexcept; +bool consume_click() noexcept; +void set_dialog_choice(u8 choice, bool clicked) noexcept; +bool get_dialog_choice(u8& choice) noexcept; +bool consume_dialog_click(u8& choice) noexcept; +void defer_activation(Context context, u8 target) noexcept; +bool consume_deferred_activation(Context context, u8 target) noexcept; +void clear_deferred_activation(Context context) noexcept; +u32 suppressed_pad_buttons(u32 port) noexcept; +void finish_pad_suppression_read(u32 port) noexcept; + +bool hit_rect(f32 left, f32 top, f32 right, f32 bottom, f32 padding = 0.0f) noexcept; +bool hit_pane(CPaneMgr* pane, f32 padding = 0.0f) noexcept; +bool hit_pane(J2DPane* pane, f32 padding = 0.0f) noexcept; + +} // namespace dusk::menu_pointer diff --git a/include/dusk/settings.h b/include/dusk/settings.h index da8055b225..e4b28686ff 100644 --- a/include/dusk/settings.h +++ b/include/dusk/settings.h @@ -1,9 +1,9 @@ -#ifndef DUSK_CONFIG_H -#define DUSK_CONFIG_H +#pragma once #include #include "dusk/config_var.hpp" +#include "dusk/ui/controls.hpp" namespace dusk { @@ -40,11 +40,6 @@ enum class DiscVerificationState : u8 { HashMismatch, }; -enum class GyroMode : u8 { - Sensor = 0, - Mouse = 1, -}; - enum class FrameInterpMode : u8 { Off = 0, Capped = 1, @@ -96,12 +91,6 @@ struct ConfigEnumRange { static constexpr auto max = DiscVerificationState::HashMismatch; }; -template <> -struct ConfigEnumRange { - static constexpr auto min = GyroMode::Sensor; - static constexpr auto max = GyroMode::Mouse; -}; - template <> struct ConfigEnumRange { static constexpr auto min = FrameInterpMode::Off; @@ -119,6 +108,11 @@ struct ConfigEnumRange { static constexpr auto min = MagicArmorMode::NORMAL; static constexpr auto max = MagicArmorMode::COSMETIC; }; + +template <> +struct ConfigValueTraits { + static constexpr bool enabled = true; +}; } // namespace config // Persistent user settings @@ -221,6 +215,9 @@ struct UserSettings { ConfigVar mouseCameraSensitivity; ConfigVar invertMouseY; ConfigVar freeCamera; + ConfigVar enableTouchControls; + ConfigVar enableMenuPointer; + ConfigVar touchControlsLayout; ConfigVar invertCameraXAxis; ConfigVar invertCameraYAxis; ConfigVar invertFirstPersonXAxis; @@ -229,6 +226,8 @@ struct UserSettings { ConfigVar invertAirSwimY; ConfigVar freeCameraXSensitivity; ConfigVar freeCameraYSensitivity; + ConfigVar touchCameraXSensitivity; + ConfigVar touchCameraYSensitivity; ConfigVar debugFlyCam; ConfigVar debugFlyCamLockEvents; ConfigVar allowBackgroundInput; @@ -287,6 +286,8 @@ struct UserSettings { struct { std::array firstPersonCamera; std::array callMidna; + std::array openMapScreen; + std::array toggleMinimap; std::array openDusklightMenu; std::array turboSpeedButton; } actionBindings; @@ -318,6 +319,4 @@ struct TransientSettings { TransientSettings& getTransientSettings(); -} - -#endif // DUSK_CONFIG_H +} // namespace dusk diff --git a/include/dusk/touch_camera.h b/include/dusk/touch_camera.h new file mode 100644 index 0000000000..d1680afed1 --- /dev/null +++ b/include/dusk/touch_camera.h @@ -0,0 +1,12 @@ +#pragma once + +namespace dusk::touch_camera { + +constexpr float YAW_DEGREES_PER_DP = 0.34f; +constexpr float PITCH_DEGREES_PER_DP = 0.22f; + +void add_delta(float yaw_dp, float pitch_dp) noexcept; +bool consume_delta(float& yaw_dp, float& pitch_dp) noexcept; +void clear() noexcept; + +} // namespace dusk::touch_camera diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h b/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h index b054c97fae..f738a96dd4 100644 --- a/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h +++ b/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h @@ -212,6 +212,9 @@ public: void setCornerColor(JUtility::TColor c0) { setCornerColor(c0, c0, c0, c0); } +#if TARGET_PC + JUtility::TColor corner(size_t index) const { return mCornerColor[index]; } +#endif protected: /* 0x100 */ JUTTexture* mTexture[2]; diff --git a/res/rml/overlay.rcss b/res/rml/overlay.rcss index 8927e1a01c..9a86843295 100644 --- a/res/rml/overlay.rcss +++ b/res/rml/overlay.rcss @@ -16,7 +16,7 @@ body { flex-direction: column; justify-content: flex-end; align-items: stretch; - z-index: 1; + z-index: 2; pointer-events: none; } diff --git a/res/rml/touch_controls.rcss b/res/rml/touch_controls.rcss new file mode 100644 index 0000000000..5bf42136ad --- /dev/null +++ b/res/rml/touch_controls.rcss @@ -0,0 +1,340 @@ +*, *:before, *:after { + box-sizing: border-box; +} + +body { + width: 100%; + height: 100%; + margin: 0; + padding: 0; + overflow: hidden; + font-family: "Fira Sans Condensed"; + font-weight: bold; + color: rgba(248, 244, 232, 90%); + z-index: 1; + filter: opacity(0); + transition: filter 0.2s linear-in-out; +} + +body[open] { + filter: opacity(1); +} + +body:not([open]) { + pointer-events: none; +} + +button { + display: flex; + align-items: center; + justify-content: center; + decorator: none; + padding: 0; + border: 1dp rgba(255, 255, 255, 22%); + background-color: rgba(22, 24, 28, 48%); + color: rgba(248, 244, 232, 90%); + text-align: center; + /* backdrop-filter: blur(7dp); */ + /* box-shadow: 0 6dp 18dp rgba(0, 0, 0, 28%); */ + transform-origin: center; + transition: background-color border-color filter transform 0.08s linear-in-out, + opacity 0.2s linear-in-out; +} + +button.pressed, +button.active { + background-color: rgba(63, 78, 90, 68%); + border-color: rgba(255, 255, 255, 48%); + filter: brightness(1.18); +} + +button:hidden { + opacity: 0; + pointer-events: none; +} + +button span { + display: block; + line-height: 1; +} + +button icon { + display: flex; + align-items: center; + justify-content: center; + width: 100%; + height: 100%; +} + +button icon glyph { + display: block; + font-family: "Material Symbols Rounded"; + font-weight: normal; + font-size: 24dp; + line-height: 1; +} + +.midna-icon, +.item-icon, +.item-count, +.oil-meter { + display: none; +} + +.midna-icon.visible, +.item-icon.visible, +.item-count.visible, +.oil-meter.visible { + display: block; +} + +.control { + position: absolute; +} + +.trigger-l.active { + background-color: rgba(57, 116, 133, 74%); + border-color: rgba(128, 222, 234, 72%); +} + +.trigger, +.skip { + border-radius: 23dp; +} + +.trigger { + font-size: 22dp; +} + +.button-z { + background-color: rgba(118, 79, 158, 58%); + border-color: rgba(203, 170, 255, 36%); +} + +.midna-icon { + position: absolute; + left: 9dp; + top: -1dp; + height: 48dp; +} + +.button-z.has-icon span, +.face.has-item span { + position: absolute; + font-size: 13dp; + line-height: 1; +} + +.button-z.has-icon span { + right: 9dp; + bottom: 7dp; +} + +.button-z.pressed { + background-color: rgba(139, 91, 187, 82%); + border-color: rgba(220, 194, 255, 70%); +} + +action-bar { + position: absolute; + display: flex; + align-items: center; + justify-content: stretch; + border: 1dp rgba(255, 255, 255, 22%); + border-radius: 23dp; + background-color: rgba(22, 24, 28, 48%); + /* backdrop-filter: blur(7dp); */ + /* box-shadow: 0 -6dp 18dp rgba(0, 0, 0, 28%); */ + overflow: hidden; + opacity: 1; + transform-origin: center; + transition: opacity 0.2s linear-in-out; +} + +action-bar:hidden, +action-bar:hidden button, +action-bar:hidden separator { + opacity: 0; + pointer-events: none; +} + +.utility { + position: relative; + flex: 1 1 auto; + width: 56dp; + height: 44dp; + margin: 0; + border-width: 0dp; + border-radius: 0; + background-color: transparent; + box-shadow: none; +} + +.utility, +.skip { + opacity: 0.55; +} + +.utility.pressed { + background-color: rgba(63, 78, 90, 68%); +} + +.utility.pressed, +.skip.pressed { + opacity: 1; +} + +.skip { + z-index: 1; + border-color: rgba(255, 255, 255, 36%); +} + +separator { + display: block; + flex: 0 0 1dp; + width: 1dp; + height: 24dp; + background-color: rgba(255, 255, 255, 18%); + opacity: 1; + transition: opacity 0.2s linear-in-out; +} + +.face { + position: absolute; + border-radius: 29dp; + font-size: 24dp; + overflow: visible; +} + +.item-icon { + width: auto; + height: auto; + max-width: 76%; + max-height: 76%; +} + +.item-count { + position: absolute; + left: 6dp; + bottom: 5dp; + min-width: 17dp; + height: 15dp; + padding: 1dp 3dp; + border-radius: 7dp; + background-color: rgba(0, 0, 0, 52%); + color: rgba(255, 255, 255, 92%); + font-size: 12dp; + line-height: 13dp; + text-align: center; +} + +.oil-meter { + position: absolute; + left: 12dp; + bottom: -5dp; + width: 34dp; + height: 8dp; + padding: 2dp; + border: 1dp rgba(42, 32, 18, 82%); + border-radius: 4dp; + background-color: rgba(18, 14, 10, 70%); + /* box-shadow: 0 2dp 6dp rgba(0, 0, 0, 35%); */ +} + +oil-fill { + display: block; + width: 0%; + height: 100%; + border-radius: 2dp; + background-color: rgb(255, 232, 74); +} + +.face.has-item span { + right: 6dp; + bottom: 6dp; + color: rgba(255, 255, 255, 88%); +} + +.face.a { + border-radius: 37dp; + font-size: 31dp; + background-color: rgba(34, 112, 123, 62%); +} + +.face.b { + background-color: rgba(161, 61, 66, 58%); +} + +.face.x { + background-color: rgba(83, 115, 151, 56%); +} + +.face.y { + background-color: rgba(113, 91, 150, 54%); +} + +button.control.docked-top, +action-bar.docked-top { + border-top-width: 0dp; + border-top-left-radius: 0dp; + border-top-right-radius: 0dp; +} + +button.control.docked-bottom, +action-bar.docked-bottom { + border-bottom-width: 0dp; + border-bottom-left-radius: 0dp; + border-bottom-right-radius: 0dp; +} + +button.control.docked-left, +action-bar.docked-left { + border-left-width: 0dp; + border-top-left-radius: 0dp; + border-bottom-left-radius: 0dp; +} + +button.control.docked-right, +action-bar.docked-right { + border-right-width: 0dp; + border-top-right-radius: 0dp; + border-bottom-right-radius: 0dp; +} + +touch-stick { + display: block; + position: absolute; + width: 124dp; + height: 124dp; + border-radius: 62dp; + background-color: rgba(18, 20, 24, 35%); + border: 1dp rgba(255, 255, 255, 20%); + /* backdrop-filter: blur(7dp); */ + /* box-shadow: 0 8dp 24dp rgba(0, 0, 0, 24%); */ + opacity: 0; + pointer-events: none; + transition: opacity 0.18s linear-in-out; +} + +touch-stick.active { + opacity: 1; +} + +stick-ring { + position: absolute; + left: 18dp; + top: 18dp; + width: 88dp; + height: 88dp; + border-radius: 44dp; + border: 1dp rgba(255, 255, 255, 18%); +} + +stick-knob { + position: absolute; + width: 48dp; + height: 48dp; + border-radius: 24dp; + background-color: rgba(238, 236, 226, 55%); + border: 1dp rgba(255, 255, 255, 45%); +} diff --git a/res/rml/touch_controls_editor.rcss b/res/rml/touch_controls_editor.rcss new file mode 100644 index 0000000000..2ca99d935a --- /dev/null +++ b/res/rml/touch_controls_editor.rcss @@ -0,0 +1,138 @@ +body.touch-editor { + background-color: rgba(4, 6, 8, 34%); + z-index: 8; +} + +body.touch-editor .control, +body.touch-editor action-bar { + opacity: 0.88; + cursor: move; + pointer-events: auto; +} + +body.touch-editor .control:hover, +body.touch-editor action-bar:hover, +body.touch-editor .control.editor-selected, +body.touch-editor action-bar.editor-selected { + border-color: rgba(255, 232, 128, 80%); + filter: brightness(1.15); +} + +body.touch-editor action-bar button, +body.touch-editor action-bar separator { + pointer-events: none; +} + +selection-frame { + display: none; + position: absolute; + z-index: 20; + border: 2dp rgba(255, 232, 128, 88%); + background-color: rgba(255, 232, 128, 7%); + pointer-events: none; +} + +selection-frame.visible { + display: block; +} + +resize-handle { + display: block; + position: absolute; + width: 22dp; + height: 22dp; + border: 2dp rgba(255, 244, 190, 96%); + border-radius: 11dp; + background-color: rgba(34, 37, 42, 86%); + pointer-events: auto; +} + +resize-handle.left { + left: -12dp; +} + +resize-handle.right { + right: -12dp; +} + +resize-handle.top { + top: -12dp; +} + +resize-handle.bottom { + bottom: -12dp; +} + +resize-handle.horizontal { + top: 50%; + margin-top: -11dp; +} + +resize-handle.vertical { + left: 50%; + margin-left: -11dp; +} + +resize-handle.corner.left { + left: -12dp; +} + +resize-handle.corner.right { + right: -12dp; +} + +resize-handle.corner.top { + top: -12dp; +} + +resize-handle.corner.bottom { + bottom: -12dp; +} + +editor-toolbar { + display: flex; + position: absolute; + left: 24dp; + right: 24dp; + top: 50%; + z-index: 30; + height: 48dp; + margin-top: -24dp; + gap: 8dp; + justify-content: center; + pointer-events: auto; +} + +editor-toolbar button.editor-command { + flex: 0 1 150dp; + min-width: 96dp; + height: 48dp; + padding: 0 14dp; + border-radius: 8dp; + border: 1dp rgba(255, 255, 255, 26%); + background-color: rgba(17, 19, 24, 88%); + color: rgba(255, 250, 232, 94%); + font-family: "Fira Sans"; + font-size: 18dp; + line-height: 48dp; + opacity: 1; + cursor: pointer; +} + +editor-toolbar button.editor-command span { + display: block; + width: 100%; + line-height: 48dp; + text-align: center; +} + +editor-toolbar button.editor-command.primary { + border-color: rgba(255, 232, 128, 70%); + background-color: rgba(96, 82, 38, 90%); +} + +editor-toolbar button.editor-command:hover, +editor-toolbar button.editor-command:focus-visible { + border-color: rgba(255, 244, 190, 92%); + background-color: rgba(78, 85, 96, 92%); +} diff --git a/src/d/actor/d_a_alink_link.inc b/src/d/actor/d_a_alink_link.inc index 4d93f39457..0cf53edf3e 100644 --- a/src/d/actor/d_a_alink_link.inc +++ b/src/d/actor/d_a_alink_link.inc @@ -14,6 +14,7 @@ #include "dusk/action_bindings.h" #include "dusk/gyro.h" #include "dusk/mouse.h" +#include "dusk/touch_camera.h" #endif bool daAlink_c::checkNoSubjectModeCamera() { @@ -172,6 +173,32 @@ BOOL daAlink_c::setBodyAngleToCamera() { sp8 = mBodyAngle.x; } } + + if (dusk::getSettings().game.enableTouchControls && checkAimContext()) { + f32 touchYawDp = 0.0f; + f32 touchPitchDp = 0.0f; + if (dusk::touch_camera::consume_delta(touchYawDp, touchPitchDp)) { + f32 scale = 1.0f; + if (checkWolfEyeUp()) { + scale *= 0.6f; + } + if (dComIfGp_checkPlayerStatus0(0, 0x200000)) { + scale /= dComIfGp_getCameraZoomScale(field_0x317c); + } + + const f32 yawDeg = -touchYawDp * dusk::touch_camera::YAW_DEGREES_PER_DP * scale * + dusk::getSettings().game.touchCameraXSensitivity; + const f32 pitchDeg = touchPitchDp * dusk::touch_camera::PITCH_DEGREES_PER_DP * + scale * dusk::getSettings().game.touchCameraYSensitivity; + + shape_angle.y = shape_angle.y + cM_deg2s(yawDeg); + sp8 = sp8 + cM_deg2s(pitchDeg); + + if (checkNotItemSinkLimit() && sp8 > 0 && sp8 > mBodyAngle.x) { + sp8 = mBodyAngle.x; + } + } + } #endif if (checkNotItemSinkLimit() && sp8 > 0) { diff --git a/src/d/d_camera.cpp b/src/d/d_camera.cpp index 50e9f073b6..483e052312 100644 --- a/src/d/d_camera.cpp +++ b/src/d/d_camera.cpp @@ -34,6 +34,7 @@ #include "dusk/action_bindings.h" #include "dusk/mouse.h" #include "dusk/settings.h" +#include "dusk/touch_camera.h" #include "imgui.h" #endif @@ -7499,6 +7500,15 @@ static constexpr s16 FLYCAM_ROLL_SPEED = 256; static ImVec2 sFlyCamLastMousePos = {-1.f, -1.f}; #if TARGET_PC +static constexpr f32 TOUCH_CAMERA_CSTICK_EXIT_THRESHOLD = 0.05f; +static bool sTouchFreeCameraActive = false; + +bool dCamera_c::isAimActive() { + auto* link = daAlink_getAlinkActorClass(); + return link != nullptr && link->checkAimContext() && + dComIfGp_checkCameraAttentionStatus(link->field_0x317c, 0x10); +} + bool dCamera_c::executeDebugFlyCam() { if (!dusk::getSettings().game.debugFlyCam) { if (mDebugFlyCam.initialized) { @@ -7640,16 +7650,30 @@ void dCamera_c::deactivateDebugFlyCam() { mDebugFlyCam.initialized = false; } -bool dCamera_c::canUseFreeCam() { - return dusk::getSettings().game.freeCamera || dusk::getSettings().game.enableMouseCamera; -} - bool dCamera_c::freeCamera() { - if (canUseFreeCam() && mGear == 1) { + f32 touchYawDp = 0.0f; + f32 touchPitchDp = 0.0f; + bool touchCameraMoved = false; + const bool touchControlsEnabled = dusk::getSettings().game.enableTouchControls; + if (touchControlsEnabled && !isAimActive()) { + touchCameraMoved = dusk::touch_camera::consume_delta(touchYawDp, touchPitchDp); + } + if (!touchControlsEnabled || + mPadInfo.mCStick.mLastValue > TOUCH_CAMERA_CSTICK_EXIT_THRESHOLD) + { + sTouchFreeCameraActive = false; + } + if (touchCameraMoved) { + sTouchFreeCameraActive = true; + } + + const bool useFreeCamera = dusk::getSettings().game.freeCamera || + dusk::getSettings().game.enableMouseCamera || sTouchFreeCameraActive; + if (useFreeCamera && mGear == 1) { mGear = 0; } - if (!canUseFreeCam() || mCamStyle == 70) + if (!useFreeCamera || mCamStyle == 70) { mCamParam.mManualMode = 0; return false; @@ -7660,6 +7684,17 @@ bool dCamera_c::freeCamera() { mCamParam.freeYAngle = mViewCache.mDirection.mInclination.Degree(); } + if (touchCameraMoved) { + mCamParam.mManualMode = 1; + const f32 yawInput = dusk::getSettings().game.invertCameraXAxis ? -touchYawDp : touchYawDp; + const f32 pitchInput = + touchPitchDp * (dusk::getSettings().game.invertCameraYAxis ? -1.0f : 1.0f); + mCamParam.freeXAngle += yawInput * dusk::getSettings().game.touchCameraXSensitivity * + dusk::touch_camera::YAW_DEGREES_PER_DP; + mCamParam.freeYAngle += pitchInput * dusk::getSettings().game.touchCameraYSensitivity * + dusk::touch_camera::PITCH_DEGREES_PER_DP; + } + 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); @@ -11359,7 +11394,7 @@ static int camera_execute(camera_process_class* i_this) { const auto target = get_target_trim_height(i_this); const auto step = dusk::frame_interp::get_interpolation_step(); const auto cur = camera->TrimHeight(); - const auto prev = (4.0f * cur - target) / 3.0f; + const auto prev = (4.0f * cur - target) / 3.0f; const auto trim_height = prev + (cur - prev) * step; widezoom_correction(i_this, trim_height); diff --git a/src/d/d_file_select.cpp b/src/d/d_file_select.cpp index 27b18c202a..6e5e2e4954 100644 --- a/src/d/d_file_select.cpp +++ b/src/d/d_file_select.cpp @@ -23,8 +23,22 @@ #include "m_Do/m_Do_graphic.h" #include +#if TARGET_PC +#include "dusk/menu_pointer.h" #include "dusk/string.hpp" +namespace { +constexpr u8 pointer_target(u8 group, u8 index) noexcept { + return static_cast((group << 4) | (index & 0x0F)); +} + +constexpr u8 s_pointerDataSelectTarget = 0; +constexpr u8 s_pointerMenuSelectTarget = 1; +constexpr u8 s_pointerCopySelectTarget = 2; +constexpr u8 s_pointerYesNoSelectTarget = 3; +} // namespace +#endif + static s32 SelStartFrameTbl[3] = { 59, 99, @@ -756,8 +770,143 @@ void dFile_select_c::dataSelectInit() { } } +#if TARGET_PC +bool dFile_select_c::pointerDataSelect() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + for (u8 i = 0; i < 3; ++i) { + if (!dusk::menu_pointer::hit_pane(mSelFilePanes[i], 8.0f)) { + continue; + } + const bool clicked = dusk::menu_pointer::consume_click(); + if (mSelectNum != i) { + mDoAud_seStart(Z2SE_FILE_SELECT_CURSOR, NULL, 0, 0); + mLastSelectNum = mSelectNum; + mSelectNum = i; + if (clicked) { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerDataSelectTarget, i)); + } + dataSelectAnmSet(); + mDataSelProc = DATASELPROC_DATA_SELECT_MOVE_ANIME; + return true; + } + if (clicked) { + dataSelectStart(); + return true; + } + } + return false; +} + +bool dFile_select_c::pointerMenuSelect() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + for (u8 i = 0; i < 3; ++i) { + if (!dusk::menu_pointer::hit_pane(m3mSelPane[i], 8.0f)) { + continue; + } + const bool clicked = dusk::menu_pointer::consume_click(); + if (!mIsDataNew[mSelectNum] && mSelectMenuNum != i) { + mDoAud_seStart(Z2SE_SY_MENU_CURSOR_COMMON, NULL, 0, 0); + mLastSelectMenuNum = mSelectMenuNum; + mSelectMenuNum = i; + if (clicked) { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerMenuSelectTarget, i)); + } + menuSelectAnmSet(); + mDataSelProc = DATASELPROC_MENU_SELECT_MOVE_ANM; + return true; + } + if (clicked) { + menuSelectStart(); + return true; + } + } + return false; +} + +bool dFile_select_c::pointerCopyDataToSelect() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + for (u8 i = 0; i < 2; ++i) { + if (!dusk::menu_pointer::hit_pane(mCpSelPane[i], 8.0f)) { + continue; + } + const bool clicked = dusk::menu_pointer::consume_click(); + if (field_0x026b != i) { + mDoAud_seStart(Z2SE_FILE_SELECT_CURSOR, NULL, 0, 0); + field_0x026c = field_0x026b; + field_0x026b = i; + if (clicked) { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerCopySelectTarget, i)); + } + copyDataToSelectMoveAnmSet(); + mDataSelProc = DATASELPROC_COPY_DATA_TO_SELECT_MOVE_ANM; + return true; + } + if (clicked) { + copyDataToSelectStart(); + return true; + } + } + return false; +} + +bool dFile_select_c::pointerYesNoSelect(bool errorSelect) { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + for (u8 i = 0; i < 2; ++i) { + if (!dusk::menu_pointer::hit_pane(mYnSelPane[i], 8.0f)) { + continue; + } + const bool clicked = + (!errorSelect || field_0x0268 == i) && dusk::menu_pointer::consume_click(); + if (field_0x0268 != i) { + field_0x0269 = field_0x0268; + field_0x0268 = i; + if (errorSelect) { + errCurMove(0); + return false; + } else { + mDoAud_seStart(Z2SE_SY_MENU_CURSOR_COMMON, NULL, 0, 0); + if (clicked) { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerYesNoSelectTarget, i)); + } + yesnoSelectAnmSet(); + mDataSelProc = DATASELPROC_YES_NO_CURSOR_MOVE_ANM; + return true; + } + } + if (clicked) { + if (errorSelect) { + if (field_0x0268 != 0) { + mDoAud_seStart(Z2SE_SY_CURSOR_OK, 0, 0, 0); + } else { + mDoAud_seStart(Z2SE_SY_CURSOR_CANCEL, 0, 0, 0); + } + mSelIcon->setAlphaRate(0.0f); + } else { + yesNoSelectStart(); + } + return true; + } + } + return false; +} +#endif + // handles switching between quest logs void dFile_select_c::dataSelect() { +#if TARGET_PC + if (pointerDataSelect()) { + return; + } +#endif + stick->checkTrigger(); // If A or Start was pressed @@ -801,6 +950,9 @@ static u16 msgTbl[3] = { }; void dFile_select_c::dataSelectStart() { +#if TARGET_PC + dusk::menu_pointer::clear_deferred_activation(dusk::menu_pointer::Context::FileSelect); +#endif mSelIcon->setAlphaRate(0.0f); if (mIsNoData[mSelectNum]) { @@ -949,6 +1101,16 @@ void dFile_select_c::dataSelectAnmSet() { } void dFile_select_c::dataSelectMoveAnime() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + if (mSelectNum != 0xFF && dusk::menu_pointer::hit_pane(mSelFilePanes[mSelectNum], 8.0f) && + dusk::menu_pointer::consume_click()) + { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerDataSelectTarget, mSelectNum)); + } +#endif bool iVar7 = true; bool iVar6 = true; bool bVar1 = true; @@ -997,6 +1159,14 @@ void dFile_select_c::dataSelectMoveAnime() { mSelFilePanes[mLastSelectNum]->getPanePtr()->setAnimation((J2DAnmTransform*)NULL); } +#if TARGET_PC + if (dusk::menu_pointer::consume_deferred_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerDataSelectTarget, mSelectNum))) { + dataSelectStart(); + return; + } +#endif mDataSelProc = DATASELPROC_DATA_SELECT; } } @@ -1161,6 +1331,12 @@ void dFile_select_c::selectDataOpenEraseMove() { // Handles selecting between copy / start / delete menus in quest log void dFile_select_c::menuSelect() { +#if TARGET_PC + if (pointerMenuSelect()) { + return; + } +#endif + stick->checkTrigger(); // if a was pressed, do the menu selection process @@ -1191,6 +1367,9 @@ void dFile_select_c::menuSelect() { // Handles copy / start / delete actions depending on which menu is selected from menuSelect void dFile_select_c::menuSelectStart() { +#if TARGET_PC + dusk::menu_pointer::clear_deferred_activation(dusk::menu_pointer::Context::FileSelect); +#endif #if TARGET_PC if (!dusk::getSettings().game.hideTvSettingsScreen || mSelectMenuNum != 1) { mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0); @@ -1312,6 +1491,17 @@ void dFile_select_c::menuSelectAnmSet() { } void dFile_select_c::menuSelectMoveAnm() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + if (mSelectMenuNum != 0xFF && + dusk::menu_pointer::hit_pane(m3mSelPane[mSelectMenuNum], 8.0f) && + dusk::menu_pointer::consume_click()) + { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerMenuSelectTarget, mSelectMenuNum)); + } +#endif bool tmp1 = true; if (mSelectMenuNum != 0xFF && @@ -1369,6 +1559,14 @@ void dFile_select_c::menuSelectMoveAnm() { m3mSelPane[mLastSelectMenuNum]->getPanePtr()->setAnimation((J2DAnmTransform*)NULL); } +#if TARGET_PC + if (dusk::menu_pointer::consume_deferred_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerMenuSelectTarget, mSelectMenuNum))) { + menuSelectStart(); + return; + } +#endif mDataSelProc = DATASELPROC_MENU_SELECT; } } @@ -1698,6 +1896,12 @@ void dFile_select_c::setSaveDataForCopySel() { } void dFile_select_c::copyDataToSelect() { +#if TARGET_PC + if (pointerCopyDataToSelect()) { + return; + } +#endif + stick->checkTrigger(); if (mDoCPd_c::getTrigA(PAD_1)) { @@ -1722,6 +1926,9 @@ void dFile_select_c::copyDataToSelect() { } void dFile_select_c::copyDataToSelectStart() { +#if TARGET_PC + dusk::menu_pointer::clear_deferred_activation(dusk::menu_pointer::Context::FileSelect); +#endif mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0); mCpDataToNum = getCptoNum(field_0x026b); @@ -1787,6 +1994,17 @@ void dFile_select_c::copyDataToSelectMoveAnmSet() { } void dFile_select_c::copyDataToSelectMoveAnm() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + if (field_0x026b != 0xFF && + dusk::menu_pointer::hit_pane(mCpSelPane[field_0x026b], 8.0f) && + dusk::menu_pointer::consume_click()) + { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerCopySelectTarget, field_0x026b)); + } +#endif bool iVar7 = true; bool iVar6 = true; bool bVar1 = true; @@ -1836,6 +2054,14 @@ void dFile_select_c::copyDataToSelectMoveAnm() { mSelIcon2->setAlphaRate(1.0f); } +#if TARGET_PC + if (dusk::menu_pointer::consume_deferred_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerCopySelectTarget, field_0x026b))) { + copyDataToSelectStart(); + return; + } +#endif mDataSelProc = DATASELPROC_COPY_DATA_TO_SELECT; } } @@ -2105,6 +2331,12 @@ void dFile_select_c::yesnoCursorShow() { } void dFile_select_c::YesNoSelect() { +#if TARGET_PC + if (pointerYesNoSelect(false)) { + return; + } +#endif + stick->checkTrigger(); if (mDoCPd_c::getTrigA(PAD_1)) { @@ -2129,6 +2361,9 @@ void dFile_select_c::YesNoSelect() { } void dFile_select_c::yesNoSelectStart() { +#if TARGET_PC + dusk::menu_pointer::clear_deferred_activation(dusk::menu_pointer::Context::FileSelect); +#endif if (field_0x0268 != 0) { mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0); field_0x03b1 = 1; @@ -2284,10 +2519,29 @@ void dFile_select_c::YesNoCancelMove() { } void dFile_select_c::yesNoCursorMoveAnm() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::FileSelect); + if (field_0x0268 != 0xFF && + dusk::menu_pointer::hit_pane(mYnSelPane[field_0x0268], 8.0f) && + dusk::menu_pointer::consume_click()) + { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerYesNoSelectTarget, field_0x0268)); + } +#endif bool isYnSelMove = yesnoSelectMoveAnm(); bool isYnWakuAlpha = yesnoWakuAlpahAnm(field_0x0269); if (isYnSelMove == true && isYnWakuAlpha == true) { yesnoCursorShow(); +#if TARGET_PC + if (dusk::menu_pointer::consume_deferred_activation( + dusk::menu_pointer::Context::FileSelect, + pointer_target(s_pointerYesNoSelectTarget, field_0x0268))) { + yesNoSelectStart(); + return; + } +#endif mDataSelProc = DATASELPROC_YES_NO_SELECT; } } @@ -5238,6 +5492,12 @@ void dFile_select_c::MemCardMsgWindowClose() { bool dFile_select_c::errYesNoSelect() { bool rv = false; +#if TARGET_PC + if (pointerYesNoSelect(true)) { + return true; + } +#endif + stick->checkTrigger(); if (mDoCPd_c::getTrigA(PAD_1)) { diff --git a/src/d/d_menu_collect.cpp b/src/d/d_menu_collect.cpp index 7ac70e4a7b..3aea57e1d3 100644 --- a/src/d/d_menu_collect.cpp +++ b/src/d/d_menu_collect.cpp @@ -36,6 +36,10 @@ #include "d/d_menu_window.h" #include "JSystem/J3DGraphBase/J3DMaterial.h" +#if TARGET_PC +#include "dusk/menu_pointer.h" +#endif + typedef void (dMenu_Collect2D_c::*initFunc)(); static DUSK_CONSTEXPR initFunc init[] = { &dMenu_Collect2D_c::wait_init, &dMenu_Collect2D_c::save_open_init, @@ -1786,6 +1790,12 @@ void dMenu_Collect2D_c::wait_init() { } void dMenu_Collect2D_c::wait_proc() { +#if TARGET_PC + if (pointerWait()) { + return; + } +#endif + if (dMw_A_TRIGGER()) { if (mCursorX == 0 && mCursorY == 5) { if (mDoGph_gInf_c::getFader()->mStatus == 1) { @@ -1887,6 +1897,87 @@ void dMenu_Collect2D_c::wait_proc() { } } +#if TARGET_PC +void dMenu_Collect2D_c::pointerActivateCurrent() { + if (mCursorX == 0 && mCursorY == 5) { + if (mDoGph_gInf_c::getFader()->mStatus == 1) { + mSubWindowOpenCheck = 1; + Z2GetAudioMgr()->seStart(Z2SE_SY_MENU_CHANGE_WINDOW, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibrationM(); + } + } else if (mCursorX == 1 && mCursorY == 5) { + if (mDoGph_gInf_c::getFader()->mStatus == 1) { + mSubWindowOpenCheck = 2; + Z2GetAudioMgr()->seStart(Z2SE_SY_MENU_CHANGE_WINDOW, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibrationM(); + } + } else if (mCursorX == 3 && mCursorY == 4) { + if (field_0x22d[3][4] != 0 && mDoGph_gInf_c::getFader()->mStatus == 1) { + mSubWindowOpenCheck = 3; + dMeter2Info_set2DVibration(); + } + } else if (mCursorX == 2 && mCursorY == 4) { + if (isFishIconVisible() && mDoGph_gInf_c::getFader()->mStatus == 1) { + mSubWindowOpenCheck = 4; + dMeter2Info_set2DVibration(); + } + } else if (mCursorX == 3 && mCursorY == 3) { + if (isSkillIconVisible() && mDoGph_gInf_c::getFader()->mStatus == 1) { + mSubWindowOpenCheck = 5; + dMeter2Info_set2DVibration(); + } + } else if (mCursorX == 2 && mCursorY == 3) { + if (isInsectIconVisible() && mDoGph_gInf_c::getFader()->mStatus == 1) { + mSubWindowOpenCheck = 6; + dMeter2Info_set2DVibration(); + } + } else if (field_0x22d[mCursorX][mCursorY] != 0 && !mIsWolf) { + if ((mCursorX >= 3 && mCursorX <= 4) || (mCursorX == 5 && mCursorY == 2)) { + u8 cursorY = mCursorY; + if (cursorY == 0) { + if (daPy_getPlayerActorClass()->getSwordChangeWaitTimer() == 0) { + changeSword(); + } + } else if (cursorY == 1) { + if (daPy_getPlayerActorClass()->getShieldChangeWaitTimer() == 0) { + changeShield(); + } + } else if (cursorY == 2 && + daPy_getPlayerActorClass()->getClothesChangeWaitTimer() == 0) + { + changeClothe(); + } + } + } +} + +bool dMenu_Collect2D_c::pointerWait() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Collection); + for (u8 y = 0; y < 6; ++y) { + for (u8 x = 0; x < 7; ++x) { + if (getItemTag(x, y, true) == 0 || !dusk::menu_pointer::hit_pane(mpSelPm[x][y], 8.0f)) { + continue; + } + if (mCursorX != x || mCursorY != y) { + mDoAud_seStart(Z2SE_SY_MENU_CURSOR_COMMON, NULL, 0, 0); + mCursorX = x; + mCursorY = y; + cursorPosSet(); + setItemNameString(mCursorX, mCursorY); + } + if (dusk::menu_pointer::consume_click()) { + pointerActivateCurrent(); + return true; + } + return false; + } + } + return false; +} +#endif + void dMenu_Collect2D_c::save_open_init() { JKRHeap* heap = mDoExt_setCurrentHeap(mpSubHeap); diff --git a/src/d/d_menu_fmap2D.cpp b/src/d/d_menu_fmap2D.cpp index 960131a7a2..795e3a5f64 100644 --- a/src/d/d_menu_fmap2D.cpp +++ b/src/d/d_menu_fmap2D.cpp @@ -17,7 +17,10 @@ #include "d/d_msg_scrn_explain.h" #include "m_Do/m_Do_graphic.h" #include "d/actor/d_a_midna.h" +#if TARGET_PC #include "dusk/frame_interpolation.h" +#include "dusk/ui/touch_controls.hpp" +#endif #include #if TARGET_PC @@ -2509,6 +2512,10 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) { } dMenu_Fmap2DTop_c::~dMenu_Fmap2DTop_c() { +#if TARGET_PC + dusk::ui::set_control_override(dusk::ui::Control::Z, dusk::ui::ControlOverride::Default); +#endif + deleteExplain(); JKR_DELETE(mpTitleScreen); mpTitleScreen = NULL; @@ -2782,6 +2789,12 @@ void dMenu_Fmap2DTop_c::setZButtonString(u32 param_0, u8 i_alpha) { param_0 = 0x533; } +#if TARGET_PC + dusk::ui::set_control_override(dusk::ui::Control::Z, + param_0 != 0 && isWarpAccept() ? dusk::ui::ControlOverride::Action : + dusk::ui::ControlOverride::Default); +#endif + #if VERSION == VERSION_GCN_JPN static const u64 cont_zt[5] = {MULTI_CHAR('cont_zt'), MULTI_CHAR('cont_zt1'), MULTI_CHAR('cont_zt2'), MULTI_CHAR('cont_zt3'), MULTI_CHAR('cont_zt4')}; #define setZButtonString_font_zt cont_zt diff --git a/src/d/d_menu_insect.cpp b/src/d/d_menu_insect.cpp index 8e6ad49b5b..7967ca6cdf 100644 --- a/src/d/d_menu_insect.cpp +++ b/src/d/d_menu_insect.cpp @@ -22,6 +22,10 @@ #include #include +#if TARGET_PC +#include "dusk/menu_pointer.h" +#endif + typedef void (dMenu_Insect_c::*initFunc)(); static initFunc map_init_process[] = { &dMenu_Insect_c::wait_init, &dMenu_Insect_c::explain_open_init, @@ -280,6 +284,12 @@ void dMenu_Insect_c::wait_init() { void dMenu_Insect_c::wait_move() { if (mDoGph_gInf_c::getFader()->getStatus() == 1) { +#if TARGET_PC + if (pointerWait()) { + return; + } +#endif + if (mDoCPd_c::getTrigB(PAD_1) || field_0xf7 == 0) { if (mDoCPd_c::getTrigB(PAD_1) && field_0xf6 == 1) { dMeter2Info_setInsectSelectType(0); @@ -301,6 +311,39 @@ void dMenu_Insect_c::wait_move() { } } +#if TARGET_PC +bool dMenu_Insect_c::pointerWait() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Collection); + for (u8 y = 0; y < 4; ++y) { + for (u8 x = 0; x < 6; ++x) { + const int index = x + y * 6; + if (!isGetInsect(x, y) || !dusk::menu_pointer::hit_pane(mpINSParent[index], 8.0f)) { + continue; + } + + if (field_0xf4 != x || field_0xf5 != y) { + field_0xf4 = x; + field_0xf5 = y; + setCursorPos(); + setAButtonString(0x368); + Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_ITEM, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + } + if (dusk::menu_pointer::consume_click()) { + field_0xf3 = 1; + Z2GetAudioMgr()->seStart(Z2SE_SY_EXP_WIN_OPEN, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibration(); + return true; + } + return false; + } + } + + return false; +} +#endif + void dMenu_Insect_c::explain_open_init() { char local_78[32]; char local_98[32]; diff --git a/src/d/d_menu_letter.cpp b/src/d/d_menu_letter.cpp index cd7da6a6f4..0d7efd3adb 100644 --- a/src/d/d_menu_letter.cpp +++ b/src/d/d_menu_letter.cpp @@ -19,6 +19,15 @@ #ifdef TARGET_PC #include "dusk/achievements.h" +#include "dusk/menu_pointer.h" +#include "dusk/ui/touch_controls.hpp" + +static void enable_turn_page_controls(bool enabled) { + const auto controlOverride = + enabled ? dusk::ui::ControlOverride::Action : dusk::ui::ControlOverride::Default; + dusk::ui::set_control_override(dusk::ui::Control::L, controlOverride); + dusk::ui::set_control_override(dusk::ui::Control::R, controlOverride); +} #endif #if VERSION == VERSION_GCN_JPN @@ -82,6 +91,10 @@ dMenu_Letter_c::dMenu_Letter_c(JKRExpHeap* i_heap, STControl* i_stick, CSTContro dMenu_Letter_c::~dMenu_Letter_c() { +#if TARGET_PC + enable_turn_page_controls(false); +#endif + JKR_DELETE(mpDrawCursor); mpDrawCursor = NULL; @@ -357,6 +370,10 @@ int dMenu_Letter_c::_open() { } int dMenu_Letter_c::_close() { +#if TARGET_PC + enable_turn_page_controls(false); +#endif + s16 closeWindowFrame = g_drawHIO.mLetterSelectScreen.mCloseFrame[dMeter_drawLetterHIO_c::WINDOW_FRAME]; field_0x368 = 0; @@ -386,6 +403,10 @@ int dMenu_Letter_c::_close() { } void dMenu_Letter_c::wait_init() { +#if TARGET_PC + enable_turn_page_controls(field_0x374 > 1); +#endif + setAButtonString(0x40c); setBButtonString(0x3f9); } @@ -393,6 +414,12 @@ void dMenu_Letter_c::wait_init() { void dMenu_Letter_c::wait_move() { u8 oldIndex = mIndex; if (mDoGph_gInf_c::getFader()->getStatus() == 1) { +#if TARGET_PC + if (pointerWait()) { + return; + } +#endif + if (mDoCPd_c::getTrigB(PAD_1) != 0) { mpDrawCursor->offPlayAnime(0); mStatus = 3; @@ -448,8 +475,40 @@ void dMenu_Letter_c::wait_move() { } } +#if TARGET_PC +bool dMenu_Letter_c::pointerWait() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Collection); + for (u8 i = 0; i < field_0x373; ++i) { + if (!dusk::menu_pointer::hit_pane(mpLetterParent[i], 8.0f)) { + continue; + } + + if (mIndex != i) { + mIndex = i; + changeActiveColor(); + Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_ITEM, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + } + if (dusk::menu_pointer::consume_click()) { + mProcess = 3; + Z2GetAudioMgr()->seStart(Z2SE_SY_LETTER_OPEN, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibration(); + return true; + } + return false; + } + + return false; +} +#endif + void dMenu_Letter_c::slide_right_init() { +#if TARGET_PC + enable_turn_page_controls(false); +#endif + field_0x358 = -field_0x1ec->getWidth() * mDoGph_gInf_c::getInvScale(); field_0x35c = field_0x1ec->getWidth() IF_NOT_DUSK(* mDoGph_gInf_c::getInvScale()); changePageLight(); @@ -467,6 +526,10 @@ void dMenu_Letter_c::slide_right_move() { } void dMenu_Letter_c::slide_left_init() { +#if TARGET_PC + enable_turn_page_controls(false); +#endif + field_0x358 = field_0x1ec->getWidth() * mDoGph_gInf_c::getInvScale(); field_0x35c = -field_0x1ec->getWidth() IF_NOT_DUSK(* mDoGph_gInf_c::getInvScale()); changePageLight(); @@ -484,6 +547,10 @@ void dMenu_Letter_c::slide_left_move() { } void dMenu_Letter_c::read_open_init() { +#if TARGET_PC + enable_turn_page_controls(false); +#endif + field_0x36a = 0; u8 idx = field_0x3ac[field_0x36f * 6 + mIndex] - 1; field_0x3e3 = 1; diff --git a/src/d/d_menu_option.cpp b/src/d/d_menu_option.cpp index 62f30d2d99..cc4bb01f2a 100644 --- a/src/d/d_menu_option.cpp +++ b/src/d/d_menu_option.cpp @@ -26,6 +26,11 @@ #include "JSystem/JAudio2/JASDriverIF.h" +#if TARGET_PC +#include "dusk/menu_pointer.h" +#include "dusk/ui/touch_controls.hpp" +#endif + typedef void (dMenu_Option_c::*initFunc)(); static initFunc init[] = { &dMenu_Option_c::atten_init, @@ -293,6 +298,10 @@ void dMenu_Option_c::_create() { } void dMenu_Option_c::_delete() { +#if TARGET_PC + dusk::ui::set_control_override(dusk::ui::Control::Z, dusk::ui::ControlOverride::Default); +#endif + JKR_DELETE(mpString); mpString = NULL; @@ -518,6 +527,15 @@ void dMenu_Option_c::_move() { (this->*init[field_0x3ef])(); } } + +#if TARGET_PC + if (field_0x3f4 == 5 && field_0x3ef != SelectType3 && field_0x3f3 == 5 && + field_0x3ef != SelectType4 && field_0x3ef != SelectType5 && field_0x3ef != SelectType6 && + field_0x3ef != SelectType7 && pointerConfirmSelect()) + { + goto skip; + } +#endif } skip: u8 oldValue = field_0x3ef; @@ -1074,6 +1092,34 @@ void dMenu_Option_c::confirm_move_move() { bool leftTrigger = checkLeftTrigger(); bool rightTrigger = checkRightTrigger(); +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Options); + for (u8 i = 0; i < 2; ++i) { + if (!dusk::menu_pointer::hit_pane(mpYesNoSelBase_c[i], 8.0f)) { + continue; + } + if (field_0x3f9 != i) { + Z2GetAudioMgr()->seStart(Z2SE_SY_MENU_CURSOR_COMMON, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + field_0x3fa = field_0x3f9; + field_0x3f9 = i; + yesnoSelectAnmSet(); + field_0x3ef = SelectType6; + mpWarning->_move(); + setAnimation(); + return; + } + if (dusk::menu_pointer::consume_click()) { + yesNoSelectStart(); + field_0x3ef = SelectType7; + dMeter2Info_set2DVibrationM(); + mpWarning->_move(); + setAnimation(); + return; + } + } +#endif + if (mDoCPd_c::getTrigA(PAD_1) != 0) { yesNoSelectStart(); field_0x3ef = SelectType7; @@ -2063,6 +2109,11 @@ void dMenu_Option_c::cursorAnime(f32 i_cursorValue) { } void dMenu_Option_c::setZButtonString(u16 i_stringID) { +#if TARGET_PC + dusk::ui::set_control_override(dusk::ui::Control::Z, + i_stringID != 0 ? dusk::ui::ControlOverride::Action : dusk::ui::ControlOverride::Default); +#endif + if (i_stringID == 0) { for (int i = 0; i < 3; i++) { if (mpZButtonText[i] != NULL) { @@ -2142,7 +2193,88 @@ bool dMenu_Option_c::isRumbleSupported() { return JUTGamePad::sRumbleSupported >> 0x1f; } +#if TARGET_PC +bool dMenu_Option_c::pointerConfirmSelect() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Options); + if (!dusk::menu_pointer::state().clicked) { + return false; + } + + for (u8 i = 0; i < SelectType3; ++i) { + if (dusk::menu_pointer::hit_pane(mpMenuPane[i], 8.0f)) { + return false; + } + } + + if (!dusk::menu_pointer::consume_click()) { + return false; + } + + field_0x3f7 = 1; + field_0x3f5 = field_0x3ef; + field_0x3ef = SelectType4; + dMeter2Info_set2DVibration(); + (this->*init[field_0x3ef])(); + return true; +} +#endif + bool dMenu_Option_c::dpdMenuMove() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Options); + for (u8 i = 0; i < SelectType3; ++i) { + if (!dusk::menu_pointer::hit_pane(mpMenuPane[i], 8.0f)) { + continue; + } + if (getSelectType() != i) { + field_0x3ef = i; + setCursorPos(i); + Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_OPTION, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + } + if (!dusk::menu_pointer::consume_click()) { + return true; + } + + switch (i) { + case SelectType0: + field_0x3e4 ^= 1; + field_0x3da = 5; + field_0x3ef = SelectType3; + field_0x3f5 = SelectType0; + Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + return true; + case SelectType1: + if (isRumbleSupported()) { + field_0x3ea ^= 1; + if (field_0x3ea != 0) { + mDoCPd_c::startMotorWave(0, &field_0x3e0, JUTGamePad::CRumble::VAL_0, 0x3c); + } + field_0x3da = 5; + field_0x3ef = SelectType3; + field_0x3f5 = SelectType1; + Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + } + return true; + case SelectType2: + if (field_0x3e9 == 0) { + field_0x3e9 = 2; + } else { + field_0x3e9--; + } + field_0x3da = 5; + mDoAud_setOutputMode(dMo_soundMode[field_0x3e9]); + setSoundMode(dMo_soundMode[field_0x3e9]); + field_0x3ef = SelectType3; + field_0x3f5 = SelectType2; + Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + return true; + } + } +#endif return false; } diff --git a/src/d/d_menu_ring.cpp b/src/d/d_menu_ring.cpp index a468ba889e..fde1f35af8 100644 --- a/src/d/d_menu_ring.cpp +++ b/src/d/d_menu_ring.cpp @@ -31,7 +31,9 @@ #if TARGET_PC #include "dusk/game_clock.h" +#include "dusk/menu_pointer.h" #include "dusk/settings.h" +#include "dusk/ui/touch_controls.hpp" #endif typedef void (dMenu_Ring_c::*initFunc)(); @@ -614,6 +616,9 @@ void dMenu_Ring_c::_delete() { * initializes a new process if mStatus changes */ void dMenu_Ring_c::_move() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::ItemWheel); +#endif mRingRadiusH = g_ringHIO.mRingRadiusH; mRingRadiusV = g_ringHIO.mRingRadiusV; mOldStatus = mStatus; // Save current status for check @@ -1517,6 +1522,11 @@ void dMenu_Ring_c::stick_wait_proc() { setDoStatus(0); return; } +#if TARGET_PC + if (pointerMove()) { + return; + } +#endif if (dMw_A_TRIGGER() && !dMeter2Info_isTouchKeyCheck(0xe)) { Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0); } @@ -1528,6 +1538,49 @@ void dMenu_Ring_c::stick_wait_proc() { } } +#if TARGET_PC +bool dMenu_Ring_c::pointerMove() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::ItemWheel); + const auto& pointer = dusk::menu_pointer::state(); + if (!pointer.valid || mItemsTotal == 0) { + return false; + } + + int hoveredSlot = -1; + f32 bestDistance = 42.0f; + for (u8 i = 0; i < mItemsTotal; ++i) { + const f32 x = mItemSlotPosX[i] + mCenterPosX; + const f32 y = mItemSlotPosY[i] + mCenterPosY; + const f32 distance = calcDistance(pointer.x, pointer.y, x, y); + if (distance < bestDistance) { + bestDistance = distance; + hoveredSlot = i; + } + } + + if (hoveredSlot < 0) { + return false; + } + + if (mCurrentSlot != hoveredSlot) { + mDirectSelectCursorPos.x = mItemSlotPosX[mCurrentSlot]; + mDirectSelectCursorPos.z = mItemSlotPosY[mCurrentSlot]; + mCurrentSlot = hoveredSlot; + mDirectSelectActive = true; + field_0x670 = field_0x63e[mCurrentSlot]; + setStatus(STATUS_MOVE); + field_0x6b2 = 0; + return true; + } + + if (dusk::menu_pointer::consume_click()) { + return true; + } + + return false; +} +#endif + void dMenu_Ring_c::stick_move_init() { if (mCursorSpeed == 0) { mCursorSpeed = g_ringHIO.mCursorInitSpeed; @@ -1672,12 +1725,40 @@ void dMenu_Ring_c::drawSelectItem() { #else if (field_0x674[i] < 10) { #endif +#if TARGET_PC + f32 initSizeX; + f32 initSizeY; + f32 initScaleX; + f32 initScaleY; + Vec pos; + dusk::ui::EquipTarget touchTarget; + if (dusk::ui::get_equip_target(i, touchTarget)) { + initSizeX = touchTarget.width; + initSizeY = touchTarget.height; + initScaleX = 1.0f; + initScaleY = 1.0f; + pos.x = touchTarget.left; + pos.y = touchTarget.top; + pos.z = 0.0f; + } else { + CPaneMgr* meterItemPane = dMeter2Info_getMeterItemPanePtr(i); + if (meterItemPane == NULL) { + continue; + } + initSizeX = meterItemPane->getInitSizeX() * 1.7f; + initSizeY = meterItemPane->getInitSizeY() * 1.7f; + initScaleX = meterItemPane->getInitScaleX(); + initScaleY = meterItemPane->getInitScaleY(); + pos = meterItemPane->getGlobalVtxCenter(meterItemPane->mPane, true, 0); + } +#else f32 initSizeX = dMeter2Info_getMeterItemPanePtr(i)->getInitSizeX() * 1.7f; f32 initSizeY = dMeter2Info_getMeterItemPanePtr(i)->getInitSizeY() * 1.7f; f32 initScaleX = dMeter2Info_getMeterItemPanePtr(i)->getInitScaleX(); f32 initScaleY = dMeter2Info_getMeterItemPanePtr(i)->getInitScaleY(); Vec pos = dMeter2Info_getMeterItemPanePtr(i)->getGlobalVtxCenter( dMeter2Info_getMeterItemPanePtr(i)->mPane, true, 0); +#endif #if TARGET_PC f32 fVar14 = 0.1f + 0.8f * u; diff --git a/src/d/d_menu_save.cpp b/src/d/d_menu_save.cpp index d73e4ff5e8..d272c57500 100644 --- a/src/d/d_menu_save.cpp +++ b/src/d/d_menu_save.cpp @@ -18,11 +18,15 @@ #include "m_Do/m_Do_controller_pad.h" #include "m_Do/m_Do_graphic.h" #include "d/d_msg_scrn_explain.h" -#include "dusk/frame_interpolation.h" -#include "dusk/settings.h" #include "JSystem/J2DGraph/J2DAnmLoader.h" #include "f_op/f_op_msg_mng.h" +#if TARGET_PC +#include "dusk/frame_interpolation.h" +#include "dusk/menu_pointer.h" +#include "dusk/settings.h" +#endif + static int SelStartFrameTbl[3] = { 59, 99, @@ -54,6 +58,17 @@ static int YnSelStartFrameTbl[2][2] = { static int YnSelEndFrameTbl[2][2] = {{2138, 3171}, {2150, 3181}}; +#if TARGET_PC +namespace { +constexpr u8 pointer_target(u8 group, u8 index) noexcept { + return static_cast((group << 4) | (index & 0x0F)); +} + +constexpr u8 s_pointerSaveSelectTarget = 0; +constexpr u8 s_pointerYesNoSelectTarget = 1; +} // namespace +#endif + static dMs_HIO_c g_msHIO; dMs_HIO_c::dMs_HIO_c() { @@ -1766,6 +1781,12 @@ void dMenu_save_c::openSaveSelect3() { void dMenu_save_c::saveSelect() { if (!mDoRst::isReset()) { +#if TARGET_PC + if (pointerSaveSelect()) { + return; + } +#endif + stick->checkTrigger(); if (mDoCPd_c::getTrigA(PAD_1)) { @@ -1792,7 +1813,84 @@ void dMenu_save_c::saveSelect() { } } +#if TARGET_PC +bool dMenu_save_c::pointerSaveSelect() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Save); + for (u8 i = 0; i < 3; ++i) { + if (!dusk::menu_pointer::hit_pane(mpSelData[i], 8.0f)) { + continue; + } + const bool clicked = dusk::menu_pointer::consume_click(); + if (mSelectedFile != i) { + mDoAud_seStart(Z2SE_FILE_SELECT_CURSOR, NULL, 0, 0); + mLastSelFile = mSelectedFile; + mSelectedFile = i; + if (clicked) { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::Save, + pointer_target(s_pointerSaveSelectTarget, i)); + } + dataSelectAnmSet(); + mMenuProc = PROC_SAVE_SELECT_MOVE_ANM; + return true; + } + if (clicked) { + saveSelectStart(); + return true; + } + } + return false; +} + +bool dMenu_save_c::pointerYesNoSelect(bool errorSelect, u8 errParam, u8 soundParam) { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Save); + for (u8 i = 0; i < 2; ++i) { + if (!dusk::menu_pointer::hit_pane(mpNoYes[i], 8.0f)) { + continue; + } + const bool clicked = + (!errorSelect || mYesNoCursor == i) && dusk::menu_pointer::consume_click(); + if (mYesNoCursor != i) { + if (errorSelect) { + errCurMove(errParam, soundParam); + return false; + } + mDoAud_seStart(Z2SE_SY_MENU_CURSOR_COMMON, NULL, 0, 0); + mYesNoPrevCursor = mYesNoCursor; + mYesNoCursor = i; + if (clicked) { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::Save, + pointer_target(s_pointerYesNoSelectTarget, i)); + } + yesnoSelectAnmSet(0); + mMenuProc = PROC_YES_NO_CURSOR_MOVE_ANM; + return true; + } + if (clicked) { + if (errorSelect) { + if (mYesNoCursor != CURSOR_NO) { + if (soundParam == 0) { + mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0); + } + } else if (soundParam == 0) { + mDoAud_seStart(Z2SE_SY_CURSOR_CANCEL, NULL, 0, 0); + } + mSelIcon->setAlphaRate(0.0f); + } else { + yesnoSelectStart(); + } + return true; + } + } + return false; +} +#endif + void dMenu_save_c::saveSelectStart() { +#if TARGET_PC + dusk::menu_pointer::clear_deferred_activation(dusk::menu_pointer::Context::Save); +#endif mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0); selectDataMoveAnmInitSet(SelOpenStartFrameTbl[mSelectedFile], SelOpenEndFrameTbl[mSelectedFile]); @@ -1851,6 +1949,17 @@ void dMenu_save_c::dataSelectAnmSet() { } void dMenu_save_c::saveSelectMoveAnime() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Save); + if (mSelectedFile != 0xFF && + dusk::menu_pointer::hit_pane(mpSelData[mSelectedFile], 8.0f) && + dusk::menu_pointer::consume_click()) + { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::Save, + pointer_target(s_pointerSaveSelectTarget, mSelectedFile)); + } +#endif bool bookWakuAnmComplete = true; bool selWakuAnmComplete = true; bool var_r29 = true; @@ -1900,12 +2009,26 @@ void dMenu_save_c::saveSelectMoveAnime() { if (mLastSelFile != 0xFF) { mpSelData[mLastSelFile]->getPanePtr()->setAnimation((J2DAnmTransformKey*)NULL); } +#if TARGET_PC + if (dusk::menu_pointer::consume_deferred_activation( + dusk::menu_pointer::Context::Save, + pointer_target(s_pointerSaveSelectTarget, mSelectedFile))) { + saveSelectStart(); + return; + } +#endif mMenuProc = PROC_SAVE_SELECT; } } void dMenu_save_c::saveYesNoSelect() { if (!mDoRst::isReset()) { +#if TARGET_PC + if (pointerYesNoSelect(false)) { + return; + } +#endif + stick->checkTrigger(); if (mDoCPd_c::getTrigA(PAD_1)) { @@ -1933,6 +2056,9 @@ void dMenu_save_c::saveYesNoSelect() { } void dMenu_save_c::yesnoSelectStart() { +#if TARGET_PC + dusk::menu_pointer::clear_deferred_activation(dusk::menu_pointer::Context::Save); +#endif if (mYesNoCursor != CURSOR_NO) { mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0); mSelIcon->setAlphaRate(0.0f); @@ -2001,11 +2127,30 @@ void dMenu_save_c::yesnoSelectAnmSet(u8 param_0) { } void dMenu_save_c::yesNoCursorMoveAnm() { +#if TARGET_PC + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Save); + if (mYesNoCursor != 0xFF && + dusk::menu_pointer::hit_pane(mpNoYes[mYesNoCursor], 8.0f) && + dusk::menu_pointer::consume_click()) + { + dusk::menu_pointer::defer_activation( + dusk::menu_pointer::Context::Save, + pointer_target(s_pointerYesNoSelectTarget, mYesNoCursor)); + } +#endif bool selAnmComplete = yesnoSelectMoveAnm(0); bool wakuAnmComplete = yesnoWakuAlpahAnm(mYesNoPrevCursor); if (selAnmComplete == true && wakuAnmComplete == true) { yesnoCursorShow(); +#if TARGET_PC + if (dusk::menu_pointer::consume_deferred_activation( + dusk::menu_pointer::Context::Save, + pointer_target(s_pointerYesNoSelectTarget, mYesNoCursor))) { + yesnoSelectStart(); + return; + } +#endif mMenuProc = PROC_SAVE_YES_NO_SELECT; } } @@ -2181,6 +2326,12 @@ bool dMenu_save_c::errYesNoSelect(u8 param_0, u8 param_1) { return false; } +#if TARGET_PC + if (pointerYesNoSelect(true, param_0, param_1)) { + return true; + } +#endif + stick->checkTrigger(); if (mDoCPd_c::getTrigA(PAD_1)) { diff --git a/src/d/d_menu_skill.cpp b/src/d/d_menu_skill.cpp index 2692d33c3f..601bae1eb6 100644 --- a/src/d/d_menu_skill.cpp +++ b/src/d/d_menu_skill.cpp @@ -18,6 +18,10 @@ #include "m_Do/m_Do_graphic.h" #include +#if TARGET_PC +#include "dusk/menu_pointer.h" +#endif + typedef void (dMenu_Skill_c::*initFunc)(); static initFunc map_init_process[] = { &dMenu_Skill_c::wait_init, @@ -275,6 +279,12 @@ void dMenu_Skill_c::wait_init() { void dMenu_Skill_c::wait_move() { u8 oldIndex = mIndex; if (mDoGph_gInf_c::getFader()->getStatus() == 1) { +#if TARGET_PC + if (pointerWait()) { + return; + } +#endif + if (mDoCPd_c::getTrigB(PAD_1) != 0) { mpDrawCursor->offPlayAnime(0); mStatus = 3; @@ -299,6 +309,34 @@ void dMenu_Skill_c::wait_move() { } } +#if TARGET_PC +bool dMenu_Skill_c::pointerWait() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Collection); + for (u8 i = 0; i < mSkillNum; ++i) { + if (!dusk::menu_pointer::hit_pane(mpLetterParent[i], 8.0f)) { + continue; + } + + if (mIndex != i) { + mIndex = i; + changeActiveColor(); + Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_ITEM, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + } + if (dusk::menu_pointer::consume_click()) { + mProcess = PROC_WAIT_MOVE; + Z2GetAudioMgr()->seStart(Z2SE_SY_EXP_WIN_OPEN, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibration(); + return true; + } + return false; + } + + return false; +} +#endif + void dMenu_Skill_c::read_open_init() { static const u32 i_id[7] = { 1716, 1715, 1717, 1718, 1719, 1720, 1721, diff --git a/src/d/d_meter2.cpp b/src/d/d_meter2.cpp index 7675bbfb0a..4afaf450a8 100644 --- a/src/d/d_meter2.cpp +++ b/src/d/d_meter2.cpp @@ -2966,7 +2966,15 @@ void dMeter2_c::alphaAnimeButtonCross() { field_0x190++; } } else { +#if TARGET_PC + if (dusk::getSettings().game.enableTouchControls) { + mpMeterDraw->setAlphaButtonCrossAnimeMin(); + } else { + mpMeterDraw->setAlphaButtonCrossAnimeMax(); + } +#else mpMeterDraw->setAlphaButtonCrossAnimeMax(); +#endif if (field_0x190 < 5) { field_0x190++; diff --git a/src/d/d_meter2_draw.cpp b/src/d/d_meter2_draw.cpp index 900367d7f3..eeebe65924 100644 --- a/src/d/d_meter2_draw.cpp +++ b/src/d/d_meter2_draw.cpp @@ -25,6 +25,7 @@ #if TARGET_PC #include "dusk/settings.h" +#include "dusk/ui/icon_provider.hpp" #include namespace { @@ -653,10 +654,22 @@ void dMeter2Draw_c::draw() { J2DGrafContext* graf_ctx = dComIfGp_getCurrentGrafPort(); graf_ctx->setup2D(); +#if TARGET_PC + const bool touchControlsEnabled = dusk::getSettings().game.enableTouchControls; + if (touchControlsEnabled) { + mpButtonParent->hide(); + } else { + mpButtonParent->show(); + } +#endif + mpScreen->draw(0.0f, 0.0f, graf_ctx); drawKanteraScreen(1); drawKanteraScreen(2); +#if TARGET_PC + if (!touchControlsEnabled) { +#endif for (int i = 0; i < 2; i++) { if (mpItemXY[i] != NULL) { for (int j = 0; j < 3; j++) { @@ -705,6 +718,9 @@ void dMeter2Draw_c::draw() { } } } +#if TARGET_PC + } +#endif if (mpLightDropParent->getAlphaRate() != 0.0f) { f32 var_f28 = g_drawHIO.mLightDrop.mPikariScaleNormal; @@ -787,7 +803,11 @@ void dMeter2Draw_c::draw() { } } +#if TARGET_PC + if (!touchControlsEnabled && field_0x738 > 0.0f) { +#else if (field_0x738 > 0.0f) { +#endif drawPikari(mpButtonMidona, &field_0x738, g_drawHIO.mMidnaIconPikariScale, g_drawHIO.mMidnaIconPikariFrontOuter, g_drawHIO.mMidnaIconPikariFrontInner, g_drawHIO.mMidnaIconPikariBackOuter, g_drawHIO.mMidnaIconPikariBackInner, @@ -2452,6 +2472,11 @@ void dMeter2Draw_c::drawButtonB(u8 i_action, bool param_1, f32 i_posX, f32 i_pos SAFE_STRCPY(static_cast(mpBText[i]->getPanePtr())->getStringPtr(), mp_string); } +#if TARGET_PC + if (dusk::getSettings().game.enableTouchControls) { + mpScreen->search(MULTI_CHAR('item_b_n'))->hide(); + } else +#endif if (i_action == 0x26 || i_action == 0x2E) { mpScreen->search(MULTI_CHAR('item_b_n'))->show(); var_r31 = 1; @@ -2729,6 +2754,12 @@ void dMeter2Draw_c::drawButtonXY(int i_no, u8 i_itemNo, u8 i_action, bool param_ mpTextXY[i_no]->scale(g_drawHIO.mButtonXYTextScale, g_drawHIO.mButtonXYTextScale); mpTextXY[i_no]->paneTrans(g_drawHIO.mButtonXYTextPosX, g_drawHIO.mButtonXYTextPosY); } + +#if TARGET_PC + if (dusk::getSettings().game.enableTouchControls) { + mpScreen->search(tag[i_no])->hide(); + } +#endif } } @@ -3294,6 +3325,10 @@ void dMeter2Draw_c::setButtonIconMidonaAlpha(u32 param_0) { } mpButtonXY[2]->setAlpha(255.0f * field_0x724 * temp_f30_2); + +#if TARGET_PC + dusk::ui::update_midna_icon_texture(mpButtonMidona != NULL ? mpButtonMidona->getPanePtr() : NULL); +#endif } void dMeter2Draw_c::setButtonIconAlpha(int i_no, u8 unused0, u32 unused1, bool unused2) { diff --git a/src/d/d_meter_map.cpp b/src/d/d_meter_map.cpp index 95cd82cd53..bffdbb8931 100644 --- a/src/d/d_meter_map.cpp +++ b/src/d/d_meter_map.cpp @@ -22,6 +22,10 @@ #endif #include +#if TARGET_PC +#include "dusk/action_bindings.h" +#endif + #if (PLATFORM_WII || PLATFORM_SHIELD) dMeter_map_HIO_c g_meter_mapHIO; #endif @@ -738,7 +742,38 @@ void dMeterMap_c::ctrlShowMap() { } } - } else if (!mDoCPd_c::getTrigUp(PAD_1) && !mDoCPd_c::getTrigDown(PAD_1)) { + } +#if TARGET_PC + else if (!isEventRunCheck() && + (dMeter2Info_getMapStatus() == 0 || dMeter2Info_getMapStatus() == 1) && + !dMeter2Info_isSub2DStatus(1) && (isFmapScreen() || isDmapScreen()) && + dusk::getActionBindTrig(dusk::ActionBinds::OPEN_MAP_SCREEN, PAD_1)) + { + dMeter2Info_setMapStatus(2); + dMeter2Info_setMapKeyDirection(0x400); + Z2GetAudioMgr()->seStart(Z2SE_SY_MAP_OPEN_S, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibration(); + } else if (!isEventRunCheck() && + (dMeter2Info_getMapStatus() == 0 || dMeter2Info_getMapStatus() == 1) && + isEnableDispMapAndMapDispSizeTypeNo() && + dusk::getActionBindTrig(dusk::ActionBinds::TOGGLE_MINIMAP, PAD_1)) + { + if (isDispPosInsideFlg()) { + setDispPosOutsideFlg_SE_On(); + Z2GetAudioMgr()->seStart(Z2SE_SY_MAP_CLOSE_S, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_setMapStatus(0); + } else { + setDispPosInsideFlg_SE_On(); + Z2GetAudioMgr()->seStart(Z2SE_SY_MAP_OPEN_S, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibration(); + dMeter2Info_setMapStatus(1); + } + } +#endif + else if (!mDoCPd_c::getTrigUp(PAD_1) && !mDoCPd_c::getTrigDown(PAD_1)) { keyCheck(); } @@ -833,7 +868,21 @@ void dMeterMap_c::meter_map_move(u32 param_0) { dMeter2Info_set2DVibration(); } dMeter2Info_resetPauseStatus(); - } else if ( + } +#if TARGET_PC + else if (!dComIfGp_event_runCheck() && !dMsgObject_isTalkNowCheck() && + (dMeter2Info_getMapStatus() == 0 || dMeter2Info_getMapStatus() == 1) && + !dMeter2Info_isSub2DStatus(1) && (isFmapScreen() || isDmapScreen()) && + dusk::getActionBindTrig(dusk::ActionBinds::OPEN_MAP_SCREEN, PAD_1)) + { + dMeter2Info_setMapStatus(2); + dMeter2Info_setMapKeyDirection(0x400); + Z2GetAudioMgr()->seStart(Z2SE_SY_MAP_OPEN_S, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + dMeter2Info_set2DVibration(); + } +#endif + else if ( #if DEBUG dMw_RIGHT_TRIGGER() && #else diff --git a/src/d/d_msg_class.cpp b/src/d/d_msg_class.cpp index 01d2ab48e6..8dc2a82c01 100644 --- a/src/d/d_msg_class.cpp +++ b/src/d/d_msg_class.cpp @@ -13,6 +13,7 @@ #include "JSystem/JUtility/JUTFont.h" #if TARGET_PC +#include "dusk/menu_pointer.h" #include "dusk/scope_guard.hpp" #endif @@ -575,6 +576,20 @@ void jmessage_tReference::pageSend() { void jmessage_tReference::selectMessage() { if (mSelectNum != 0) { +#if TARGET_PC + u8 pointerChoice = 0xFF; + if (dusk::menu_pointer::get_dialog_choice(pointerChoice) && pointerChoice < mSelectNum && + pointerChoice != mSelectPos) + { + mSelectPos = pointerChoice; + if (mSelectType != 0) { + getObjectPtr()->getSequenceProcessor()->calcStringLength(); + } + Z2GetAudioMgr()->seStart(Z2SE_SY_TALK_CURSOR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, + -1.0f, 0); + } +#endif + mpStick->checkTrigger(); if (mSelectType == 0) { diff --git a/src/d/d_msg_object.cpp b/src/d/d_msg_object.cpp index a2744eecff..4caec360a9 100644 --- a/src/d/d_msg_object.cpp +++ b/src/d/d_msg_object.cpp @@ -26,12 +26,13 @@ #include #include "JSystem/JKernel/JKRExpHeap.h" -#include "dusk/version.hpp" #include "m_Do/m_Do_controller_pad.h" #include "m_Do/m_Do_lib.h" #if TARGET_PC +#include "dusk/menu_pointer.h" #include "dusk/settings.h" +#include "dusk/version.hpp" #include #include #include @@ -1123,7 +1124,20 @@ void dMsgObject_c::selectProc() { dComIfGp_setAStatusForce(0x2a, 0); } } - if (mDoCPd_c::getTrigA(0)) { +#if TARGET_PC + jmessage_tReference* pRef = (jmessage_tReference*)mpRenProc->getReference(); + u8 pointerChoice = 0xFF; + bool pointerConfirm = dusk::menu_pointer::consume_dialog_click(pointerChoice) && + pointerChoice < pRef->getSelectNum(); + if (pointerConfirm) { + pRef->setSelectPos(pointerChoice); + } +#endif + if (mDoCPd_c::getTrigA(0) +#if TARGET_PC + || pointerConfirm +#endif + ) { if (getSelectCursorPosLocal() != 0xff) { field_0x1a3 = 1; } @@ -1145,7 +1159,9 @@ void dMsgObject_c::selectProc() { } field_0x1a3 = 2; } +#ifndef TARGET_PC jmessage_tReference* pRef = (jmessage_tReference*)mpRenProc->getReference(); +#endif if (getStatusLocal() == 8) { if (isMidonaMessage() && field_0x1a3 != 0) { if (field_0x1a3 == 2 && getSelectCancelPos() == 3) { diff --git a/src/d/d_msg_scrn_3select.cpp b/src/d/d_msg_scrn_3select.cpp index 68d0732481..b021b52dec 100644 --- a/src/d/d_msg_scrn_3select.cpp +++ b/src/d/d_msg_scrn_3select.cpp @@ -16,6 +16,17 @@ #include "d/d_msg_object.h" #include "d/d_pane_class.h" +#if TARGET_PC +#include "dusk/menu_pointer.h" + +namespace { +bool hit_choice_pane(CPaneMgr* pane, f32 padding) { + return pane != NULL && pane->getPanePtr() != NULL && pane->getPanePtr()->isVisible() && + dusk::menu_pointer::hit_pane(pane, padding); +} +} // namespace +#endif + typedef void (dMsgScrn3Select_c::*processFn)(); processFn process[] = { &dMsgScrn3Select_c::open1Proc, &dMsgScrn3Select_c::open2Proc, &dMsgScrn3Select_c::waitProc, @@ -470,6 +481,9 @@ bool dMsgScrn3Select_c::selAnimeMove(u8 i_selNum, u8 param_1, bool param_2) { mSelNum = i_selNum; field_0x114 = 0; field_0x108 = param_2; +#if TARGET_PC + pointerMove(); +#endif (this->*process[mProcess])(); @@ -518,6 +532,47 @@ bool dMsgScrn3Select_c::selAnimeMove(u8 i_selNum, u8 param_1, bool param_2) { return mProcess == PROC_SELECT_e ? TRUE : FALSE; } +#if TARGET_PC +bool dMsgScrn3Select_c::pointerMove() { + dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Dialog); + mDPDPoint = 0xFF; + + const u8 firstPane = mSelNum == 2 ? 1 : 0; + for (u8 choice = 0; choice < mSelNum; ++choice) { + const u8 paneIndex = firstPane + choice; + if (paneIndex >= 3) { + continue; + } + + // TODO: this sucks and should be replaced with Wii mpTouchArea + bool hit = hit_choice_pane(mpSel_c[paneIndex], 8.0f) || + hit_choice_pane(mpTmSel_c[paneIndex], 24.0f) || + hit_choice_pane(mpTmrSel_c[paneIndex], 24.0f) || + hit_choice_pane(mpKahen_c[paneIndex], 8.0f) || + hit_choice_pane(mpCursor_c[paneIndex], 8.0f); + for (int i = 0; i < 5 && !hit; ++i) { + hit = hit_choice_pane(mpSelCldw_c[i][paneIndex], 8.0f); + } + + if (!hit) { + continue; + } + + mDPDPoint = choice; + field_0x110 = paneIndex; + dusk::menu_pointer::set_dialog_choice(choice, dusk::menu_pointer::state().clicked); + return true; + } + + return false; +} + +bool dMsgScrn3Select_c::consumePointerClick() { + u8 choice = 0xFF; + return dusk::menu_pointer::consume_dialog_click(choice); +} +#endif + bool dMsgScrn3Select_c::selAnimeEnd() { if (mProcess == PROC_MAX_e) { return true; diff --git a/src/d/d_msg_scrn_explain.cpp b/src/d/d_msg_scrn_explain.cpp index bc6275e10c..29a88590ee 100644 --- a/src/d/d_msg_scrn_explain.cpp +++ b/src/d/d_msg_scrn_explain.cpp @@ -643,6 +643,10 @@ f32 dMsgScrnExplain_c::getAlphaRatio() { bool dMsgScrnExplain_c::checkTriggerA() { if (mDoCPd_c::getTrigA(PAD_1)) { return true; +#if TARGET_PC + } else if (mpSelect_c != NULL && mpSelect_c->consumePointerClick()) { + return true; +#endif } else { return false; } diff --git a/src/dusk/action_bindings.cpp b/src/dusk/action_bindings.cpp index 204f219558..68b07d6c0a 100644 --- a/src/dusk/action_bindings.cpp +++ b/src/dusk/action_bindings.cpp @@ -8,10 +8,19 @@ namespace dusk { static std::array(ActionBinds::COUNT)>, PAD_CHANMAX> actionPressData{}; +struct VirtualActionBindData { + bool pressed = false; + bool available = false; +}; + +static std::array(ActionBinds::COUNT)>, PAD_CHANMAX> virtualActionData{}; + ActionBindsMap& getActionBinds() { static ActionBindsMap actionBinds = { {ActionBinds::FIRST_PERSON_CAMERA, {&getSettings().actionBindings.firstPersonCamera, "First Person Camera"}}, {ActionBinds::CALL_MIDNA, {&getSettings().actionBindings.callMidna, "Call Midna"}}, + {ActionBinds::OPEN_MAP_SCREEN, {&getSettings().actionBindings.openMapScreen, "Open Map Screen"}}, + {ActionBinds::TOGGLE_MINIMAP, {&getSettings().actionBindings.toggleMinimap, "Toggle Minimap"}}, {ActionBinds::OPEN_DUSKLIGHT_MENU, {&getSettings().actionBindings.openDusklightMenu, "Open Dusklight Menu"}}, {ActionBinds::TURBO_SPEED_BUTTON, {&getSettings().actionBindings.turboSpeedButton, "Turbo Speed Button"}}, }; @@ -25,6 +34,10 @@ bool isActionBound(ActionBinds action, u32 port) { return false; } + if (port < PAD_CHANMAX && virtualActionData[port][static_cast(action)].available) { + return true; + } + return getActionBindButton(action, port) != PAD_NATIVE_BUTTON_INVALID; } @@ -41,43 +54,71 @@ void updateActionBindings() { // If the action isn't bound, or if documents are visible and the action isn't // opening the dusklight menu, don't update. Otherwise, we may accidentally // perform actions while the dusklight menu is open. - if (!isActionBound(action, port) || + const int button = boundAction.configVars->at(port); + const bool virtualAvailable = virtualActionData[port][static_cast(action)].available; + if ((button == PAD_NATIVE_BUTTON_INVALID && !virtualAvailable) || (ui::any_document_visible() && action != ActionBinds::OPEN_DUSKLIGHT_MENU)) { continue; } - int button = boundAction.configVars->at(port); - - // If keyboard is active for this port - u32 count = 0; - if (PADGetKeyButtonBindings(port, &count) != nullptr) { - int numKeys = 0; - const bool* kbState = SDL_GetKeyboardState(&numKeys); - if (kbState[button]) { - actionPressData[port][static_cast(action)].pressedCurFrame = true; - } - } else { - // If controller is active - auto controller = aurora::input::get_controller_for_player(port); - if (controller) { - if (SDL_GetGamepadButton(controller->m_controller, static_cast(button))) { + if (button != PAD_NATIVE_BUTTON_INVALID) { + // If keyboard is active for this port + u32 count = 0; + if (PADGetKeyButtonBindings(port, &count) != nullptr) { + int numKeys = 0; + const bool* kbState = SDL_GetKeyboardState(&numKeys); + if (kbState[button]) { actionPressData[port][static_cast(action)].pressedCurFrame = true; } + } else { + // If controller is active + auto controller = aurora::input::get_controller_for_player(port); + if (controller) { + if (SDL_GetGamepadButton(controller->m_controller, static_cast(button))) { + actionPressData[port][static_cast(action)].pressedCurFrame = true; + } + } } } } + + for (auto& [action, _] : getActionBinds()) { + const auto& virtualAction = virtualActionData[port][static_cast(action)]; + if (virtualAction.available && virtualAction.pressed && !ui::any_document_visible()) { + actionPressData[port][static_cast(action)].pressedCurFrame = true; + } + } } } +void setVirtualActionBind(ActionBinds action, u32 port, bool pressed, bool available) { + if (port >= PAD_CHANMAX) { + return; + } + virtualActionData[port][static_cast(action)] = { + .pressed = pressed, + .available = available, + }; +} + +void clearVirtualActionBind(ActionBinds action, u32 port) { + if (port >= PAD_CHANMAX) { + return; + } + virtualActionData[port][static_cast(action)] = {}; +} + +void clearAllVirtualActionBinds() { + virtualActionData = {}; +} + bool getActionBindTrig(ActionBinds action, u32 port) { - return isActionBound(action, port) && - actionPressData[port][static_cast(action)].pressedCurFrame && + return actionPressData[port][static_cast(action)].pressedCurFrame && !actionPressData[port][static_cast(action)].pressedPrevFrame; } bool getActionBindHold(ActionBinds action, u32 port) { - return isActionBound(action, port) && - actionPressData[port][static_cast(action)].pressedCurFrame && + return actionPressData[port][static_cast(action)].pressedCurFrame && actionPressData[port][static_cast(action)].pressedPrevFrame; } diff --git a/src/dusk/config.cpp b/src/dusk/config.cpp index 31e4a80b05..fa331eb518 100644 --- a/src/dusk/config.cpp +++ b/src/dusk/config.cpp @@ -1,19 +1,23 @@ #include "dusk/config.hpp" +#include "absl/container/flat_hash_map.h" #include "fmt/format.h" #include "nlohmann/json.hpp" -#include "absl/container/flat_hash_map.h" #include "aurora/lib/logging.hpp" #include "dusk/io.hpp" #include "dusk/settings.h" -#include +#include #include -#include +#include +#include #include +#include +#include +#include -#include "dusk/main.h" #include "dusk/action_bindings.h" +#include "dusk/main.h" using namespace dusk::config; @@ -26,6 +30,104 @@ aurora::Module DuskConfigLog("dusk::config"); static absl::flat_hash_map RegisteredConfigVars; static bool RegistrationDone = false; +static std::optional parse_control_anchor(std::string_view value) { + if (value == "none") { + return dusk::ui::ControlAnchor::None; + } + if (value == "top") { + return dusk::ui::ControlAnchor::Top; + } + if (value == "left") { + return dusk::ui::ControlAnchor::Left; + } + if (value == "bottom") { + return dusk::ui::ControlAnchor::Bottom; + } + if (value == "right") { + return dusk::ui::ControlAnchor::Right; + } + if (value == "topLeft") { + return dusk::ui::ControlAnchor::TopLeft; + } + if (value == "topRight") { + return dusk::ui::ControlAnchor::TopRight; + } + if (value == "bottomLeft") { + return dusk::ui::ControlAnchor::BottomLeft; + } + if (value == "bottomRight") { + return dusk::ui::ControlAnchor::BottomRight; + } + return std::nullopt; +} + +static const char* control_anchor_value(dusk::ui::ControlAnchor anchor) { + switch (anchor) { + case dusk::ui::ControlAnchor::None: + return "none"; + case dusk::ui::ControlAnchor::Top: + return "top"; + case dusk::ui::ControlAnchor::Left: + return "left"; + case dusk::ui::ControlAnchor::Bottom: + return "bottom"; + case dusk::ui::ControlAnchor::Right: + return "right"; + case dusk::ui::ControlAnchor::TopLeft: + return "topLeft"; + case dusk::ui::ControlAnchor::TopRight: + return "topRight"; + case dusk::ui::ControlAnchor::BottomLeft: + return "bottomLeft"; + case dusk::ui::ControlAnchor::BottomRight: + return "bottomRight"; + } + return "none"; +} + +static std::optional json_finite_float(const json& object, const char* key) { + const auto iter = object.find(key); + if (iter == object.end() || !iter->is_number()) { + return std::nullopt; + } + + const float value = iter->get(); + if (!std::isfinite(value)) { + return std::nullopt; + } + + return value; +} + +static std::optional parse_control_props(const json& value) { + if (!value.is_object()) { + return std::nullopt; + } + + const auto x = json_finite_float(value, "x"); + const auto y = json_finite_float(value, "y"); + const auto w = json_finite_float(value, "w"); + const auto h = json_finite_float(value, "h"); + const auto scale = json_finite_float(value, "scale"); + const auto anchorIter = value.find("anchor"); + if (!x || !y || !w || !h || !scale || anchorIter == value.end() || !anchorIter->is_string()) { + return std::nullopt; + } + + const auto anchor = parse_control_anchor(anchorIter->get()); + if (!anchor || *w <= 0.0f || *h <= 0.0f || *scale <= 0.0f) { + return std::nullopt; + } + return dusk::ui::ControlProps{ + .x = *x, + .y = *y, + .w = *w, + .h = *h, + .scale = *scale, + .anchor = *anchor, + }; +} + static std::filesystem::path GetConfigJsonPath() { return dusk::ConfigPath / ConfigFileName; } @@ -46,8 +148,8 @@ static void ReplaceFile(const std::filesystem::path& source, const std::filesyst } } -ConfigVarBase::ConfigVarBase(const char* name, const ConfigImplBase* impl) : name(name), registered(false), layer(ConfigVarLayer::Default), impl(impl) { -} +ConfigVarBase::ConfigVarBase(const char* name, const ConfigImplBase* impl) + : name(name), registered(false), layer(ConfigVarLayer::Default), impl(impl) {} const char* ConfigVarBase::getName() const noexcept { return name; @@ -72,11 +174,13 @@ static T sanitizeEnumValue(const ConfigVar& cVar, T value) { return value; } -template +template void ConfigImpl::loadFromJson(ConfigVar& cVar, const json& jsonValue) { if constexpr (std::is_enum_v) { if (jsonValue.is_boolean()) { - DuskConfigLog.error("Doing default migration of CVar {} from bool, enum values may not be what is expected!", cVar.getName()); + DuskConfigLog.error("Doing default migration of CVar {} from bool, enum values may not " + "be what is expected!", + cVar.getName()); using Underlying = std::underlying_type_t; const bool b = jsonValue.get(); @@ -91,13 +195,14 @@ void ConfigImpl::loadFromJson(ConfigVar& cVar, const json& jsonValue) { cVar.setValue(sanitizeEnumValue(cVar, jsonValue.get()), false); } -template +template nlohmann::json ConfigImpl::dumpToJson(const ConfigVar& cVar) { return cVar.getValueForSave(); } -template requires std::is_integral_v && std::is_signed_v -static void loadFromArgImpl(ConfigVar& cVar, const std::string_view stringValue) { +template +requires std::is_integral_v&& std::is_signed_v static void loadFromArgImpl( + ConfigVar& cVar, const std::string_view stringValue) { const std::string str(stringValue); const auto result = std::stoll(str); if (result >= std::numeric_limits::min() && result <= std::numeric_limits::max()) { @@ -107,8 +212,9 @@ static void loadFromArgImpl(ConfigVar& cVar, const std::string_view stringVal } } -template requires std::is_integral_v && std::is_unsigned_v -static void loadFromArgImpl(ConfigVar& cVar, const std::string_view stringValue) { +template +requires std::is_integral_v&& std::is_unsigned_v static void loadFromArgImpl( + ConfigVar& cVar, const std::string_view stringValue) { const std::string str(stringValue); const auto result = std::stoull(str); if (result <= std::numeric_limits::max()) { @@ -134,14 +240,17 @@ static void loadFromArgImpl(ConfigVar& cVar, const std::string_view cVar.setOverrideValue(std::string(stringValue)); } -template requires std::is_enum_v -static void loadFromArgImpl(ConfigVar& cVar, const std::string_view stringValue) { +template +requires std::is_enum_v static void loadFromArgImpl( + ConfigVar& cVar, const std::string_view stringValue) { using Underlying = std::underlying_type_t; const std::string str(stringValue); if constexpr (std::is_signed_v) { const auto result = std::stoll(str); - if (result >= std::numeric_limits::min() && result <= std::numeric_limits::max()) { + if (result >= std::numeric_limits::min() && + result <= std::numeric_limits::max()) + { cVar.setOverrideValue(sanitizeEnumValue(cVar, static_cast(result))); } else { throw std::out_of_range("Value is too large"); @@ -156,16 +265,20 @@ static void loadFromArgImpl(ConfigVar& cVar, const std::string_view stringVal } } -template +template void ConfigImpl::loadFromArg(ConfigVar& cVar, const std::string_view stringValue) { loadFromArgImpl(cVar, stringValue); } -template<> +template <> void ConfigImpl::loadFromArg(ConfigVar& cVar, const std::string_view stringValue) { - if (stringValue == "1" || stringValue == "TRUE" || stringValue == "true" || stringValue == "True") { + if (stringValue == "1" || stringValue == "TRUE" || stringValue == "true" || + stringValue == "True") + { cVar.setOverrideValue(true); - } else if (stringValue == "0" || stringValue == "FALSE" || stringValue == "false" || stringValue == "False") { + } else if (stringValue == "0" || stringValue == "FALSE" || stringValue == "false" || + stringValue == "False") + { cVar.setOverrideValue(false); } else { throw InvalidConfigError("Value cannot be parsed as boolean"); @@ -174,42 +287,103 @@ void ConfigImpl::loadFromArg(ConfigVar& cVar, const std::string_view // My IDE is convinced this namespace is necessary. It shouldn't be AFAICT? namespace dusk::config { - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; - template<> void ConfigImpl::loadFromJson(ConfigVar& cVar, const json& jsonValue) { - if (jsonValue.is_boolean()) { - const bool b = jsonValue.get(); +template <> +void ConfigImpl::loadFromJson( + ConfigVar& cVar, const json& jsonValue) { + if (jsonValue.is_boolean()) { + const bool b = jsonValue.get(); - const FrameInterpMode mode = b ? FrameInterpMode::Unlimited : FrameInterpMode::Off; + const FrameInterpMode mode = b ? FrameInterpMode::Unlimited : FrameInterpMode::Off; - cVar.setValue(sanitizeEnumValue(cVar, mode), false); - return; + cVar.setValue(sanitizeEnumValue(cVar, mode), false); + return; + } + + cVar.setValue(sanitizeEnumValue(cVar, jsonValue.get()), false); +} + +template <> +void ConfigImpl::loadFromJson( + ConfigVar& cVar, const json& jsonValue) { + if (!jsonValue.is_object()) { + return; + } + + const int version = jsonValue.value("version", 0); + if (version != ui::ControlLayout::Version) { + return; + } + + const auto controlsIter = jsonValue.find("controls"); + if (controlsIter == jsonValue.end() || !controlsIter->is_object()) { + return; + } + + ui::ControlLayout layout{.version = version}; + for (const auto& control : controlsIter->items()) { + if (!ui::is_control_layout_id(control.key())) { + continue; } - cVar.setValue(sanitizeEnumValue(cVar, jsonValue.get()), false); + if (const auto props = parse_control_props(control.value())) { + layout.controls[control.key()] = *props; + } } - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; - template class ConfigImpl; + + cVar.setValue(std::move(layout), false); } +template <> +void ConfigImpl::loadFromArg( + ConfigVar&, const std::string_view) { + throw InvalidConfigError("Touch control layout cannot be parsed from launch arguments"); +} + +template <> +nlohmann::json ConfigImpl::dumpToJson(const ConfigVar& cVar) { + const auto& layout = cVar.getValueForSave(); + json controls = json::object(); + for (const auto& [id, props] : layout.controls) { + controls[id] = { + {"x", props.x}, + {"y", props.y}, + {"w", props.w}, + {"h", props.h}, + {"scale", props.scale}, + {"anchor", control_anchor_value(props.anchor)}, + }; + } + + return { + {"version", ui::ControlLayout::Version}, + {"controls", std::move(controls)}, + }; +} + +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +template class ConfigImpl; +} // namespace dusk::config + void dusk::config::Register(ConfigVarBase& configVar) { const auto& name = configVar.getName(); if (RegistrationDone) { @@ -298,9 +472,7 @@ void dusk::config::Save() { } const auto configPathString = io::fs_path_to_string(configJsonPath); - DuskConfigLog.info( - "Saving config to '{}'", - configPathString); + DuskConfigLog.info("Saving config to '{}'", configPathString); json j; diff --git a/src/dusk/gyro.cpp b/src/dusk/gyro.cpp index 1e2e379960..31b32bd412 100644 --- a/src/dusk/gyro.cpp +++ b/src/dusk/gyro.cpp @@ -70,16 +70,7 @@ bool rollgoal_gyro_enabled() { } bool queryGyroAimContext() { - if (!static_cast(getSettings().game.enableGyroAim)) { - return false; - } - - daAlink_c* link = daAlink_getAlinkActorClass(); - if (link == nullptr) { - return false; - } - - return link->checkAimContext() && dComIfGp_checkCameraAttentionStatus(link->field_0x317c, 0x10); + return getSettings().game.enableGyroAim.getValue() && dCamera_c::isAimActive(); } void read(float dt) { diff --git a/src/dusk/menu_pointer.cpp b/src/dusk/menu_pointer.cpp new file mode 100644 index 0000000000..91b66cce55 --- /dev/null +++ b/src/dusk/menu_pointer.cpp @@ -0,0 +1,386 @@ +#include "dusk/menu_pointer.h" + +#include "m_Do/m_Do_graphic.h" +#include "d/d_pane_class.h" +#include "dusk/settings.h" + +#include +#include + +#include + +namespace dusk::menu_pointer { +namespace { +State s_state; +bool s_clickConsumed = false; +Context s_lastContext = Context::None; +Context s_currentContext = Context::None; +u8 s_lastDialogChoice = 0xFF; +u8 s_currentDialogChoice = 0xFF; +bool s_lastDialogChoiceValid = false; +bool s_currentDialogChoiceValid = false; +bool s_lastDialogClicked = false; +bool s_currentDialogClicked = false; +bool s_mouseActive = false; +bool s_mouseButtonCaptured = false; +s32 s_mouseButton = -1; +u32 s_suppressedPadHoldMask = 0; +u32 s_suppressedPadNextReadMask = 0; +Context s_deferredActivationContext = Context::None; +u8 s_deferredActivationTarget = 0xFF; + +s32 scancode_from_rml_button(s32 button) noexcept { + switch (button) { + case 0: + return PAD_KEY_MOUSE_LEFT; + case 1: + return PAD_KEY_MOUSE_RIGHT; + case 2: + return PAD_KEY_MOUSE_MIDDLE; + default: + return PAD_KEY_INVALID; + } +} + +bool is_mouse_scancode(s32 scancode) noexcept { + return scancode >= PAD_KEY_MOUSE_X2 && scancode <= PAD_KEY_MOUSE_LEFT; +} + +PADButton pad_button_for_scancode(u32 port, s32 scancode) noexcept { + u32 count = 0; + PADKeyButtonBinding* bindings = PADGetKeyButtonBindings(port, &count); + if (bindings == nullptr) { + return 0; + } + + for (u32 i = 0; i < count; ++i) { + if (bindings[i].scancode == scancode) { + return bindings[i].padButton; + } + } + + return 0; +} + +s32 menu_confirm_mouse_scancode() noexcept { + constexpr u32 port = PAD_CHAN0; + u32 count = 0; + PADKeyButtonBinding* bindings = PADGetKeyButtonBindings(port, &count); + if (bindings == nullptr) { + return PAD_KEY_MOUSE_LEFT; + } + + for (u32 i = 0; i < count; ++i) { + if (bindings[i].padButton == PAD_BUTTON_A && is_mouse_scancode(bindings[i].scancode)) { + return bindings[i].scancode; + } + } + + return pad_button_for_scancode(port, PAD_KEY_MOUSE_LEFT) != 0 ? PAD_KEY_INVALID : + PAD_KEY_MOUSE_LEFT; +} + +bool mouse_button_is_menu_confirm(s32 button) noexcept { + const s32 scancode = scancode_from_rml_button(button); + return scancode != PAD_KEY_INVALID && scancode == menu_confirm_mouse_scancode(); +} + +void suppress_pad_for_mouse_button(s32 button, bool held) noexcept { + const s32 scancode = scancode_from_rml_button(button); + if (scancode == PAD_KEY_INVALID) { + return; + } + + const PADButton padButton = pad_button_for_scancode(PAD_CHAN0, scancode); + if (padButton == 0) { + return; + } + + s_suppressedPadNextReadMask |= padButton; + if (held) { + s_suppressedPadHoldMask |= padButton; + } else { + s_suppressedPadHoldMask &= ~padButton; + } +} + +void set_position_from_rml(f32 x, f32 y) noexcept { + auto* context = aurora::rmlui::get_context(); + if (context == nullptr) { + return; + } + + const auto dimensions = context->GetDimensions(); + const f32 width = std::max(static_cast(dimensions.x), 1.0f); + const f32 height = std::max(static_cast(dimensions.y), 1.0f); + + s_state.x = mDoGph_gInf_c::getMinXF() + x / width * mDoGph_gInf_c::getWidthF(); + s_state.y = mDoGph_gInf_c::getMinYF() + y / height * mDoGph_gInf_c::getHeightF(); + s_state.valid = true; +} + +void clear_input_state() noexcept { + s_state = {}; + s_clickConsumed = false; + s_lastDialogChoice = 0xFF; + s_currentDialogChoice = 0xFF; + s_lastDialogChoiceValid = false; + s_currentDialogChoiceValid = false; + s_lastDialogClicked = false; + s_currentDialogClicked = false; + s_mouseActive = false; + s_mouseButtonCaptured = false; + s_mouseButton = -1; + s_suppressedPadHoldMask = 0; + s_suppressedPadNextReadMask = 0; + s_deferredActivationContext = Context::None; + s_deferredActivationTarget = 0xFF; +} + +} // namespace + +bool handle_fallthrough_pointer(f32 x, f32 y, Phase phase, bool touch, s32 mouseButton) noexcept { + if (!enabled()) { + return false; + } + + s_clickConsumed = false; + + if (!touch) { + if (phase == Phase::Press) { + if (!mouse_button_is_menu_confirm(mouseButton)) { + return false; + } + s_mouseButtonCaptured = true; + s_mouseButton = mouseButton; + suppress_pad_for_mouse_button(mouseButton, true); + } else if (phase == Phase::Release) { + if (!s_mouseButtonCaptured || s_mouseButton != mouseButton) { + return false; + } + suppress_pad_for_mouse_button(mouseButton, false); + s_mouseButtonCaptured = false; + s_mouseButton = -1; + } else if (phase == Phase::Cancel) { + if (s_mouseButtonCaptured) { + suppress_pad_for_mouse_button(s_mouseButton, false); + s_mouseButtonCaptured = false; + s_mouseButton = -1; + } else if (!s_mouseActive) { + return false; + } + } + s_mouseActive = true; + } + + if (phase != Phase::Cancel) { + set_position_from_rml(x, y); + } + s_state.touch = touch; + + switch (phase) { + case Phase::Press: + s_state.down = true; + s_state.pressed = true; + break; + case Phase::Release: + s_state.down = false; + s_state.released = true; + s_state.clicked = true; + break; + case Phase::Cancel: + s_state.down = false; + break; + case Phase::Move: + default: + break; + } + + return true; +} + +void begin_game_frame() noexcept { + s_currentContext = Context::None; + s_currentDialogChoice = 0xFF; + s_currentDialogChoiceValid = false; + s_currentDialogClicked = false; + s_clickConsumed = false; + if (!enabled()) { + clear_input_state(); + } +} + +void end_game_frame() noexcept { + s_lastContext = s_currentContext; + s_lastDialogChoice = s_currentDialogChoice; + s_lastDialogChoiceValid = s_currentDialogChoiceValid; + s_lastDialogClicked = s_currentDialogClicked; + s_state.pressed = false; + s_state.released = false; + s_state.clicked = false; + if (!s_state.down) { + s_state.valid = false; + } + s_clickConsumed = false; +} + +void begin_context(Context context) noexcept { + if (context == Context::None) { + return; + } + + if (s_lastContext == Context::None && s_currentContext == Context::None) { + s_state = {}; + s_mouseActive = false; + s_mouseButtonCaptured = false; + s_mouseButton = -1; + s_suppressedPadHoldMask = 0; + s_suppressedPadNextReadMask = 0; + s_deferredActivationContext = Context::None; + s_deferredActivationTarget = 0xFF; + } + + s_currentContext = context; +} + +bool active() noexcept { + return s_currentContext != Context::None || s_lastContext != Context::None; +} + +bool enabled() noexcept { + return getSettings().game.enableMenuPointer.getValue(); +} + +bool mouse_capture_active() noexcept { + return enabled() && s_mouseButtonCaptured; +} + +const State& state() noexcept { + return s_state; +} + +bool consume_click() noexcept { + if (!s_state.clicked || s_clickConsumed) { + return false; + } + + s_clickConsumed = true; + return true; +} + +void set_dialog_choice(u8 choice, bool clicked) noexcept { + s_currentDialogChoice = choice; + s_currentDialogChoiceValid = true; + s_currentDialogClicked = clicked; +} + +bool get_dialog_choice(u8& choice) noexcept { + if (s_currentDialogChoiceValid) { + choice = s_currentDialogChoice; + return true; + } + if (s_lastDialogChoiceValid) { + choice = s_lastDialogChoice; + return true; + } + return false; +} + +bool consume_dialog_click(u8& choice) noexcept { + if (s_currentDialogChoiceValid && s_currentDialogClicked) { + choice = s_currentDialogChoice; + s_currentDialogClicked = false; + return true; + } + if (s_lastDialogChoiceValid && s_lastDialogClicked) { + choice = s_lastDialogChoice; + s_lastDialogClicked = false; + return true; + } + return false; +} + +void defer_activation(Context context, u8 target) noexcept { + s_deferredActivationContext = context; + s_deferredActivationTarget = target; +} + +bool consume_deferred_activation(Context context, u8 target) noexcept { + if (s_deferredActivationContext != context || s_deferredActivationTarget != target) { + return false; + } + + s_deferredActivationContext = Context::None; + s_deferredActivationTarget = 0xFF; + return true; +} + +void clear_deferred_activation(Context context) noexcept { + if (s_deferredActivationContext != context) { + return; + } + + s_deferredActivationContext = Context::None; + s_deferredActivationTarget = 0xFF; +} + +u32 suppressed_pad_buttons(u32 port) noexcept { + if (port != PAD_CHAN0) { + return 0; + } + + return s_suppressedPadHoldMask | s_suppressedPadNextReadMask; +} + +void finish_pad_suppression_read(u32 port) noexcept { + if (port != PAD_CHAN0) { + return; + } + + s_suppressedPadNextReadMask = 0; +} + +bool hit_rect(f32 left, f32 top, f32 right, f32 bottom, f32 padding) noexcept { + const auto& state = menu_pointer::state(); + if (!state.valid) { + return false; + } + + if (left > right) { + std::swap(left, right); + } + if (top > bottom) { + std::swap(top, bottom); + } + + return state.x >= left - padding && state.x <= right + padding && state.y >= top - padding && + state.y <= bottom + padding; +} + +bool hit_pane(CPaneMgr* pane, f32 padding) noexcept { + if (pane == nullptr || pane->getPanePtr() == nullptr) { + return false; + } + + Mtx mtx; + Vec v0 = pane->getGlobalVtx(&mtx, 0, false, 0); + Vec v1 = pane->getGlobalVtx(&mtx, 1, false, 0); + Vec v2 = pane->getGlobalVtx(&mtx, 2, false, 0); + Vec v3 = pane->getGlobalVtx(&mtx, 3, false, 0); + const f32 left = std::min({v0.x, v1.x, v2.x, v3.x}); + const f32 right = std::max({v0.x, v1.x, v2.x, v3.x}); + const f32 top = std::min({v0.y, v1.y, v2.y, v3.y}); + const f32 bottom = std::max({v0.y, v1.y, v2.y, v3.y}); + return hit_rect(left, top, right, bottom, padding); +} + +bool hit_pane(J2DPane* pane, f32 padding) noexcept { + if (pane == nullptr || !pane->isVisible()) { + return false; + } + + const JGeometry::TBox2& bounds = pane->getBounds(); + return hit_rect(bounds.i.x, bounds.i.y, bounds.f.x, bounds.f.y, padding); +} + +} // namespace dusk::menu_pointer diff --git a/src/dusk/mouse.cpp b/src/dusk/mouse.cpp index 8ebfaf60cb..f1aa5672fd 100644 --- a/src/dusk/mouse.cpp +++ b/src/dusk/mouse.cpp @@ -1,4 +1,5 @@ #include "dusk/mouse.h" +#include "dusk/menu_pointer.h" #include "dusk/settings.h" #include "dusk/ui/ui.hpp" #include "d/actor/d_a_alink.h" @@ -26,16 +27,7 @@ void reset_deltas() { } bool queryMouseAimContext() { - if (!getSettings().game.enableMouseAim) { - return false; - } - - daAlink_c* link = daAlink_getAlinkActorClass(); - if (link == nullptr) { - return false; - } - - return link->checkAimContext() && dComIfGp_checkCameraAttentionStatus(link->field_0x317c, 0x10); + return getSettings().game.enableMouseAim.getValue() && dCamera_c::isAimActive(); } bool wantMouseCapture() { @@ -50,7 +42,7 @@ bool isWindowFocused(SDL_Window* window) { } bool shouldCaptureMouse(SDL_Window* window) { - if (window == nullptr || ui::any_document_visible()) { + if (window == nullptr || ui::any_document_visible() || menu_pointer::active()) { return false; } return wantMouseCapture() && isWindowFocused(window); diff --git a/src/dusk/settings.cpp b/src/dusk/settings.cpp index 74145e32ea..37585c5190 100644 --- a/src/dusk/settings.cpp +++ b/src/dusk/settings.cpp @@ -95,6 +95,9 @@ UserSettings g_userSettings = { .mouseCameraSensitivity {"game.mouseCameraSensitivity", 1.0f}, .invertMouseY {"game.invertMouseY", false}, .freeCamera {"game.freeCamera", false}, + .enableTouchControls {"game.enableTouchControls", false}, + .enableMenuPointer {"game.enableMenuPointer", true}, + .touchControlsLayout {"game.touchControlsLayout", ui::ControlLayout{}}, .invertCameraXAxis {"game.invertCameraXAxis", false}, .invertCameraYAxis {"game.invertCameraYAxis", false}, .invertFirstPersonXAxis {"game.invertFirstPersonXAxis", false}, @@ -103,6 +106,8 @@ UserSettings g_userSettings = { .invertAirSwimY {"game.invertAirSwimY", false}, .freeCameraXSensitivity {"game.freeCameraXSensitivity", 1.0f}, .freeCameraYSensitivity {"game.freeCameraYSensitivity", 1.0f}, + .touchCameraXSensitivity {"game.touchCameraXSensitivity", 1.0f}, + .touchCameraYSensitivity {"game.touchCameraYSensitivity", 1.0f}, .debugFlyCam {"game.debugFlyCam", false}, .debugFlyCamLockEvents {"game.debugFlyCamLockEvents", true}, .allowBackgroundInput {"game.allowBackgroundInput", true}, @@ -176,6 +181,18 @@ UserSettings g_userSettings = { ActionBindConfigVar{"actionBindings.callMidna_port2", PAD_NATIVE_BUTTON_INVALID}, ActionBindConfigVar{"actionBindings.callMidna_port3", PAD_NATIVE_BUTTON_INVALID}, }, + .openMapScreen { + ActionBindConfigVar{"actionBindings.openMapScreen_port0", PAD_NATIVE_BUTTON_INVALID}, + ActionBindConfigVar{"actionBindings.openMapScreen_port1", PAD_NATIVE_BUTTON_INVALID}, + ActionBindConfigVar{"actionBindings.openMapScreen_port2", PAD_NATIVE_BUTTON_INVALID}, + ActionBindConfigVar{"actionBindings.openMapScreen_port3", PAD_NATIVE_BUTTON_INVALID}, + }, + .toggleMinimap { + ActionBindConfigVar{"actionBindings.toggleMinimap_port0", PAD_NATIVE_BUTTON_INVALID}, + ActionBindConfigVar{"actionBindings.toggleMinimap_port1", PAD_NATIVE_BUTTON_INVALID}, + ActionBindConfigVar{"actionBindings.toggleMinimap_port2", PAD_NATIVE_BUTTON_INVALID}, + ActionBindConfigVar{"actionBindings.toggleMinimap_port3", PAD_NATIVE_BUTTON_INVALID}, + }, .openDusklightMenu { ActionBindConfigVar{"actionBindings.openDusklightMenu_port0", PAD_NATIVE_BUTTON_INVALID}, ActionBindConfigVar{"actionBindings.openDusklightMenu_port1", PAD_NATIVE_BUTTON_INVALID}, @@ -246,6 +263,8 @@ void registerSettings() { Register(g_userSettings.game.invertAirSwimY); Register(g_userSettings.game.freeCameraXSensitivity); Register(g_userSettings.game.freeCameraYSensitivity); + Register(g_userSettings.game.touchCameraXSensitivity); + Register(g_userSettings.game.touchCameraYSensitivity); Register(g_userSettings.game.minimalHUD); Register(g_userSettings.game.hudScale); Register(g_userSettings.game.pauseOnFocusLost); @@ -310,6 +329,9 @@ void registerSettings() { Register(g_userSettings.game.mouseCameraSensitivity); Register(g_userSettings.game.invertMouseY); Register(g_userSettings.game.freeCamera); + Register(g_userSettings.game.enableTouchControls); + Register(g_userSettings.game.enableMenuPointer); + Register(g_userSettings.game.touchControlsLayout); Register(g_userSettings.game.debugFlyCam); Register(g_userSettings.game.debugFlyCamLockEvents); Register(g_userSettings.game.allowBackgroundInput); @@ -337,6 +359,14 @@ void registerSettings() { Register(g_userSettings.actionBindings.callMidna[1]); Register(g_userSettings.actionBindings.callMidna[2]); Register(g_userSettings.actionBindings.callMidna[3]); + Register(g_userSettings.actionBindings.openMapScreen[0]); + Register(g_userSettings.actionBindings.openMapScreen[1]); + Register(g_userSettings.actionBindings.openMapScreen[2]); + Register(g_userSettings.actionBindings.openMapScreen[3]); + Register(g_userSettings.actionBindings.toggleMinimap[0]); + Register(g_userSettings.actionBindings.toggleMinimap[1]); + Register(g_userSettings.actionBindings.toggleMinimap[2]); + Register(g_userSettings.actionBindings.toggleMinimap[3]); Register(g_userSettings.actionBindings.openDusklightMenu[0]); Register(g_userSettings.actionBindings.openDusklightMenu[1]); Register(g_userSettings.actionBindings.openDusklightMenu[2]); diff --git a/src/dusk/touch_camera.cpp b/src/dusk/touch_camera.cpp new file mode 100644 index 0000000000..6f48d22c38 --- /dev/null +++ b/src/dusk/touch_camera.cpp @@ -0,0 +1,26 @@ +#include "dusk/touch_camera.h" + +namespace dusk::touch_camera { +namespace { +float s_yaw_dp = 0.0f; +float s_pitch_dp = 0.0f; +} // namespace + +void add_delta(float yaw_dp, float pitch_dp) noexcept { + s_yaw_dp += yaw_dp; + s_pitch_dp += pitch_dp; +} + +bool consume_delta(float& yaw_dp, float& pitch_dp) noexcept { + yaw_dp = s_yaw_dp; + pitch_dp = s_pitch_dp; + clear(); + return yaw_dp != 0.0f || pitch_dp != 0.0f; +} + +void clear() noexcept { + s_yaw_dp = 0.0f; + s_pitch_dp = 0.0f; +} + +} // namespace dusk::touch_camera diff --git a/src/dusk/ui/button.hpp b/src/dusk/ui/button.hpp index bf97a66e6e..f2c9756c98 100644 --- a/src/dusk/ui/button.hpp +++ b/src/dusk/ui/button.hpp @@ -19,8 +19,6 @@ public: void set_text(const Rml::String& text); Button& on_pressed(ButtonCallback callback); - const Rml::String& get_text() const { return mProps.text; } - private: void update_props(Props props); diff --git a/src/dusk/ui/controller_config.cpp b/src/dusk/ui/controller_config.cpp index 20e9ef62d5..a506a593a6 100644 --- a/src/dusk/ui/controller_config.cpp +++ b/src/dusk/ui/controller_config.cpp @@ -861,6 +861,20 @@ void ControllerConfigWindow::render_page(Pane& pane, int port, Page page) { break; } case Page::Rumble: { + if (PADCanForceDeviceRumble(static_cast(port))) { + pane.add_child(BoolButton::Props{ + .key = "Use Device Haptics", + .getValue = [port] { return PADGetForceDeviceRumble(static_cast(port)); }, + .setValue = + [port](bool value) { + PADSetForceDeviceRumble(static_cast(port), value ? TRUE : FALSE); + PADSerializeMappings(); + }, + .isDisabled = [this] { return mRumbleTestActive; }, + }); + pane.add_text("Use native device haptics instead of controller rumble. " + "Useful for devices with built-in gamepads."); + } auto& rumbleTest = pane.add_select_button({ .key = "Test Rumble", .getValue = diff --git a/src/dusk/ui/controls.hpp b/src/dusk/ui/controls.hpp new file mode 100644 index 0000000000..2a83d6127f --- /dev/null +++ b/src/dusk/ui/controls.hpp @@ -0,0 +1,192 @@ +#pragma once + +#include + +namespace dusk::ui { + +struct EquipTarget { + float left = 0.0f; + float top = 0.0f; + float width = 0.0f; + float height = 0.0f; + bool valid = false; +}; + +enum class Control { + A, + B, + X, + Y, + Z, + L, + R, + FIRST_PERSON, + ITEMS, + COLLECTIONS, + MAP, + SKIP, + DPAD_UP, + DPAD_DOWN, + DPAD_LEFT, + DPAD_RIGHT, + COUNT, +}; + +enum class ControlAnchor : u8 { + None, + Top, + Left, + Bottom, + Right, + TopLeft, + TopRight, + BottomLeft, + BottomRight, +}; + +struct ControlProps { + float x = 0.0f; + float y = 0.0f; + float w = 0.0f; + float h = 0.0f; + float scale = 1.0f; + ControlAnchor anchor = ControlAnchor::None; +}; + +struct ControlRect { + float l = 0.0f; + float t = 0.0f; + float w = 0.0f; + float h = 0.0f; +}; + +struct ResolvedControlLayout { + ControlRect visual; + ControlRect box; + float scale = 1.0f; +}; + +struct ControlLayoutSize { + float w = 0.0f; + float h = 0.0f; +}; + +struct ControlLayout { + static constexpr int Version = 1; + + int version = Version; + std::map > controls; +}; + +constexpr std::array kControlLayoutIds = { + "actionBar", + "buttonA", + "buttonB", + "buttonX", + "buttonY", + "buttonZ", + "skip", + "triggerL", + "triggerR", +}; + +constexpr bool is_control_layout_id(std::string_view id) noexcept { + for (const auto knownId : kControlLayoutIds) { + if (id == knownId) { + return true; + } + } + return false; +} + +constexpr ControlRect resolve_anchored_rect( + ControlAnchor anchor, float x, float y, float w, float h, ControlLayoutSize docSize) noexcept { + switch (anchor) { + case ControlAnchor::None: + return {x * docSize.w - w * 0.5f, y * docSize.h - h * 0.5f, w, h}; + case ControlAnchor::Top: + return {x * docSize.w - w * 0.5f, y, w, h}; + case ControlAnchor::Bottom: + return {x * docSize.w - w * 0.5f, docSize.h - y - h, w, h}; + case ControlAnchor::Left: + return {x, y * docSize.h - h * 0.5f, w, h}; + case ControlAnchor::Right: + return {docSize.w - x - w, y * docSize.h - h * 0.5f, w, h}; + case ControlAnchor::TopLeft: + return {x, y, w, h}; + case ControlAnchor::TopRight: + return {docSize.w - x - w, y, w, h}; + case ControlAnchor::BottomLeft: + return {x, docSize.h - y - h, w, h}; + case ControlAnchor::BottomRight: + return {docSize.w - x - w, docSize.h - y - h, w, h}; + } + return {}; +} + +constexpr ResolvedControlLayout resolve_control_layout( + ControlProps props, ControlLayoutSize docSize) noexcept { + const float visualW = props.w * props.scale; + const float visualH = props.h * props.scale; + const ControlRect visual = + resolve_anchored_rect(props.anchor, props.x, props.y, visualW, visualH, docSize); + const ControlRect box = { + visual.l + (visual.w - props.w) * 0.5f, + visual.t + (visual.h - props.h) * 0.5f, + props.w, + props.h, + }; + return { + .visual = visual, + .box = box, + .scale = props.scale, + }; +} + +constexpr ControlProps encode_control_props(ControlRect visual, ControlLayoutSize docSize, + ControlProps props, ControlAnchor anchor) noexcept { + props.anchor = anchor; + + switch (anchor) { + case ControlAnchor::None: + props.x = (visual.l + visual.w * 0.5f) / docSize.w; + props.y = (visual.t + visual.h * 0.5f) / docSize.h; + break; + case ControlAnchor::Top: + props.x = (visual.l + visual.w * 0.5f) / docSize.w; + props.y = visual.t; + break; + case ControlAnchor::Bottom: + props.x = (visual.l + visual.w * 0.5f) / docSize.w; + props.y = docSize.h - visual.t - visual.h; + break; + case ControlAnchor::Left: + props.x = visual.l; + props.y = (visual.t + visual.h * 0.5f) / docSize.h; + break; + case ControlAnchor::Right: + props.x = docSize.w - visual.l - visual.w; + props.y = (visual.t + visual.h * 0.5f) / docSize.h; + break; + case ControlAnchor::TopLeft: + props.x = visual.l; + props.y = visual.t; + break; + case ControlAnchor::TopRight: + props.x = docSize.w - visual.l - visual.w; + props.y = visual.t; + break; + case ControlAnchor::BottomLeft: + props.x = visual.l; + props.y = docSize.h - visual.t - visual.h; + break; + case ControlAnchor::BottomRight: + props.x = docSize.w - visual.l - visual.w; + props.y = docSize.h - visual.t - visual.h; + break; + } + + return props; +} + +} // namespace dusk::ui diff --git a/src/dusk/ui/document.cpp b/src/dusk/ui/document.cpp index a7bcc3f9ed..fc8be92a83 100644 --- a/src/dusk/ui/document.cpp +++ b/src/dusk/ui/document.cpp @@ -5,6 +5,7 @@ #include "Z2AudioLib/Z2SeMgr.h" #include "m_Do/m_Do_audio.h" +#include namespace dusk::ui { namespace { @@ -19,11 +20,15 @@ Rml::ElementDocument* load_document(const Rml::String& source) { } // namespace -Document::Document(const Rml::String& source) : mDocument(load_document(source)) { +Document::Document(const Rml::String& source, bool passive) + : mDocument(load_document(source)), mPassive(passive) { // Block events while hidden (except for Menu command); play nav sounds when visible listen( Rml::EventId::Keydown, [this](Rml::Event& event) { + if (mPassive) { + return; + } const auto cmd = map_nav_event(event); if (cmd != NavCommand::Menu && !visible()) { event.StopImmediatePropagation(); @@ -40,11 +45,14 @@ Document::Document(const Rml::String& source) : mDocument(load_document(source)) listen(Rml::EventId::Scroll, blockUnlessVisible, true); listen(Rml::EventId::Keydown, [this](Rml::Event& event) { - const auto cmd = map_nav_event(event); - if (cmd == NavCommand::None) { + if (mPassive) { + auto* doc = top_document(); + if (doc != nullptr && doc->handle_nav_event(event)) { + event.StopPropagation(); + } return; } - if (handle_nav_command(event, cmd)) { + if (handle_nav_event(event)) { event.StopPropagation(); } }); @@ -97,6 +105,18 @@ void Document::listen(Rml::Element* element, Rml::EventId event, std::make_unique(element, event, std::move(callback), capture)); } +void Document::listen(Rml::Element* element, const Rml::String& event, + ScopedEventListener::Callback callback, bool capture) { + if (element == nullptr) { + element = mDocument; + } + if (element == nullptr || event.empty() || !callback) { + return; + } + mListeners.emplace_back( + std::make_unique(element, event, std::move(callback), capture)); +} + bool Document::visible() const { if (mDocument == nullptr) { return false; @@ -104,6 +124,14 @@ bool Document::visible() const { return *mDocument->GetProperty(Rml::PropertyId::Visibility) == Rml::Style::Visibility::Visible; } +bool Document::handle_nav_event(Rml::Event& event) { + const auto cmd = map_nav_event(event); + if (cmd == NavCommand::None) { + return false; + } + return handle_nav_command(event, cmd); +} + bool Document::handle_nav_command(Rml::Event& event, NavCommand cmd) { if (cmd == NavCommand::Menu) { mDoAud_seStartMenu(visible() ? kSoundMenuClose : kSoundMenuOpen); diff --git a/src/dusk/ui/document.hpp b/src/dusk/ui/document.hpp index d0f4cae841..cf61267ee9 100644 --- a/src/dusk/ui/document.hpp +++ b/src/dusk/ui/document.hpp @@ -7,7 +7,7 @@ namespace dusk::ui { class Document { public: - Document(const Rml::String& source); + explicit Document(const Rml::String& source, bool passive = false); virtual ~Document(); Document(const Document&) = delete; @@ -21,9 +21,15 @@ public: void listen(Rml::Element* element, Rml::EventId event, ScopedEventListener::Callback callback, bool capture = false); + void listen(Rml::Element* element, const Rml::String& event, + ScopedEventListener::Callback callback, bool capture = false); void listen(Rml::EventId event, ScopedEventListener::Callback callback, bool capture = false) { listen(mDocument, event, std::move(callback), capture); } + void listen( + const Rml::String& event, ScopedEventListener::Callback callback, bool capture = false) { + listen(mDocument, event, std::move(callback), capture); + } void toggle() { if (visible()) { hide(false); @@ -43,6 +49,8 @@ public: bool pending_close() const { return mPendingClose; } bool closed() const { return mClosed; } + bool handle_nav_event(Rml::Event& event); + protected: virtual bool handle_nav_command(Rml::Event& event, NavCommand cmd); @@ -50,6 +58,7 @@ protected: std::vector > mListeners; bool mPendingClose = false; bool mClosed = false; + bool mPassive = false; }; } // namespace dusk::ui diff --git a/src/dusk/ui/icon_provider.cpp b/src/dusk/ui/icon_provider.cpp new file mode 100644 index 0000000000..b8307b92f7 --- /dev/null +++ b/src/dusk/ui/icon_provider.cpp @@ -0,0 +1,899 @@ +#include "icon_provider.hpp" + +#include "d/dolzel.h" // IWYU pragma: keep + +#ifdef AURORA_ENABLE_RMLUI + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "JSystem/J2DGraph/J2DPicture.h" +#include "JSystem/JUtility/JUTTexture.h" +#include "d/actor/d_a_alink.h" +#include "d/d_com_inf_game.h" +#include "d/d_item_data.h" +#include "d/d_meter2_info.h" +#include "d/d_pane_class.h" + +namespace dusk::ui { +namespace { + +constexpr std::string_view kScheme = "item"; +constexpr std::string_view kSourcePrefix = "item://"; +constexpr std::string_view kMeterScheme = "meter"; +constexpr std::string_view kMeterSourcePrefix = "meter://"; +constexpr size_t kItemTextureBufferSize = 0xC00; +constexpr size_t kMaxCachedIcons = 128; +constexpr uint64_t kMeterTextureSourceSlots = 8; +constexpr uint32_t kMinRenderedPaneIconSize = 128; +constexpr uint32_t kMaxRenderedPaneIconSize = 1024; + +struct alignas(32) ItemTextureBuffer { + std::array bytes{}; + + std::byte* data() noexcept { return bytes.data(); } + const std::byte* data() const noexcept { return bytes.data(); } +}; + +struct CachedIcon { + std::vector pixels; + uint32_t width = 0; + uint32_t height = 0; +}; + +struct RuntimeIconState { + CachedIcon icon; + uint64_t revision = 0; + bool valid = false; +}; + +struct LayerColors { + JUtility::TColor black; + JUtility::TColor white; + std::array corner; +}; + +struct RectF { + float left = std::numeric_limits::max(); + float top = std::numeric_limits::max(); + float right = std::numeric_limits::lowest(); + float bottom = std::numeric_limits::lowest(); + + bool valid() const noexcept { return left < right && top < bottom; } + float width() const noexcept { return right - left; } + float height() const noexcept { return bottom - top; } + + void include(float x, float y) noexcept { + if (!std::isfinite(x) || !std::isfinite(y)) { + return; + } + left = std::min(left, x); + top = std::min(top, y); + right = std::max(right, x); + bottom = std::max(bottom, y); + } + + void include(const RectF& rect) noexcept { + if (!rect.valid()) { + return; + } + include(rect.left, rect.top); + include(rect.right, rect.bottom); + } +}; + +struct PictureLayer { + J2DPicture* picture = nullptr; + RectF rect; + uint8_t alpha = 0; +}; + +struct SurfaceDeleter { + void operator()(SDL_Surface* surface) const noexcept { SDL_DestroySurface(surface); } +}; + +using SurfacePtr = std::unique_ptr; + +std::unordered_map& icon_cache() { + static auto* cache = new std::unordered_map(); + return *cache; +} + +RuntimeIconState& midna_icon_state() { + static auto* state = new RuntimeIconState(); + return *state; +} + +std::string_view strip_query(std::string_view path) noexcept { + const auto queryPos = path.find_first_of("?#"); + if (queryPos != std::string_view::npos) { + path = path.substr(0, queryPos); + } + return path; +} + +std::optional parse_item_no(std::string_view text) noexcept { + if (text.starts_with("0x") || text.starts_with("0X")) { + text.remove_prefix(2); + } + unsigned value = 0; + const auto* first = text.data(); + const auto* last = text.data() + text.size(); + const auto [ptr, ec] = std::from_chars(first, last, value, 16); + if (ec != std::errc() || ptr != last || value > 0xFF) { + return std::nullopt; + } + return static_cast(value); +} + +bool is_valid_icon_item(u8 itemNo) noexcept { + return itemNo != 0 && itemNo != dItemNo_NONE_e; +} + +u8 item_icon_texture_item(u8 itemNo) noexcept { + if (itemNo == dItemNo_LIGHT_ARROW_e) { + return dItemNo_BOW_e; + } + return itemNo; +} + +std::optional selected_slot_item(int slot) noexcept { + const u8 itemNo = dComIfGp_getSelectItem(slot); + if (!is_valid_icon_item(itemNo)) { + return std::nullopt; + } + return item_icon_texture_item(itemNo); +} + +bool is_sword_item(u8 itemNo) noexcept { + switch (itemNo) { + case dItemNo_WOOD_STICK_e: + case dItemNo_SWORD_e: + case dItemNo_MASTER_SWORD_e: + case dItemNo_LIGHT_SWORD_e: + return true; + default: + return false; + } +} + +std::optional b_button_item() noexcept { + const u8 action = dComIfGp_getAStatus(); + if (action == 0x26 || action == 0x2E) { + const u8 sword = dComIfGs_getSelectEquipSword(); + if (is_sword_item(sword)) { + return sword; + } + return std::nullopt; + } + if (action == 0x4F) { + return dItemNo_LURE_ROD_e; + } + return std::nullopt; +} + +std::optional item_for_source(std::string_view source) noexcept { + if (!source.starts_with(kSourcePrefix)) { + return std::nullopt; + } + + std::string_view path = strip_query(source.substr(kSourcePrefix.size())); + if (path.starts_with("item/")) { + path.remove_prefix(5); + const auto itemNo = parse_item_no(path); + if (itemNo && is_valid_icon_item(*itemNo)) { + return item_icon_texture_item(*itemNo); + } + return std::nullopt; + } + if (path == "slot/x") { + return selected_slot_item(0); + } + if (path == "slot/y") { + return selected_slot_item(1); + } + if (path == "button/b") { + return b_button_item(); + } + return std::nullopt; +} + +uint32_t item_revision(u8 itemNo) noexcept { + uint32_t revision = itemNo; + revision = revision * 131u + g_meter2_info.getItemType(itemNo); + + if (itemNo == dItemNo_KANTERA_e || itemNo == dItemNo_KANTERA2_e) { + revision = revision * 131u + (dComIfGs_getOil() == 0 ? 0u : 1u); + } + if (itemNo == dItemNo_COPY_ROD_e) { + auto* player = daPy_getPlayerActorClass(); + revision = revision * 131u + (player != nullptr && player->checkCopyRodTopUse() ? 1u : 0u); + } + return revision; +} + +std::string item_source_for_item(u8 itemNo) { + itemNo = item_icon_texture_item(itemNo); + return fmt::format("{}://item/{:02x}?rev={:08x}", kScheme, itemNo, item_revision(itemNo)); +} + +std::optional selected_slot_count(int slot) noexcept { + const u8 itemNo = dComIfGp_getSelectItem(slot); + if (!is_valid_icon_item(itemNo)) { + return std::nullopt; + } + if (item_icon_texture_item(itemNo) == dItemNo_KANTERA_e || + item_icon_texture_item(itemNo) == dItemNo_KANTERA2_e) + { + return std::nullopt; + } + + int count = 0; + int max = 0; + switch (itemNo) { + case dItemNo_BOW_e: + case dItemNo_LIGHT_ARROW_e: + case dItemNo_ARROW_LV1_e: + case dItemNo_ARROW_LV2_e: + case dItemNo_ARROW_LV3_e: + case dItemNo_HAWK_ARROW_e: + count = dComIfGs_getArrowNum(); + max = dComIfGs_getArrowMax(); + break; + case dItemNo_BOMB_ARROW_e: + count = std::min(dComIfGp_getSelectItemNum(slot), dComIfGs_getArrowNum()); + max = std::max(dComIfGp_getSelectItemMaxNum(slot), dComIfGs_getArrowMax()); + break; + default: + count = dComIfGp_getSelectItemNum(slot); + max = dComIfGp_getSelectItemMaxNum(slot); + break; + } + if (max <= 0) { + return std::nullopt; + } + return std::clamp(count, 0, max); +} + +aurora::gfx::ConvertedTexture decode_timg(const ResTIMG* image) { + if (image == nullptr || image->width.host() == 0 || image->height.host() == 0) { + return {}; + } + + const auto* base = reinterpret_cast(image); + const auto width = image->width.host(); + const auto height = image->height.host(); + const uint32_t textureSize = GXGetTexBufferSize(width, height, image->format, GX_FALSE, 0); + const auto* textureData = base + static_cast(image->imageOffset); + + if (image->indexTexture != 0) { + const auto* paletteData = base + static_cast(image->paletteOffset); + return aurora::gfx::convert_texture_palette(image->format, width, height, 1, + aurora::ArrayRef{textureData, textureSize}, static_cast(image->colorFormat), + image->numColors, + aurora::ArrayRef{paletteData, static_cast(image->numColors) * 2}); + } + + return aurora::gfx::convert_texture( + image->format, width, height, 1, aurora::ArrayRef{textureData, textureSize}); +} + +uint8_t lerp_u8(uint8_t a, uint8_t b, uint32_t t) noexcept { + return static_cast( + (static_cast(a) * (255u - t) + static_cast(b) * t) / 255u); +} + +JUtility::TColor lerp_color( + const JUtility::TColor& a, const JUtility::TColor& b, uint32_t t) noexcept { + return { + lerp_u8(a.r, b.r, t), + lerp_u8(a.g, b.g, t), + lerp_u8(a.b, b.b, t), + lerp_u8(a.a, b.a, t), + }; +} + +JUtility::TColor bilerp_corner( + const LayerColors& colors, uint32_t x, uint32_t y, uint32_t width, uint32_t height) noexcept { + const uint32_t u = width > 1 ? (x * 255u) / (width - 1u) : 0u; + const uint32_t v = height > 1 ? (y * 255u) / (height - 1u) : 0u; + const JUtility::TColor top = lerp_color(colors.corner[0], colors.corner[1], u); + const JUtility::TColor bottom = lerp_color(colors.corner[2], colors.corner[3], u); + return lerp_color(top, bottom, v); +} + +std::array apply_layer_colors(std::span src, + const LayerColors& colors, uint32_t x, uint32_t y, uint32_t width, uint32_t height) noexcept { + std::array out{ + lerp_u8(colors.black.r, colors.white.r, src[0]), + lerp_u8(colors.black.g, colors.white.g, src[1]), + lerp_u8(colors.black.b, colors.white.b, src[2]), + src[3], + }; + + const auto corner = bilerp_corner(colors, x, y, width, height); + out[0] = static_cast((static_cast(out[0]) * corner.r) / 255u); + out[1] = static_cast((static_cast(out[1]) * corner.g) / 255u); + out[2] = static_cast((static_cast(out[2]) * corner.b) / 255u); + out[3] = static_cast((static_cast(out[3]) * corner.a) / 255u); + return out; +} + +void blend_premultiplied(uint8_t* dst, const std::array& src) noexcept { + const uint32_t srcAlpha = src[3]; + const uint32_t invAlpha = 255u - srcAlpha; + const uint32_t srcR = (static_cast(src[0]) * srcAlpha) / 255u; + const uint32_t srcG = (static_cast(src[1]) * srcAlpha) / 255u; + const uint32_t srcB = (static_cast(src[2]) * srcAlpha) / 255u; + + dst[0] = static_cast( + std::min(255u, srcR + (static_cast(dst[0]) * invAlpha) / 255u)); + dst[1] = static_cast( + std::min(255u, srcG + (static_cast(dst[1]) * invAlpha) / 255u)); + dst[2] = static_cast( + std::min(255u, srcB + (static_cast(dst[2]) * invAlpha) / 255u)); + dst[3] = static_cast( + std::min(255u, srcAlpha + (static_cast(dst[3]) * invAlpha) / 255u)); +} + +LayerColors layer_colors(const J2DPicture& picture) noexcept { + return { + .black = picture.getBlack(), + .white = picture.getWhite(), + .corner = {picture.corner(0), picture.corner(1), picture.corner(2), picture.corner(3)}, + }; +} + +LayerColors layer_colors(J2DPicture& picture, uint8_t alpha) noexcept { + std::array corners{}; + picture.getNewColor(corners.data()); + for (auto& corner : corners) { + corner.a = static_cast((static_cast(corner.a) * alpha) / 255u); + } + return { + .black = picture.getBlack(), + .white = picture.getWhite(), + .corner = corners, + }; +} + +std::optional render_item_icon(u8 itemNo) { + std::array buffers{}; + std::array pictures{}; + + const int textureCount = + dMeter2Info_readItemTexture(itemNo, buffers[0].data(), &pictures[0], buffers[1].data(), + &pictures[1], buffers[2].data(), &pictures[2], buffers[3].data(), &pictures[3], -1); + if (textureCount <= 0) { + return std::nullopt; + } + + std::array decodedLayers{}; + std::array colors{}; + int decodedCount = 0; + for (int i = 0; i < textureCount && i < static_cast(decodedLayers.size()); ++i) { + auto decoded = decode_timg(reinterpret_cast(buffers[i].data())); + if (decoded.data.empty()) { + continue; + } + colors[decodedCount] = layer_colors(pictures[i]); + decodedLayers[decodedCount] = std::move(decoded); + ++decodedCount; + } + if (decodedCount == 0) { + return std::nullopt; + } + + CachedIcon icon{ + .width = decodedLayers[0].width, + .height = decodedLayers[0].height, + }; + icon.pixels.assign(static_cast(icon.width) * static_cast(icon.height) * 4, 0); + + for (int layer = 0; layer < decodedCount; ++layer) { + const auto& decoded = decodedLayers[layer]; + for (uint32_t y = 0; y < icon.height; ++y) { + const uint32_t sourceY = decoded.height > 0 ? (y * decoded.height) / icon.height : 0; + for (uint32_t x = 0; x < icon.width; ++x) { + const uint32_t sourceX = decoded.width > 0 ? (x * decoded.width) / icon.width : 0; + const size_t sourceOffset = + (static_cast(sourceY) * decoded.width + static_cast(sourceX)) * + 4; + if (sourceOffset + 3 >= decoded.data.size()) { + continue; + } + + const std::span sourcePixel( + decoded.data.data() + sourceOffset, 4); + const auto pixel = + apply_layer_colors(sourcePixel, colors[layer], x, y, icon.width, icon.height); + uint8_t* destination = + icon.pixels.data() + + (static_cast(y) * icon.width + static_cast(x)) * 4; + blend_premultiplied(destination, pixel); + } + } + } + + return icon; +} + +SurfacePtr create_rgba_surface(uint32_t width, uint32_t height) { + if (width == 0 || height == 0 || + width > static_cast(std::numeric_limits::max()) || + height > static_cast(std::numeric_limits::max())) + { + return {}; + } + + return SurfacePtr{SDL_CreateSurface( + static_cast(width), static_cast(height), SDL_PIXELFORMAT_RGBA32)}; +} + +bool lock_surface(SDL_Surface* surface) noexcept { + return surface != nullptr && (!SDL_MUSTLOCK(surface) || SDL_LockSurface(surface)); +} + +void unlock_surface(SDL_Surface* surface) noexcept { + if (surface != nullptr && SDL_MUSTLOCK(surface)) { + SDL_UnlockSurface(surface); + } +} + +SurfacePtr create_layer_surface( + const aurora::gfx::ConvertedTexture& decoded, const LayerColors& colors) { + if (decoded.width == 0 || decoded.height == 0 || decoded.data.empty()) { + return {}; + } + + auto surface = create_rgba_surface(decoded.width, decoded.height); + if (!surface || !lock_surface(surface.get())) { + return {}; + } + + for (uint32_t y = 0; y < decoded.height; ++y) { + auto* destination = static_cast(surface->pixels) + + static_cast(y) * static_cast(surface->pitch); + for (uint32_t x = 0; x < decoded.width; ++x) { + const size_t sourceOffset = + (static_cast(y) * decoded.width + static_cast(x)) * 4; + if (sourceOffset + 3 >= decoded.data.size()) { + continue; + } + + const std::span sourcePixel(decoded.data.data() + sourceOffset, 4); + const auto pixel = + apply_layer_colors(sourcePixel, colors, x, y, decoded.width, decoded.height); + std::memcpy(destination + static_cast(x) * 4, pixel.data(), pixel.size()); + } + } + + unlock_surface(surface.get()); + SDL_SetSurfaceBlendMode(surface.get(), SDL_BLENDMODE_BLEND); + return surface; +} + +std::optional icon_from_surface(SDL_Surface* surface) { + if (surface == nullptr || surface->w <= 0 || surface->h <= 0) { + return std::nullopt; + } + + CachedIcon icon{ + .width = static_cast(surface->w), + .height = static_cast(surface->h), + }; + const size_t rowSize = static_cast(icon.width) * 4u; + icon.pixels.resize(rowSize * static_cast(icon.height)); + + if (!lock_surface(surface)) { + return std::nullopt; + } + + for (uint32_t y = 0; y < icon.height; ++y) { + const auto* source = static_cast(surface->pixels) + + static_cast(y) * static_cast(surface->pitch); + auto* destination = icon.pixels.data() + static_cast(y) * rowSize; + std::memcpy(destination, source, rowSize); + } + + unlock_surface(surface); + return icon; +} + +RectF pane_global_rect(J2DPane* pane) noexcept { + RectF rect; + CPaneMgr paneMgr; + Mtx m; + for (u8 i = 0; i < 4; ++i) { + const Vec vertex = paneMgr.getGlobalVtx(pane, &m, i, false, 0); + rect.include(vertex.x, vertex.y); + } + return rect; +} + +uint8_t effective_pane_alpha(J2DPane& pane, uint8_t parentAlpha) noexcept { + uint32_t alpha = pane.getAlpha(); + if (pane.isInfluencedAlpha()) { + alpha = alpha * parentAlpha / 255u; + } + return static_cast(alpha); +} + +void collect_picture_layers( + J2DPane* pane, std::vector& layers, uint8_t parentAlpha = 255) noexcept { + if (pane == nullptr || !pane->isVisible()) { + return; + } + + const uint8_t paneAlpha = effective_pane_alpha(*pane, parentAlpha); + if (paneAlpha == 0) { + return; + } + + if (pane->getKind() == MULTI_CHAR('PIC1') || pane->getKind() == MULTI_CHAR('PIC2')) { + auto* picture = static_cast(pane); + if (picture->getTexture(0) != nullptr) { + RectF rect = pane_global_rect(pane); + if (rect.valid()) { + layers.push_back({ + .picture = picture, + .rect = rect, + .alpha = paneAlpha, + }); + } + } + } + + for (J2DPane* child = pane->getFirstChildPane(); child != nullptr; + child = child->getNextChildPane()) + { + collect_picture_layers(child, layers, paneAlpha); + } +} + +std::optional icon_dimension(float value) noexcept { + if (!std::isfinite(value) || value <= 0.0f) { + return std::nullopt; + } + + const auto dimension = static_cast(std::ceil(value)); + if (dimension == 0 || dimension > kMaxRenderedPaneIconSize) { + return std::nullopt; + } + return dimension; +} + +float pane_icon_render_scale(const std::vector& layers, const RectF& canvas) { + float scale = 1.0f; + for (const auto& layer : layers) { + if (layer.picture == nullptr || !layer.rect.valid() || layer.rect.width() <= 0.0f || + layer.rect.height() <= 0.0f) + { + continue; + } + + auto* texture = layer.picture->getTexture(0); + const ResTIMG* image = texture != nullptr ? texture->getTexInfo() : nullptr; + if (image == nullptr || image->width.host() == 0 || image->height.host() == 0) { + continue; + } + + scale = std::max(scale, static_cast(image->width) / layer.rect.width()); + scale = std::max(scale, static_cast(image->height) / layer.rect.height()); + } + + const float canvasMax = std::max(canvas.width(), canvas.height()); + if (canvasMax <= 0.0f) { + return scale; + } + + const float minScale = static_cast(kMinRenderedPaneIconSize) / canvasMax; + const float maxScale = static_cast(kMaxRenderedPaneIconSize) / canvasMax; + return std::clamp(std::max(scale, minScale), 1.0f, maxScale); +} + +void composite_picture_layer( + SDL_Surface& icon, const RectF& canvas, const PictureLayer& layer, float renderScale) { + if (layer.picture == nullptr || !layer.rect.valid()) { + return; + } + + auto* texture = layer.picture->getTexture(0); + if (texture == nullptr) { + return; + } + + auto decoded = decode_timg(texture->getTexInfo()); + if (decoded.data.empty() || decoded.width == 0 || decoded.height == 0) { + return; + } + + const auto colors = layer_colors(*layer.picture, layer.alpha); + auto layerSurface = create_layer_surface(decoded, colors); + if (!layerSurface) { + return; + } + + const float dstLeft = (layer.rect.left - canvas.left) * renderScale; + const float dstTop = (layer.rect.top - canvas.top) * renderScale; + const float dstRight = (layer.rect.right - canvas.left) * renderScale; + const float dstBottom = (layer.rect.bottom - canvas.top) * renderScale; + const float dstWidth = dstRight - dstLeft; + const float dstHeight = dstBottom - dstTop; + if (dstWidth <= 0.0f || dstHeight <= 0.0f) { + return; + } + + const int x0 = std::clamp(static_cast(std::floor(dstLeft)), 0, icon.w); + const int y0 = std::clamp(static_cast(std::floor(dstTop)), 0, icon.h); + const int x1 = std::clamp(static_cast(std::ceil(dstRight)), 0, icon.w); + const int y1 = std::clamp(static_cast(std::ceil(dstBottom)), 0, icon.h); + if (x0 >= x1 || y0 >= y1) { + return; + } + + SDL_Rect destinationRect{ + .x = x0, + .y = y0, + .w = x1 - x0, + .h = y1 - y0, + }; + SDL_BlitSurfaceScaled( + layerSurface.get(), nullptr, &icon, &destinationRect, SDL_SCALEMODE_LINEAR); +} + +std::optional render_j2d_pane_icon(J2DPane* pane) { + std::vector layers; + collect_picture_layers(pane, layers); + if (layers.empty()) { + return std::nullopt; + } + + RectF canvas; + for (const auto& layer : layers) { + canvas.include(layer.rect); + } + if (!canvas.valid()) { + return std::nullopt; + } + + const float renderScale = pane_icon_render_scale(layers, canvas); + auto width = icon_dimension(canvas.width() * renderScale); + auto height = icon_dimension(canvas.height() * renderScale); + if (!width || !height) { + return std::nullopt; + } + + auto surface = create_rgba_surface(*width, *height); + if (!surface) { + return std::nullopt; + } + + for (const auto& layer : layers) { + composite_picture_layer(*surface, canvas, layer, renderScale); + } + + return icon_from_surface(surface.get()); +} + +std::optional icon_provider(std::string_view source) { + const auto itemNo = item_for_source(source); + if (!itemNo) { + return std::nullopt; + } + + auto& cache = icon_cache(); + const std::string key(source); + auto it = cache.find(key); + if (it == cache.end()) { + auto icon = render_item_icon(*itemNo); + if (!icon) { + return std::nullopt; + } + if (cache.size() >= kMaxCachedIcons) { + cache.erase(cache.begin()); + } + it = cache.emplace(key, std::move(*icon)).first; + } + + const auto& icon = it->second; + return aurora::rmlui::RuntimeTexture{ + .width = icon.width, + .height = icon.height, + .rgba8 = + std::span(reinterpret_cast(icon.pixels.data()), icon.pixels.size()), + .premultipliedAlpha = true, + }; +} + +std::optional meter_texture_provider(std::string_view source) { + if (!source.starts_with(kMeterSourcePrefix)) { + return std::nullopt; + } + + const std::string name(strip_query(source.substr(kMeterSourcePrefix.size()))); + if (name != "midna") { + return std::nullopt; + } + + const auto& state = midna_icon_state(); + if (!state.valid) { + return std::nullopt; + } + + return aurora::rmlui::RuntimeTexture{ + .width = state.icon.width, + .height = state.icon.height, + .rgba8 = std::span( + reinterpret_cast(state.icon.pixels.data()), state.icon.pixels.size()), + .premultipliedAlpha = true, + }; +} + +} // namespace + +void register_icon_texture_provider() noexcept { + aurora::rmlui::register_texture_provider(std::string(kScheme), icon_provider); + aurora::rmlui::register_texture_provider(std::string(kMeterScheme), meter_texture_provider); +} + +void unregister_icon_texture_provider() noexcept { + aurora::rmlui::unregister_texture_provider(kScheme); + aurora::rmlui::unregister_texture_provider(kMeterScheme); + icon_cache().clear(); + midna_icon_state() = {}; +} + +void update_midna_icon_texture(J2DPane* pane) noexcept { + auto& state = midna_icon_state(); + if (pane == nullptr || !pane->isVisible()) { + if (state.valid) { + state.valid = false; + state.icon = {}; + state.revision++; + } + return; + } + + auto icon = render_j2d_pane_icon(pane); + if (!icon) { + if (state.valid) { + state.valid = false; + state.icon = {}; + state.revision++; + } + return; + } + + if (!state.valid || state.icon.width != icon->width || state.icon.height != icon->height || + state.icon.pixels != icon->pixels) + { + state.icon = std::move(*icon); + state.valid = true; + state.revision++; + } +} + +std::string midna_icon_source() { + const auto& state = midna_icon_state(); + if (!state.valid) { + return ""; + } + return fmt::format( + "{}://midna?slot={}", kMeterScheme, state.revision % kMeterTextureSourceSlots); +} + +uint64_t midna_icon_revision() noexcept { + const auto& state = midna_icon_state(); + return state.valid ? state.revision : 0; +} + +std::string item_icon_source_for_button(Control control) { + std::optional itemNo; + switch (control) { + case Control::X: + itemNo = selected_slot_item(0); + break; + case Control::Y: + itemNo = selected_slot_item(1); + break; + case Control::B: + itemNo = b_button_item(); + break; + default: + break; + } + if (!itemNo) { + return {}; + } + return item_source_for_item(*itemNo); +} + +std::string item_count_label_for_button(Control control) { + std::optional count; + switch (control) { + case Control::X: + count = selected_slot_count(0); + break; + case Control::Y: + count = selected_slot_count(1); + break; + default: + break; + } + if (!count) { + return {}; + } + return fmt::format("{}", *count); +} + +std::optional item_oil_fill_for_button(Control control) noexcept { + std::optional itemNo; + switch (control) { + case Control::X: + itemNo = selected_slot_item(0); + break; + case Control::Y: + itemNo = selected_slot_item(1); + break; + default: + break; + } + if (!itemNo || (*itemNo != dItemNo_KANTERA_e && *itemNo != dItemNo_KANTERA2_e)) { + return std::nullopt; + } + + const int maxOil = dComIfGs_getMaxOil(); + if (maxOil <= 0) { + return std::nullopt; + } + return std::clamp( + static_cast(dComIfGs_getOil()) / static_cast(maxOil), 0.0f, 1.0f); +} + +} // namespace dusk::ui + +#else + +namespace dusk::ui { + +void register_icon_texture_provider() noexcept {} +void unregister_icon_texture_provider() noexcept {} +void update_midna_icon_texture(J2DPane*) noexcept {} +std::string midna_icon_source() { + return {}; +} +uint64_t midna_icon_revision() noexcept { + return 0; +} +std::string item_icon_source_for_button(Control) { + return {}; +} +std::string item_count_label_for_button(Control) { + return {}; +} +std::optional item_oil_fill_for_button(Control) noexcept { + return std::nullopt; +} + +} // namespace dusk::ui + +#endif diff --git a/src/dusk/ui/icon_provider.hpp b/src/dusk/ui/icon_provider.hpp new file mode 100644 index 0000000000..a77c518992 --- /dev/null +++ b/src/dusk/ui/icon_provider.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include "controls.hpp" + +#include +#include +#include + +class J2DPane; + +namespace dusk::ui { + +void register_icon_texture_provider() noexcept; +void unregister_icon_texture_provider() noexcept; + +void update_midna_icon_texture(J2DPane* pane) noexcept; +std::string midna_icon_source(); +uint64_t midna_icon_revision() noexcept; +std::string item_icon_source_for_button(Control control); +std::string item_count_label_for_button(Control control); +std::optional item_oil_fill_for_button(Control control) noexcept; + +} // namespace dusk::ui diff --git a/src/dusk/ui/overlay.cpp b/src/dusk/ui/overlay.cpp index d6f87b9262..192b0ebf6a 100644 --- a/src/dusk/ui/overlay.cpp +++ b/src/dusk/ui/overlay.cpp @@ -5,6 +5,7 @@ #include "dusk/action_bindings.h" #include "controller_config.hpp" #include "dusk/livesplit.h" +#include "dusk/settings.h" #include "dusk/speedrun.h" #include "fmt/format.h" #include "magic_enum.hpp" @@ -194,7 +195,7 @@ static std::string FormatTime(OSTime ticks) { return fmt::format("{0:02}:{1:02}:{2:02}.{3:03}", t.hour, t.min, t.sec, t.msec); } -Overlay::Overlay() : Document(kDocumentSource) { +Overlay::Overlay() : Document(kDocumentSource, true) { mFpsCounter = mDocument->GetElementById("fps"); mSpeedrunTimer = mDocument->GetElementById("speedrun-timer"); mSpeedrunRta = mDocument->GetElementById("speedrun-rta"); @@ -317,6 +318,7 @@ void Overlay::update() { u32 count = 0; const bool showControllerWarning = PADGetIndexForPort(PAD_CHAN0) < 0 && PADGetKeyButtonBindings(PAD_CHAN0, &count) == nullptr && + !getSettings().game.enableTouchControls && dynamic_cast(top_document()) == nullptr && dynamic_cast(top_document()) == nullptr; if (showControllerWarning && mControllerWarning == nullptr) { diff --git a/src/dusk/ui/preset.cpp b/src/dusk/ui/preset.cpp index 5d1bbcdd28..1a75a27e6b 100644 --- a/src/dusk/ui/preset.cpp +++ b/src/dusk/ui/preset.cpp @@ -21,6 +21,7 @@ void applyPresetClassic() { s.game.shadowResolutionMultiplier.setValue(1); s.game.hideTvSettingsScreen.setValue(false); s.game.menuScalingMode.setValue(MenuScaling::GameCube); + s.game.enableMenuPointer.setValue(false); AuroraSetViewportPolicy(AURORA_VIEWPORT_FIT); } @@ -53,6 +54,7 @@ void applyPresetDusk() { s.game.autoSave.setValue(true); s.game.menuScalingMode.setValue(MenuScaling::Dusklight); s.game.enhancedMapMenus.setValue(true); + s.game.enableMenuPointer.setValue(true); } } // namespace diff --git a/src/dusk/ui/settings.cpp b/src/dusk/ui/settings.cpp index 49757aab20..194ddd78a7 100644 --- a/src/dusk/ui/settings.cpp +++ b/src/dusk/ui/settings.cpp @@ -22,6 +22,7 @@ #include "menu_bar.hpp" #include "pane.hpp" #include "prelaunch.hpp" +#include "touch_controls_editor.hpp" #include "ui.hpp" #include @@ -35,6 +36,17 @@ #include #include +#if defined(__APPLE__) +#include +#endif + +#if defined(TARGET_ANDROID) || defined(__ANDROID__) || \ + (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST) +#define TOUCH_CONTROLS_AVAILABLE true +#else +#define TOUCH_CONTROLS_AVAILABLE false +#endif + namespace dusk::ui { namespace { @@ -968,6 +980,31 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) { .onChange = [](bool value) { aurora_set_background_input(value); }, }); +#if TOUCH_CONTROLS_AVAILABLE + leftPane.add_section("Touch"); + addOption("Touch Controls", getSettings().game.enableTouchControls, + "Enables controls overlay for touch screens.

Press and drag on the left side " + "of the screen to move, and on the right side of the screen to control the camera."); + auto& customizeTouchLayout = leftPane.add_button(ControlledButton::Props{ + .text = "Customize Layout", + .isDisabled = [] { return !getSettings().game.enableTouchControls; }, + }); + leftPane.register_control(customizeTouchLayout.on_pressed( + [this] { push(std::make_unique()); }), + rightPane, [](Pane& pane) { + pane.clear(); + pane.add_text("Open the touch controls layout editor."); + }); + config_percent_select(leftPane, rightPane, getSettings().game.touchCameraXSensitivity, + "Touch Camera X Sensitivity", + "Adjusts touch camera horizontal sensitivity.

Applies to touch input only.", + 25, 400, 5, [] { return !getSettings().game.enableTouchControls; }); + config_percent_select(leftPane, rightPane, getSettings().game.touchCameraYSensitivity, + "Touch Camera Y Sensitivity", + "Adjusts touch camera vertical sensitivity.

Applies to touch input only.", 25, + 400, 5, [] { return !getSettings().game.enableTouchControls; }); +#endif + leftPane.add_section("Camera"); addOption("Free Camera", getSettings().game.freeCamera, "Enables free camera control, letting you control the camera fully with the C-Stick."); @@ -1035,6 +1072,8 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) { [] { return !getSettings().game.enableMouseAim || !getSettings().game.enableMouseCamera; }); leftPane.add_section("Gameplay"); + addOption("Mouse/Touch in Menus", getSettings().game.enableMenuPointer, + "Enables mouse and touch input for supported in-game menus."); addOption("Invert Air/Swim X Axis", getSettings().game.invertAirSwimX, "Invert horizontal movement while flying or swimming."); addOption("Invert Air/Swim Y Axis", getSettings().game.invertAirSwimY, diff --git a/src/dusk/ui/touch_controls.cpp b/src/dusk/ui/touch_controls.cpp new file mode 100644 index 0000000000..a85a90930f --- /dev/null +++ b/src/dusk/ui/touch_controls.cpp @@ -0,0 +1,1372 @@ +#include "touch_controls.hpp" +#include "touch_controls_common.hpp" + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "d/actor/d_a_alink.h" +#include "d/actor/d_a_player.h" +#include "d/d_com_inf_game.h" +#include "d/d_meter2_info.h" +#include "d/d_msg_object.h" +#include "dusk/action_bindings.h" +#include "dusk/menu_pointer.h" +#include "dusk/settings.h" +#include "dusk/touch_camera.h" +#include "f_op/f_op_overlap_mng.h" +#include "icon_provider.hpp" +#include "m_Do/m_Do_graphic.h" +#include "ui.hpp" + +namespace dusk::ui { +namespace { + +constexpr u32 kPort = PAD_CHAN0; +constexpr float kStickRadiusDp = 62.f; +constexpr float kStickKnobRadiusDp = 24.f; +constexpr float kAnalogZoneTopDp = 92.f; +constexpr float kAnalogZoneBottomDp = 30.f; +constexpr float kLeftZoneWidth = 0.46f; +constexpr float kRightZoneStart = 0.52f; +constexpr u8 kTriggerAnalog = 180; +constexpr auto kLDoubleTapWindow = std::chrono::milliseconds(300); +constexpr auto kHoldActionDuration = std::chrono::milliseconds(450); +constexpr float kFaceIconTargetRatio = 0.76f; +constexpr float kPressedScale = 0.94f; +constexpr size_t kEquipTargetCount = 4; + +std::array sEquipTargets{}; +std::array(Control::COUNT)> sControlOverrides{}; +TouchControls* sTouchControls = nullptr; + +struct ControlInfo { + const char* id = nullptr; + const char* iconId = nullptr; + const char* oilId = nullptr; + const char* oilFillId = nullptr; + const char* countId = nullptr; + u16 padButton = 0; + std::optional tapAction; + std::optional holdAction; +}; + +constexpr std::array(Control::COUNT)> kControls = {{ + { + .id = "button-a", + .padButton = PAD_BUTTON_A, + }, + { + .id = "button-b", + .iconId = "button-b-icon", + .padButton = PAD_BUTTON_B, + }, + { + .id = "button-x", + .iconId = "button-x-icon", + .oilId = "button-x-oil", + .oilFillId = "button-x-oil-fill", + .countId = "button-x-count", + .padButton = PAD_BUTTON_X, + }, + { + .id = "button-y", + .iconId = "button-y-icon", + .oilId = "button-y-oil", + .oilFillId = "button-y-oil-fill", + .countId = "button-y-count", + .padButton = PAD_BUTTON_Y, + }, + { + .id = "button-z", + .iconId = "z-midna-icon", + .padButton = PAD_TRIGGER_Z, + }, + { + .id = "trigger-l", + }, + { + .id = "trigger-r", + }, + { + .id = "first-person", + .tapAction = ActionBinds::FIRST_PERSON_CAMERA, + }, + { + .id = "items", + .padButton = PAD_BUTTON_UP, + }, + { + .id = "collections", + .padButton = PAD_BUTTON_START, + }, + { + .id = "map", + .tapAction = ActionBinds::OPEN_MAP_SCREEN, + .holdAction = ActionBinds::TOGGLE_MINIMAP, + }, + { + .id = "skip", + .padButton = PAD_BUTTON_START, + }, +}}; + +constexpr const ControlInfo* control_info(Control control) noexcept { + const auto index = static_cast(control); + return index < kControls.size() ? &kControls[index] : nullptr; +} + +bool control_override_active(Control control) noexcept { + const auto index = static_cast(control); + return index < sControlOverrides.size() && sControlOverrides[index] != ControlOverride::Default; +} + +Rml::String touch_controls_document_source() { + const auto fragment = touch_controls_rml_fragment(); + return Rml::String{R"RML( + + + + + + + + + +)RML"} + Rml::String{fragment.data(), fragment.size()} + + Rml::String{R"RML( + + +)RML"}; +} + +s8 stick_value(float value) noexcept { + return static_cast(std::clamp(std::lround(value * 127.f), -127l, 127l)); +} + +bool player_attention_locked() noexcept { + const auto* player = daPy_getPlayerActorClass(); + return player != nullptr && (player->checkAttentionLock() || player->checkEnemyAttentionLock()); +} + +bool item_wheel_active() noexcept { + return dMeter2Info_getWindowStatus() == 2; +} + +bool fishing_controls_active() noexcept { + const auto* player = daAlink_getAlinkActorClass(); + if (player == nullptr) { + return false; + } + return player->checkCanoeFishingWaitAnime(); +} + +enum class StickOutput { + MainStick, + CStick, +}; + +StickOutput stick_output_mode() noexcept { + if (fishing_controls_active()) { + return StickOutput::CStick; + } + return StickOutput::MainStick; +} + +bool controls_available(bool allowItemWheel) noexcept { + if (dComIfGp_getLinkPlayer() == nullptr) { + return false; + } + + const auto* fader = mDoGph_gInf_c::getFader(); + if (fader == nullptr || fader->getStatus() != JUTFader::Wait || mDoGph_gInf_c::isFade()) { + return false; + } + + const bool itemWheelActive = allowItemWheel && item_wheel_active(); + const auto heapLock = dComIfGp_isHeapLockFlag(); + if ((heapLock != 0 && heapLock != 5 && !(itemWheelActive && heapLock == 1)) || + (dComIfGp_isPauseFlag() && !itemWheelActive) || dComIfGp_getMesgStatus() != 0 || + dComIfGp_isEnableNextStage() || fopOvlpM_IsDoingReq()) + { + return false; + } + + return true; +} + +Rml::Vector2f clamped_stick_delta( + Rml::Vector2f start, Rml::Vector2f current, float stickRadius) noexcept { + Rml::Vector2f delta = current - start; + const float length = std::sqrt(delta.x * delta.x + delta.y * delta.y); + delta *= length > stickRadius ? stickRadius / length : 1.f; + return delta; +} + +struct FaceButtonState { + std::string iconSource; + uint64_t iconRevision = 0; + bool visible = false; + bool showIcon = false; +}; + +void release_rml_texture(const std::string& source) noexcept { + if (!source.empty()) { + Rml::ReleaseTexture(source); + } +} + +FaceButtonState override_button_state(Control control) { + if (control_override_active(control)) { + return { + .iconSource = "", + .visible = true, + .showIcon = false, + }; + } + + return {}; +} + +bool game_controls_suppressed() noexcept { + return !controls_available(true) || dComIfGp_event_runCheck() || + (dComIfGp_getMsgObjectClass() != nullptr && dMsgObject_isTalkNowCheck()); +} + +FaceButtonState xy_button_state(Control control) { + if (sControlOverrides[static_cast(control)] != ControlOverride::Default) { + return override_button_state(control); + } + if (game_controls_suppressed()) { + return {}; + } + + const bool itemMode = dComIfGp_getLinkPlayer() != nullptr && daPy_py_c::checkNowWolf() == 0; + const auto source = itemMode ? item_icon_source_for_button(control) : std::string(); + return { + .iconSource = source, + .visible = true, + .showIcon = itemMode && !source.empty(), + }; +} + +FaceButtonState z_button_state() { + if (sControlOverrides[static_cast(Control::Z)] != ControlOverride::Default) { + return override_button_state(Control::Z); + } + if (game_controls_suppressed()) { + return {}; + } + + const auto source = midna_icon_source(); + return { + .iconSource = source, + .iconRevision = midna_icon_revision(), + .visible = true, + .showIcon = !source.empty(), + }; +} + +FaceButtonState b_button_state() { + if (game_controls_suppressed()) { + return { + .iconSource = "", + .visible = true, + .showIcon = false, + }; + } + + const auto source = item_icon_source_for_button(Control::B); + return { + .iconSource = source, + .visible = true, + .showIcon = dMeter2Info_isUseButton(METER2_USEBUTTON_B) && !source.empty(), + }; +} + +void clear_equip_targets() noexcept { + for (auto& target : sEquipTargets) { + target.valid = false; + } +} + +void sync_equip_target(int slot, ControlRect rectDp, float widthRatio, float heightRatio, + bool square = false) noexcept { + if (slot < 0 || static_cast(slot) >= sEquipTargets.size()) { + return; + } + + auto& target = sEquipTargets[slot]; + target.valid = false; + + auto* context = aurora::rmlui::get_context(); + if (context == nullptr) { + return; + } + + const auto dimensions = context->GetDimensions(); + if (dimensions.x <= 0 || dimensions.y <= 0) { + return; + } + + const float scale = std::max(context->GetDensityIndependentPixelRatio(), 1.f); + const Rml::Vector2f buttonPosition{rectDp.l * scale, rectDp.t * scale}; + const Rml::Vector2f buttonSize{rectDp.w * scale, rectDp.h * scale}; + if (buttonSize.x <= 0.f || buttonSize.y <= 0.f) { + return; + } + + Rml::Vector2f targetSize{buttonSize.x * widthRatio, buttonSize.y * heightRatio}; + if (square) { + const float side = std::min(buttonSize.x, buttonSize.y) * widthRatio; + targetSize = Rml::Vector2f{side, side}; + } + const auto targetPosition = buttonPosition + (buttonSize - targetSize) * 0.5f; + const float scaleX = mDoGph_gInf_c::getWidthF() / static_cast(dimensions.x); + const float scaleY = mDoGph_gInf_c::getHeightF() / static_cast(dimensions.y); + + target.left = mDoGph_gInf_c::getMinXF() + targetPosition.x * scaleX; + target.top = mDoGph_gInf_c::getMinYF() + targetPosition.y * scaleY; + target.width = targetSize.x * scaleX; + target.height = targetSize.y * scaleY; + target.valid = true; +} + +} // namespace + +bool get_equip_target(int slot, EquipTarget& target) noexcept { + if (slot < 0 || static_cast(slot) >= sEquipTargets.size()) { + return false; + } + + const auto& stored = sEquipTargets[slot]; + if (!stored.valid) { + return false; + } + + target = stored; + return true; +} + +void set_control_override(Control control, ControlOverride override) noexcept { + const auto index = static_cast(control); + if (index >= sControlOverrides.size()) { + return; + } + sControlOverrides[index] = override; +} + +void sync_virtual_input() noexcept { + if (sTouchControls != nullptr) { + sTouchControls->sync_virtual_input(); + } +} + +TouchControls::TouchControls() + : Document(touch_controls_document_source(), true), + mRoot(mDocument != nullptr ? mDocument->GetElementById("root") : nullptr), + mControlStick(mDocument != nullptr ? mDocument->GetElementById("control-stick") : nullptr), + mControlKnob(mDocument != nullptr ? mDocument->GetElementById("control-knob") : nullptr), + mActionBar(mDocument != nullptr ? mDocument->GetElementById("action-bar") : nullptr) { + sTouchControls = this; + if (mDocument != nullptr) { + for (std::size_t i = 0; i < kControls.size(); ++i) { + const auto& info = kControls[i]; + auto& elements = mControlElements[i]; + elements.root = info.id != nullptr ? mDocument->GetElementById(info.id) : nullptr; + elements.icon = + info.iconId != nullptr ? mDocument->GetElementById(info.iconId) : nullptr; + elements.oil = info.oilId != nullptr ? mDocument->GetElementById(info.oilId) : nullptr; + elements.oilFill = + info.oilFillId != nullptr ? mDocument->GetElementById(info.oilFillId) : nullptr; + elements.count = + info.countId != nullptr ? mDocument->GetElementById(info.countId) : nullptr; + } + } + + listen(mRoot, Rml::EventId::Transitionend, [this](Rml::Event& event) { + if (event.GetTargetElement() == mRoot && !mRoot->HasAttribute("open") && + Document::visible()) + { + Document::hide(mPendingClose); + } + }); + + auto listenControl = [this](Control control) { + const auto index = static_cast(control); + auto* element = index < mControlElements.size() ? mControlElements[index].root : nullptr; + if (element == nullptr) { + return; + } + listen(element, aurora::rmlui::TouchStartEvent, [this, control](Rml::Event& event) { + if (!visible() || mWasSuppressed || !getSettings().game.enableTouchControls) { + return; + } + if (start_control_touch(touch_event_id(event), control)) { + event.StopPropagation(); + } + }); + listen(element, aurora::rmlui::TouchEndEvent, [this](Rml::Event& event) { + if (release_control_touch(touch_event_id(event), false)) { + event.StopPropagation(); + } + }); + listen(element, aurora::rmlui::TouchCancelEvent, [this](Rml::Event& event) { + if (release_control_touch(touch_event_id(event), true)) { + event.StopPropagation(); + } + }); + }; + for (std::size_t i = 0; i < kControls.size(); ++i) { + listenControl(static_cast(i)); + } + + listen(mRoot, aurora::rmlui::TouchStartEvent, + [this](Rml::Event& event) { handle_touch_down(event); }); + listen(mRoot, aurora::rmlui::TouchMoveEvent, + [this](Rml::Event& event) { handle_touch_motion(event); }); + listen( + mRoot, aurora::rmlui::TouchEndEvent, [this](Rml::Event& event) { handle_touch_up(event); }); + listen(mRoot, aurora::rmlui::TouchCancelEvent, + [this](Rml::Event& event) { handle_touch_cancel(event); }); + listen(mRoot, Rml::EventId::Mousemove, [this](Rml::Event& event) { handle_mouse_move(event); }); + listen(mRoot, Rml::EventId::Mousedown, [this](Rml::Event& event) { handle_mouse_down(event); }); + listen(mRoot, Rml::EventId::Mouseup, [this](Rml::Event& event) { handle_mouse_up(event); }); +} + +TouchControls::~TouchControls() { + clear_virtual_input(); + clearAllVirtualActionBinds(); + if (sTouchControls == this) { + sTouchControls = nullptr; + } +} + +void TouchControls::show() { + Document::show(); + if (mRoot != nullptr) { + mRoot->SetAttribute("open", ""); + } +} + +void TouchControls::hide(bool close) { + clear_virtual_input(); + if (mRoot != nullptr) { + mRoot->RemoveAttribute("open"); + mPendingClose = close; + } else { + Document::hide(close); + } +} + +void TouchControls::set_control_pressed(Control control, bool pressed) { + set_control_visual(control, pressed); + sync_control_button_mask(); + + switch (control) { + case Control::L: + if (control_override_active(control)) { + mLPressed = pressed; + mLLatched = false; + mManualLLatched = false; + mLReleasePending = false; + mLPressStartTime = {}; + mLastLTapTime = {}; + break; + } + if (pressed && (mLLatched || mManualLLatched)) { + mLLatched = false; + mManualLLatched = false; + mLPressed = false; + mLReleasePending = true; + mLPressStartTime = {}; + mLastLTapTime = {}; + set_control_visual(control, false); + } else if (pressed) { + const auto now = clock::now(); + if (!player_attention_locked() && mLastLTapTime != clock::time_point{} && + now - mLastLTapTime <= kLDoubleTapWindow) + { + mManualLLatched = true; + mLPressed = false; + mLReleasePending = true; + mLPressStartTime = {}; + mLastLTapTime = {}; + } else if (!mLReleasePending) { + mLPressed = true; + mLPressStartTime = now; + } + } else if (!mLReleasePending) { + mLPressed = false; + } + if (!pressed) { + const auto now = clock::now(); + if (!mLReleasePending) { + const bool wasQuickTap = mLPressStartTime != clock::time_point{} && + now - mLPressStartTime <= kLDoubleTapWindow; + mLastLTapTime = wasQuickTap ? now : clock::time_point{}; + } + mLPressStartTime = {}; + mLReleasePending = false; + } + if (!pressed && !player_attention_locked()) { + mLLatched = false; + } + break; + case Control::R: + mRTriggerHeld = pressed; + break; + default: + break; + } +} + +bool TouchControls::fire_control_action(Control control, ControlAction action) noexcept { + const auto* info = control_info(control); + if (info == nullptr) { + return false; + } + + const auto actionBind = action == ControlAction::Tap ? info->tapAction : info->holdAction; + if (!actionBind) { + return false; + } + + const auto actionIndex = static_cast(*actionBind); + if (actionIndex >= mQueuedActions.size()) { + return false; + } + + mQueuedActions.set(actionIndex); + return true; +} + +bool TouchControls::start_control_touch(SDL_FingerID id, Control control) noexcept { + const auto index = static_cast(control); + if (index >= mControlTouches.size()) { + return false; + } + + auto& touch = mControlTouches[index]; + if (touch.active) { + return false; + } + + touch = { + .id = id, + .startTime = clock::now(), + .active = true, + .longPressFired = false, + }; + set_control_pressed(control, true); + return true; +} + +void TouchControls::release_control(Control control) noexcept { + const auto index = static_cast(control); + if (index < mControlTouches.size()) { + mControlTouches[index] = {}; + } + + sync_control_button_mask(); + switch (control) { + case Control::L: + mLPressed = false; + mLLatched = false; + mManualLLatched = false; + mLReleasePending = false; + mLPressStartTime = {}; + mLastLTapTime = {}; + break; + case Control::R: + mRTriggerHeld = false; + break; + default: + break; + } + set_control_visual(control, false); +} + +void TouchControls::sync_control_button_mask() noexcept { + u16 buttonMask = 0; + for (std::size_t i = 0; i < mControlTouches.size() && i < kControls.size(); ++i) { + if (mControlTouches[i].active) { + buttonMask |= kControls[i].padButton; + } + } + mButtonMask = buttonMask; +} + +void TouchControls::set_control_visual(Control control, bool pressed) noexcept { + const auto index = static_cast(control); + auto* element = index < mControlElements.size() ? mControlElements[index].root : nullptr; + if (index >= mControlVisualPressed.size()) { + return; + } + mControlVisualPressed[index] = pressed; + if (element != nullptr) { + element->SetClass("pressed", pressed); + } + apply_control_transform(control); +} + +void TouchControls::apply_control_transform(Control control) noexcept { + const auto index = static_cast(control); + if (index >= mControlElements.size()) { + return; + } + auto& elements = mControlElements[index]; + auto& layout = elements.layout; + const float pressedScale = + index < mControlVisualPressed.size() && mControlVisualPressed[index] ? kPressedScale : 1.f; + apply_control_transform_if_changed( + elements.root, layout.appliedTransform, layout.layoutScale * pressedScale); +} + +void TouchControls::sync_l_lock_state() noexcept { + if (player_attention_locked()) { + if (mLPressed) { + mLLatched = true; + } + } else { + mLLatched = false; + } +} + +void TouchControls::clear_motion_touch_input() noexcept { + mMoveTouch = {}; + mCameraTouch = {}; + touch_camera::clear(); + if (mControlStick != nullptr) { + mControlStick->SetClass("active", false); + } +} + +void TouchControls::clear_control_input() noexcept { + for (std::size_t i = 0; i < mControlTouches.size(); ++i) { + release_control(static_cast(i)); + } + mQueuedActions.reset(); + mButtonMask = 0; + mWantsVirtualPad = false; + PADClearVirtualStatus(kPort); + for (const auto& control : kControls) { + if (control.tapAction) { + setVirtualActionBind(*control.tapAction, kPort, false, false); + } + if (control.holdAction) { + setVirtualActionBind(*control.holdAction, kPort, false, false); + } + } +} + +void TouchControls::clear_virtual_input() noexcept { + clear_motion_touch_input(); + mMenuPointerTouch = 0; + mMenuPointerMouseSuppressions = 0; + mMenuPointerTouchActive = false; + clear_control_input(); +} + +void TouchControls::sync_touch_state() noexcept { + const bool controlsEnabled = getSettings().game.enableTouchControls; + const bool pointerMenuActive = menu_pointer::active(); + if (mWasSuppressed || (!controlsEnabled && !pointerMenuActive)) { + clear_virtual_input(); + return; + } + + if (pointerMenuActive) { + clear_motion_touch_input(); + if (!controlsEnabled) { + clear_control_input(); + return; + } + } + + sync_l_lock_state(); + const bool aimActive = dCamera_c::isAimActive(); + if (aimActive && mMoveTouch.active) { + if (!mCameraTouch.active) { + mCameraTouch = mMoveTouch; + mCameraTouch.start = mMoveTouch.current; + } + mMoveTouch = {}; + } + + const float stickRadius = kStickRadiusDp * touch_dp_scale(); + if (mControlStick != nullptr) { + if (mMoveTouch.active && stickRadius > 0.f) { + const auto delta = + clamped_stick_delta(mMoveTouch.start, mMoveTouch.current, stickRadius); + const float knobRadius = kStickKnobRadiusDp * touch_dp_scale(); + mControlStick->SetClass("active", true); + mControlStick->SetProperty(Rml::PropertyId::Left, + Rml::Property(mMoveTouch.start.x - stickRadius, Rml::Unit::PX)); + mControlStick->SetProperty(Rml::PropertyId::Top, + Rml::Property(mMoveTouch.start.y - stickRadius, Rml::Unit::PX)); + mControlKnob->SetProperty(Rml::PropertyId::Left, + Rml::Property(stickRadius + delta.x - knobRadius, Rml::Unit::PX)); + mControlKnob->SetProperty(Rml::PropertyId::Top, + Rml::Property(stickRadius + delta.y - knobRadius, Rml::Unit::PX)); + } else { + mControlStick->SetClass("active", false); + } + } + + sync_visual_state(); +} + +void TouchControls::sync_virtual_input() noexcept { + sync_touch_state(); + if (mWasSuppressed || !getSettings().game.enableTouchControls) { + return; + } + + PADStatus status{}; + status.err = PAD_ERR_NONE; + status.button = mButtonMask; + + if (mLPressed || mLLatched || mManualLLatched) { + status.button |= PAD_TRIGGER_L; + status.triggerLeft = kTriggerAnalog; + } + if (mRTriggerHeld) { + status.button |= PAD_TRIGGER_R; + status.triggerRight = kTriggerAnalog; + } + + const float stickRadius = kStickRadiusDp * touch_dp_scale(); + if (mMoveTouch.active && stickRadius > 0.f) { + const auto delta = clamped_stick_delta(mMoveTouch.start, mMoveTouch.current, stickRadius); + const float stickX = stick_value(delta.x / stickRadius); + const float stickY = stick_value(-delta.y / stickRadius); + switch (stick_output_mode()) { + case StickOutput::CStick: + status.substickX = stickX; + status.substickY = stickY; + break; + case StickOutput::MainStick: + default: + status.stickX = stickX; + status.stickY = stickY; + break; + } + } + + mWantsVirtualPad = status.button != 0 || status.stickX != 0 || status.stickY != 0 || + status.substickX != 0 || status.substickY != 0 || status.triggerLeft != 0 || + status.triggerRight != 0; + if (mWantsVirtualPad) { + PADSetVirtualStatus(kPort, &status); + } else { + PADClearVirtualStatus(kPort); + } + + for (const auto& control : kControls) { + if (control.tapAction) { + const bool queued = mQueuedActions.test(static_cast(*control.tapAction)); + setVirtualActionBind( + *control.tapAction, kPort, queued, queued && visible() && !mWasSuppressed); + } + if (control.holdAction) { + const bool queued = mQueuedActions.test(static_cast(*control.holdAction)); + setVirtualActionBind( + *control.holdAction, kPort, queued, queued && visible() && !mWasSuppressed); + } + } + mQueuedActions.reset(); +} + +void TouchControls::sync_visibility() noexcept { + mWasSuppressed = any_document_visible(); + if ((getSettings().game.enableTouchControls || + (menu_pointer::enabled() && menu_pointer::active())) && + !mWasSuppressed) + { + show(); + } else if (visible()) { + hide(false); + } else { + clear_virtual_input(); + } +} + +void TouchControls::sync_safe_area() noexcept { + if (mDocument == nullptr) { + return; + } + const auto insets = safe_area_insets(mDocument->GetContext()); + if (insets == mSafeInsets) { + return; + } + mSafeInsets = insets; +} + +void TouchControls::sync_control_layouts() noexcept { + auto* context = mDocument != nullptr ? mDocument->GetContext() : aurora::rmlui::get_context(); + const auto docSize = touch_document_size_dp(context); + if (docSize.w <= 0.f || docSize.h <= 0.f || context == nullptr) { + return; + } + + const auto& customControls = getSettings().game.touchControlsLayout.getValue().controls; + for (const auto& info : touch_layout_controls()) { + auto props = info.props; + if (const auto iter = customControls.find(info.layoutId); iter != customControls.end()) { + props = iter->second; + } + + const auto layout = resolve_control_layout(props, docSize); + if (info.hasControl) { + const auto index = static_cast(info.control); + if (index >= mControlElements.size()) { + continue; + } + + auto& elements = mControlElements[index]; + auto& state = elements.layout; + state.visualRect = layout.visual; + state.layoutScale = layout.scale; + apply_control_box_if_changed(elements.root, state.appliedBox, layout.box); + apply_control_dock_classes( + elements.root, touch_control_dock_anchor(layout.visual, docSize)); + apply_control_transform(info.control); + continue; + } + + mActionBarLayout.visualRect = layout.visual; + mActionBarLayout.layoutScale = layout.scale; + apply_control_box_if_changed(mActionBar, mActionBarLayout.appliedBox, layout.box); + apply_control_dock_classes(mActionBar, touch_control_dock_anchor(layout.visual, docSize)); + apply_control_transform_if_changed( + mActionBar, mActionBarLayout.appliedTransform, mActionBarLayout.layoutScale); + } +} + +void TouchControls::sync_visual_state() noexcept { + if (mWasSuppressed || !getSettings().game.enableTouchControls) { + clear_motion_touch_input(); + for (const auto control : {Control::L, Control::R}) { + const auto& elements = mControlElements[static_cast(control)]; + if (elements.root != nullptr) { + elements.root->SetPseudoClass("hidden", true); + } + release_control(control); + } + return; + } + + const bool hideGameplayControls = game_controls_suppressed(); + const auto& lTrigger = mControlElements[static_cast(Control::L)]; + const auto& rTrigger = mControlElements[static_cast(Control::R)]; + const bool lHidden = hideGameplayControls && !control_override_active(Control::L); + const bool rHidden = hideGameplayControls && !control_override_active(Control::R); + + if (lTrigger.root != nullptr) { + lTrigger.root->SetPseudoClass("hidden", lHidden); + lTrigger.root->SetClass("active", + !lHidden && (mLPressed || mLLatched || mManualLLatched || + (!control_override_active(Control::L) && player_attention_locked()))); + } + if (rTrigger.root != nullptr) { + rTrigger.root->SetPseudoClass("hidden", rHidden); + } + + if (lHidden) { + release_control(Control::L); + } + if (rHidden) { + release_control(Control::R); + } +} + +void TouchControls::sync_action_bar_state() noexcept { + if (mWasSuppressed || !getSettings().game.enableTouchControls) { + if (mActionBar != nullptr) { + mActionBar->SetPseudoClass("hidden", true); + } + const auto& skip = mControlElements[static_cast(Control::SKIP)]; + if (skip.root != nullptr) { + skip.root->SetPseudoClass("hidden", true); + } + for (const auto control : {Control::FIRST_PERSON, Control::ITEMS, Control::COLLECTIONS, + Control::MAP, Control::SKIP}) + { + release_control(control); + } + return; + } + + auto* event = dComIfGp_getEvent(); + const bool skipVisible = event != nullptr && event->mEventStatus == 1 && + event->mSkipFunc != nullptr && !event->chkFlag2(2); + const bool hidden = + !skipVisible && + (!controls_available(false) || dComIfGp_event_runCheck() || + (dComIfGp_getMsgObjectClass() != nullptr && dMsgObject_isTalkNowCheck())); + const auto& skip = mControlElements[static_cast(Control::SKIP)]; + if (mActionBar != nullptr) { + mActionBar->SetPseudoClass("hidden", hidden || skipVisible); + } + if (skip.root != nullptr) { + skip.root->SetPseudoClass("hidden", !skipVisible); + } + if (skipVisible) { + for (const auto control : + {Control::FIRST_PERSON, Control::ITEMS, Control::COLLECTIONS, Control::MAP}) + { + release_control(control); + } + return; + } + + release_control(Control::SKIP); + if (!hidden) { + return; + } + + for (const auto control : + {Control::FIRST_PERSON, Control::ITEMS, Control::COLLECTIONS, Control::MAP}) + { + release_control(control); + } +} + +void TouchControls::sync_control_displays() noexcept { + if (mWasSuppressed || !getSettings().game.enableTouchControls) { + for (const auto control : {Control::A, Control::B, Control::X, Control::Y, Control::Z}) { + const auto& elements = mControlElements[static_cast(control)]; + if (elements.root != nullptr) { + elements.root->SetPseudoClass("hidden", true); + } + release_control(control); + } + clear_equip_targets(); + return; + } + + const auto bState = b_button_state(); + const auto xState = xy_button_state(Control::X); + const auto yState = xy_button_state(Control::Y); + const auto zState = z_button_state(); + + const auto& a = mControlElements[static_cast(Control::A)]; + const auto& b = mControlElements[static_cast(Control::B)]; + const auto& x = mControlElements[static_cast(Control::X)]; + const auto& y = mControlElements[static_cast(Control::Y)]; + const auto& z = mControlElements[static_cast(Control::Z)]; + + if (a.root != nullptr) { + a.root->SetPseudoClass("hidden", false); + } + if (z.root != nullptr) { + z.root->SetPseudoClass("hidden", !zState.visible); + z.root->SetClass("has-icon", zState.showIcon); + } + if (!zState.visible) { + release_control(Control::Z); + } + if (z.icon != nullptr) { + z.icon->SetClass("visible", zState.showIcon); + } + + const bool zSourceChanged = zState.iconSource != mZTriggerIconSource; + const bool zRevisionChanged = zState.iconRevision != mZTriggerIconRevision; + if (zSourceChanged || zRevisionChanged) { + const std::string previousSource = mZTriggerIconSource; + mZTriggerIconSource = zState.iconSource; + mZTriggerIconRevision = zState.iconRevision; + if (z.icon == nullptr) { + release_rml_texture(previousSource); + } else if (zState.iconSource.empty()) { + z.icon->RemoveAttribute("src"); + } else { + release_rml_texture(zState.iconSource); + if (!zSourceChanged) { + z.icon->RemoveAttribute("src"); + } + z.icon->SetAttribute("src", zState.iconSource); + } + if (zSourceChanged) { + release_rml_texture(previousSource); + } + } + + const auto syncIcon = [this](Rml::Element* button, Rml::Element* icon, std::string& lastSource, + Control control, const FaceButtonState& state) { + if (button != nullptr) { + button->SetPseudoClass("hidden", !state.visible); + button->SetClass("has-item", state.showIcon); + } + if (!state.visible) { + release_control(control); + } + + if (icon != nullptr) { + icon->SetClass("visible", state.showIcon); + } + + if (state.iconSource == lastSource) { + return; + } + + const std::string previousSource = lastSource; + lastSource = state.iconSource; + if (icon == nullptr) { + release_rml_texture(previousSource); + return; + } + if (state.iconSource.empty()) { + icon->RemoveAttribute("src"); + } else { + icon->SetAttribute("src", state.iconSource); + } + release_rml_texture(previousSource); + }; + + syncIcon(b.root, b.icon, mButtonBIconSource, Control::B, bState); + syncIcon(x.root, x.icon, mButtonXIconSource, Control::X, xState); + syncIcon(y.root, y.icon, mButtonYIconSource, Control::Y, yState); + + const auto syncCount = [](Rml::Element* countElement, std::string& lastLabel, Control control, + const FaceButtonState& state) { + const std::string label = state.showIcon ? item_count_label_for_button(control) : ""; + if (label == lastLabel) { + return; + } + + lastLabel = label; + if (countElement == nullptr) { + return; + } + countElement->SetClass("visible", !label.empty()); + countElement->SetInnerRML(label); + }; + + syncCount(x.count, mButtonXCountLabel, Control::X, xState); + syncCount(y.count, mButtonYCountLabel, Control::Y, yState); + + const auto syncOil = [](Rml::Element* meter, Rml::Element* fill, Control control, + const FaceButtonState& state) { + const auto oilFill = state.showIcon ? item_oil_fill_for_button(control) : std::nullopt; + if (meter != nullptr) { + meter->SetClass("visible", oilFill.has_value()); + } + if (fill != nullptr) { + const float percent = oilFill ? *oilFill * 100.f : 0.f; + fill->SetProperty(Rml::PropertyId::Width, Rml::Property(percent, Rml::Unit::PERCENT)); + } + }; + + syncOil(b.oil, b.oilFill, Control::B, bState); + syncOil(x.oil, x.oilFill, Control::X, xState); + syncOil(y.oil, y.oilFill, Control::Y, yState); + + clear_equip_targets(); + if (!visible() || mWasSuppressed || !getSettings().game.enableTouchControls) { + return; + } + + if (xState.showIcon && x.layout.visualRect) { + sync_equip_target(0, *x.layout.visualRect, kFaceIconTargetRatio, kFaceIconTargetRatio); + } + if (yState.showIcon && y.layout.visualRect) { + sync_equip_target(1, *y.layout.visualRect, kFaceIconTargetRatio, kFaceIconTargetRatio); + } + if (zState.showIcon && z.layout.visualRect) { + sync_equip_target(2, *z.layout.visualRect, 1.f, 1.f, true); + } + if (bState.showIcon && b.layout.visualRect) { + sync_equip_target(3, *b.layout.visualRect, kFaceIconTargetRatio, kFaceIconTargetRatio); + } +} + +void TouchControls::update() { + sync_visibility(); + sync_control_long_presses(); + sync_safe_area(); + sync_control_layouts(); + sync_visual_state(); + sync_action_bar_state(); + sync_control_displays(); + sync_touch_state(); +} + +bool TouchControls::release_control_touch(SDL_FingerID id, bool cancelled) noexcept { + for (std::size_t i = 0; i < mControlTouches.size(); ++i) { + auto& touch = mControlTouches[i]; + if (!touch.active || touch.id != id) { + continue; + } + + const auto control = static_cast(i); + const bool shouldFireTapAction = !cancelled && !touch.longPressFired; + touch = {}; + set_control_pressed(control, false); + if (shouldFireTapAction) { + fire_control_action(control, ControlAction::Tap); + } + return true; + } + + return false; +} + +void TouchControls::sync_control_long_presses() noexcept { + const auto now = clock::now(); + for (std::size_t i = 0; i < mControlTouches.size(); ++i) { + auto& touch = mControlTouches[i]; + if (!touch.active || touch.longPressFired || now - touch.startTime < kHoldActionDuration) { + continue; + } + + if (!fire_control_action(static_cast(i), ControlAction::Hold)) { + continue; + } + + touch.longPressFired = true; + } +} + +bool TouchControls::handle_menu_event(Rml::Event& event, menu_pointer::Phase phase) noexcept { + if (!menu_pointer::active() || event.GetTargetElement() != mRoot) { + return false; + } + if (!menu_pointer::enabled()) { + mMenuPointerTouch = 0; + mMenuPointerMouseSuppressions = 0; + mMenuPointerTouchActive = false; + event.StopPropagation(); + return true; + } + + const auto id = touch_event_id(event); + switch (phase) { + case menu_pointer::Phase::Press: + if (mMenuPointerTouchActive) { + event.StopPropagation(); + return true; + } + mMenuPointerTouch = id; + mMenuPointerTouchActive = true; + break; + case menu_pointer::Phase::Move: + if (!mMenuPointerTouchActive || mMenuPointerTouch != id) { + event.StopPropagation(); + return true; + } + break; + case menu_pointer::Phase::Release: + case menu_pointer::Phase::Cancel: + if (!mMenuPointerTouchActive || mMenuPointerTouch != id) { + event.StopPropagation(); + return true; + } + mMenuPointerTouchActive = false; + break; + } + + const auto position = touch_event_position(event); + menu_pointer::handle_fallthrough_pointer(position.x, position.y, phase, true); + switch (phase) { + case menu_pointer::Phase::Press: + case menu_pointer::Phase::Release: + mMenuPointerMouseSuppressions = 2; + break; + case menu_pointer::Phase::Move: + case menu_pointer::Phase::Cancel: + mMenuPointerMouseSuppressions = 1; + break; + } + event.StopPropagation(); + return true; +} + +void TouchControls::handle_touch_down(Rml::Event& event) noexcept { + if (!visible() || mWasSuppressed) { + return; + } + if (handle_menu_event(event, menu_pointer::Phase::Press)) { + return; + } + if (!getSettings().game.enableTouchControls) { + return; + } + + const auto position = touch_event_position(event); + auto* context = aurora::rmlui::get_context(); + if (context == nullptr) { + return; + } + + const auto id = touch_event_id(event); + if (dCamera_c::isAimActive()) { + if (!mCameraTouch.active) { + mCameraTouch = { + .id = id, + .start = position, + .current = position, + .active = true, + }; + } + return; + } + + const auto dimensions = context->GetDimensions(); + const float top = mSafeInsets.top + kAnalogZoneTopDp * touch_dp_scale(); + const float bottom = static_cast(dimensions.y) - mSafeInsets.bottom - + kAnalogZoneBottomDp * touch_dp_scale(); + if (position.y < top || position.y > bottom) { + return; + } + + const auto width = static_cast(dimensions.x); + if (!mMoveTouch.active && position.x < width * kLeftZoneWidth) { + mMoveTouch = { + .id = id, + .start = position, + .current = position, + .active = true, + }; + } else if (!mCameraTouch.active && position.x > width * kRightZoneStart) { + mCameraTouch = { + .id = id, + .start = position, + .current = position, + .active = true, + }; + } +} + +void TouchControls::handle_touch_motion(Rml::Event& event) noexcept { + if (!visible() || mWasSuppressed) { + return; + } + if (handle_menu_event(event, menu_pointer::Phase::Move)) { + return; + } + if (!getSettings().game.enableTouchControls) { + return; + } + + const auto id = touch_event_id(event); + const auto position = touch_event_position(event); + if (mMoveTouch.active && mMoveTouch.id == id) { + mMoveTouch.current = position; + } + if (mCameraTouch.active && mCameraTouch.id == id) { + const auto delta = position - mCameraTouch.current; + mCameraTouch.current = position; + const float scale = touch_dp_scale(); + touch_camera::add_delta(delta.x / scale, delta.y / scale); + } +} + +void TouchControls::handle_touch_up(Rml::Event& event) noexcept { + if (!visible() || mWasSuppressed) { + return; + } + const auto id = touch_event_id(event); + if (release_control_touch(id, false)) { + return; + } + if (handle_menu_event(event, menu_pointer::Phase::Release)) { + return; + } + if (mMoveTouch.active && mMoveTouch.id == id) { + mMoveTouch = {}; + } + if (mCameraTouch.active && mCameraTouch.id == id) { + mCameraTouch = {}; + } +} + +void TouchControls::handle_touch_cancel(Rml::Event& event) noexcept { + if (!visible() || mWasSuppressed) { + return; + } + const auto id = touch_event_id(event); + if (release_control_touch(id, true)) { + return; + } + if (handle_menu_event(event, menu_pointer::Phase::Cancel)) { + return; + } + if (mMoveTouch.active && mMoveTouch.id == id) { + mMoveTouch = {}; + } + if (mCameraTouch.active && mCameraTouch.id == id) { + mCameraTouch = {}; + } +} + +void TouchControls::handle_mouse_move(Rml::Event& event) noexcept { + if (mMenuPointerMouseSuppressions > 0) { + --mMenuPointerMouseSuppressions; + return; + } + if (!visible() || mWasSuppressed || !menu_pointer::active() || + !menu_pointer::enabled() || event.GetTargetElement() != mRoot) + { + return; + } + + const auto position = mouse_event_position(event); + menu_pointer::handle_fallthrough_pointer( + position.x, position.y, menu_pointer::Phase::Move, false); + event.StopPropagation(); +} + +void TouchControls::handle_mouse_down(Rml::Event& event) noexcept { + if (mMenuPointerMouseSuppressions > 0) { + --mMenuPointerMouseSuppressions; + return; + } + if (!visible() || mWasSuppressed || !menu_pointer::active() || + !menu_pointer::enabled() || event.GetTargetElement() != mRoot) + { + return; + } + + const auto position = mouse_event_position(event); + const s32 button = event.GetParameter("button", -1); + if (!menu_pointer::handle_fallthrough_pointer( + position.x, position.y, menu_pointer::Phase::Press, false, button)) + { + return; + } + event.StopPropagation(); +} + +void TouchControls::handle_mouse_up(Rml::Event& event) noexcept { + if (mMenuPointerMouseSuppressions > 0) { + --mMenuPointerMouseSuppressions; + return; + } + if (!visible() || mWasSuppressed || + !menu_pointer::enabled() || + (!menu_pointer::active() && !menu_pointer::mouse_capture_active()) || + event.GetTargetElement() != mRoot) + { + return; + } + + const auto position = mouse_event_position(event); + const s32 button = event.GetParameter("button", -1); + if (!menu_pointer::handle_fallthrough_pointer( + position.x, position.y, menu_pointer::Phase::Release, false, button)) + { + return; + } + event.StopPropagation(); +} + +} // namespace dusk::ui diff --git a/src/dusk/ui/touch_controls.hpp b/src/dusk/ui/touch_controls.hpp new file mode 100644 index 0000000000..752afd58b2 --- /dev/null +++ b/src/dusk/ui/touch_controls.hpp @@ -0,0 +1,133 @@ +#pragma once + +#include "controls.hpp" +#include "document.hpp" + +#include "dusk/action_bindings.h" +#include "dusk/menu_pointer.h" +#include "dusk/ui/controls.hpp" + +#include +#include +#include +#include +#include +#include + +namespace dusk::ui { + +enum class ControlOverride { + Default, + Action, +}; + +bool get_equip_target(int slot, EquipTarget& target) noexcept; +void set_control_override(Control control, ControlOverride override) noexcept; +void sync_virtual_input() noexcept; + +class TouchControls final : public Document { +public: + TouchControls(); + ~TouchControls() override; + + void show() override; + void hide(bool close) override; + void update() override; + void sync_virtual_input() noexcept; + +private: + struct StickTouch { + SDL_FingerID id = 0; + Rml::Vector2f start; + Rml::Vector2f current; + bool active = false; + }; + struct ControlTouch { + SDL_FingerID id = 0; + clock::time_point startTime{}; + bool active = false; + bool longPressFired = false; + }; + struct LayoutState { + std::optional visualRect; + std::optional appliedBox; + float layoutScale = 1.0f; + std::optional appliedTransform; + }; + struct ControlElements { + Rml::Element* root = nullptr; + Rml::Element* icon = nullptr; + Rml::Element* oil = nullptr; + Rml::Element* oilFill = nullptr; + Rml::Element* count = nullptr; + LayoutState layout; + }; + enum class ControlAction { + Tap, + Hold, + }; + + void set_control_pressed(Control control, bool pressed); + void release_control(Control control) noexcept; + void sync_control_button_mask() noexcept; + bool fire_control_action(Control control, ControlAction action) noexcept; + bool start_control_touch(SDL_FingerID id, Control control) noexcept; + void set_control_visual(Control control, bool pressed) noexcept; + void sync_l_lock_state() noexcept; + void clear_motion_touch_input() noexcept; + void clear_control_input() noexcept; + void clear_virtual_input() noexcept; + void sync_touch_state() noexcept; + void sync_visibility() noexcept; + void sync_safe_area() noexcept; + void sync_control_layouts() noexcept; + void sync_visual_state() noexcept; + void sync_action_bar_state() noexcept; + void sync_control_displays() noexcept; + void apply_control_transform(Control control) noexcept; + void handle_touch_down(Rml::Event& event) noexcept; + void handle_touch_motion(Rml::Event& event) noexcept; + void handle_touch_up(Rml::Event& event) noexcept; + void handle_touch_cancel(Rml::Event& event) noexcept; + void handle_mouse_move(Rml::Event& event) noexcept; + void handle_mouse_down(Rml::Event& event) noexcept; + void handle_mouse_up(Rml::Event& event) noexcept; + void sync_control_long_presses() noexcept; + bool release_control_touch(SDL_FingerID id, bool cancelled) noexcept; + bool handle_menu_event(Rml::Event& event, menu_pointer::Phase phase) noexcept; + + Rml::Element* mRoot = nullptr; + Rml::Element* mControlStick = nullptr; + Rml::Element* mControlKnob = nullptr; + Rml::Element* mActionBar = nullptr; + std::array(Control::COUNT)> mControlElements{}; + std::string mButtonBIconSource; + std::string mButtonXIconSource; + std::string mButtonYIconSource; + std::string mZTriggerIconSource; + uint64_t mZTriggerIconRevision = 0; + std::string mButtonXCountLabel; + std::string mButtonYCountLabel; + StickTouch mMoveTouch; + StickTouch mCameraTouch; + SDL_FingerID mMenuPointerTouch = 0; + int mMenuPointerMouseSuppressions = 0; + std::array(Control::COUNT)> mControlTouches{}; + std::array(Control::COUNT)> mControlVisualPressed{}; + std::bitset(ActionBinds::COUNT)> mQueuedActions; + LayoutState mActionBarLayout; + Insets mSafeInsets; + u16 mButtonMask = 0; + bool mLPressed = false; + bool mLLatched = false; + bool mManualLLatched = false; + bool mLReleasePending = false; + bool mRTriggerHeld = false; + bool mWantsVirtualPad = false; + bool mWasSuppressed = true; + bool mMenuPointerTouchActive = false; + clock::time_point mLPressStartTime{}; + clock::time_point mLastLTapTime{}; +}; + +} // namespace dusk::ui diff --git a/src/dusk/ui/touch_controls_common.cpp b/src/dusk/ui/touch_controls_common.cpp new file mode 100644 index 0000000000..ef46d49335 --- /dev/null +++ b/src/dusk/ui/touch_controls_common.cpp @@ -0,0 +1,359 @@ +#include "touch_controls_common.hpp" + +#include + +#include +#include +#include + +namespace dusk::ui { +namespace { + +constexpr std::array kLayoutControls = {{ + { + .layoutId = "triggerL", + .elementId = "trigger-l", + .props = + { + .x = 24.f, + .y = 18.f, + .w = 78.f, + .h = 46.f, + .scale = 1.f, + .anchor = ControlAnchor::TopLeft, + }, + .control = Control::L, + .hasControl = true, + }, + { + .layoutId = "triggerR", + .elementId = "trigger-r", + .props = + { + .x = 24.f, + .y = 18.f, + .w = 78.f, + .h = 46.f, + .scale = 1.f, + .anchor = ControlAnchor::TopRight, + }, + .control = Control::R, + .hasControl = true, + }, + { + .layoutId = "buttonZ", + .elementId = "button-z", + .props = + { + .x = 24.f, + .y = 72.f, + .w = 78.f, + .h = 46.f, + .scale = 1.f, + .anchor = ControlAnchor::TopRight, + }, + .control = Control::Z, + .hasControl = true, + }, + { + .layoutId = "actionBar", + .elementId = "action-bar", + .props = + { + .x = 56.f, + .y = 0.f, + .w = 230.f, + .h = 46.f, + .scale = 1.f, + .anchor = ControlAnchor::BottomLeft, + }, + }, + { + .layoutId = "skip", + .elementId = "skip", + .props = + { + .x = 24.f, + .y = 18.f, + .w = 64.f, + .h = 46.f, + .scale = 1.f, + .anchor = ControlAnchor::TopRight, + }, + .control = Control::SKIP, + .hasControl = true, + }, + { + .layoutId = "buttonY", + .elementId = "button-y", + .props = + { + .x = 124.f, + .y = 138.f, + .w = 58.f, + .h = 58.f, + .scale = 1.f, + .anchor = ControlAnchor::BottomRight, + }, + .control = Control::Y, + .hasControl = true, + }, + { + .layoutId = "buttonX", + .elementId = "button-x", + .props = + { + .x = 28.f, + .y = 144.f, + .w = 58.f, + .h = 58.f, + .scale = 1.f, + .anchor = ControlAnchor::BottomRight, + }, + .control = Control::X, + .hasControl = true, + }, + { + .layoutId = "buttonB", + .elementId = "button-b", + .props = + { + .x = 158.f, + .y = 48.f, + .w = 58.f, + .h = 58.f, + .scale = 1.f, + .anchor = ControlAnchor::BottomRight, + }, + .control = Control::B, + .hasControl = true, + }, + { + .layoutId = "buttonA", + .elementId = "button-a", + .props = + { + .x = 62.f, + .y = 64.f, + .w = 74.f, + .h = 74.f, + .scale = 1.f, + .anchor = ControlAnchor::BottomRight, + }, + .control = Control::A, + .hasControl = true, + }, +}}; + +constexpr std::string_view kTouchControlsRmlFragment = R"RML( + + + + + + + + + + + + + + + + + + + +)RML"; + +} // namespace + +std::string_view touch_controls_rml_fragment() noexcept { + return kTouchControlsRmlFragment; +} + +std::span touch_layout_controls() noexcept { + return kLayoutControls; +} + +const TouchLayoutControlInfo* find_touch_layout_control(std::string_view layoutId) noexcept { + for (const auto& info : kLayoutControls) { + if (info.layoutId == layoutId) { + return &info; + } + } + return nullptr; +} + +const TouchLayoutControlInfo* find_touch_layout_control(Control control) noexcept { + for (const auto& info : kLayoutControls) { + if (info.hasControl && info.control == control) { + return &info; + } + } + return nullptr; +} + +SDL_FingerID touch_event_id(const Rml::Event& event) noexcept { + return event.GetParameter("finger_id", 0); +} + +Rml::Vector2f touch_event_position(const Rml::Event& event) noexcept { + return { + event.GetParameter("x", 0.f), + event.GetParameter("y", 0.f), + }; +} + +Rml::Vector2f mouse_event_position(const Rml::Event& event) noexcept { + return { + event.GetParameter("mouse_x", 0.f), + event.GetParameter("mouse_y", 0.f), + }; +} + +float touch_dp_scale(Rml::Context* context) noexcept { + if (context == nullptr) { + context = aurora::rmlui::get_context(); + } + if (context == nullptr) { + return 1.f; + } + return std::max(context->GetDensityIndependentPixelRatio(), 1.f); +} + +ControlLayoutSize touch_document_size_dp(Rml::Context* context) noexcept { + if (context == nullptr) { + return {}; + } + + const auto dimensions = context->GetDimensions(); + const float scale = touch_dp_scale(context); + return { + .w = static_cast(dimensions.x) / scale, + .h = static_cast(dimensions.y) / scale, + }; +} + +ControlAnchor touch_control_dock_anchor(ControlRect visual, ControlLayoutSize docSize) noexcept { + if (docSize.w <= 0.f || docSize.h <= 0.f || visual.w <= 0.f || visual.h <= 0.f) { + return ControlAnchor::None; + } + + const bool top = control_float_near(visual.t, 0.f); + const bool bottom = control_float_near(visual.t + visual.h, docSize.h); + const bool left = control_float_near(visual.l, 0.f); + const bool right = control_float_near(visual.l + visual.w, docSize.w); + + if (top && left && !right) { + return ControlAnchor::TopLeft; + } + if (top && right && !left) { + return ControlAnchor::TopRight; + } + if (bottom && left && !right) { + return ControlAnchor::BottomLeft; + } + if (bottom && right && !left) { + return ControlAnchor::BottomRight; + } + if (top) { + return ControlAnchor::Top; + } + if (bottom) { + return ControlAnchor::Bottom; + } + if (left) { + return ControlAnchor::Left; + } + if (right) { + return ControlAnchor::Right; + } + return ControlAnchor::None; +} + +bool control_float_near(float a, float b) noexcept { + return std::abs(a - b) <= 0.01f; +} + +bool control_rect_near(ControlRect a, ControlRect b) noexcept { + return control_float_near(a.l, b.l) && control_float_near(a.t, b.t) && + control_float_near(a.w, b.w) && control_float_near(a.h, b.h); +} + +void apply_control_box_if_changed( + Rml::Element* element, std::optional& appliedBox, ControlRect box) noexcept { + if (element == nullptr || (appliedBox && control_rect_near(*appliedBox, box))) { + return; + } + + element->SetProperty(Rml::PropertyId::Left, Rml::Property(box.l, Rml::Unit::DP)); + element->SetProperty(Rml::PropertyId::Top, Rml::Property(box.t, Rml::Unit::DP)); + element->SetProperty(Rml::PropertyId::Width, Rml::Property(box.w, Rml::Unit::DP)); + element->SetProperty(Rml::PropertyId::Height, Rml::Property(box.h, Rml::Unit::DP)); + appliedBox = box; +} + +void apply_control_transform_if_changed( + Rml::Element* element, std::optional& appliedTransform, float scale) noexcept { + if (element == nullptr || (appliedTransform && control_float_near(*appliedTransform, scale))) { + return; + } + + element->SetProperty(Rml::PropertyId::Transform, + Rml::Transform::MakeProperty({Rml::Transforms::Scale2D{scale}})); + appliedTransform = scale; +} + +void apply_control_dock_classes(Rml::Element* element, ControlAnchor anchor) noexcept { + if (element == nullptr) { + return; + } + + bool top = false; + bool bottom = false; + bool left = false; + bool right = false; + + switch (anchor) { + case ControlAnchor::Top: + top = true; + break; + case ControlAnchor::Bottom: + bottom = true; + break; + case ControlAnchor::Left: + left = true; + break; + case ControlAnchor::Right: + right = true; + break; + case ControlAnchor::TopLeft: + top = true; + left = true; + break; + case ControlAnchor::TopRight: + top = true; + right = true; + break; + case ControlAnchor::BottomLeft: + bottom = true; + left = true; + break; + case ControlAnchor::BottomRight: + bottom = true; + right = true; + break; + case ControlAnchor::None: + break; + } + + element->SetClass("docked", top || bottom || left || right); + element->SetClass("docked-top", top); + element->SetClass("docked-bottom", bottom); + element->SetClass("docked-left", left); + element->SetClass("docked-right", right); +} + +} // namespace dusk::ui diff --git a/src/dusk/ui/touch_controls_common.hpp b/src/dusk/ui/touch_controls_common.hpp new file mode 100644 index 0000000000..30445479ff --- /dev/null +++ b/src/dusk/ui/touch_controls_common.hpp @@ -0,0 +1,45 @@ +#pragma once + +#include "controls.hpp" + +#include +#include + +#include +#include +#include +#include + +namespace dusk::ui { + +constexpr std::size_t kTouchLayoutControlCount = 9; + +struct TouchLayoutControlInfo { + std::string_view layoutId; + const char* elementId = nullptr; + ControlProps props; + Control control = Control::COUNT; + bool hasControl = false; +}; + +std::string_view touch_controls_rml_fragment() noexcept; +std::span touch_layout_controls() noexcept; +const TouchLayoutControlInfo* find_touch_layout_control(std::string_view layoutId) noexcept; +const TouchLayoutControlInfo* find_touch_layout_control(Control control) noexcept; + +SDL_FingerID touch_event_id(const Rml::Event& event) noexcept; +Rml::Vector2f touch_event_position(const Rml::Event& event) noexcept; +Rml::Vector2f mouse_event_position(const Rml::Event& event) noexcept; +float touch_dp_scale(Rml::Context* context = nullptr) noexcept; +ControlLayoutSize touch_document_size_dp(Rml::Context* context) noexcept; +ControlAnchor touch_control_dock_anchor(ControlRect visual, ControlLayoutSize docSize) noexcept; + +bool control_float_near(float a, float b) noexcept; +bool control_rect_near(ControlRect a, ControlRect b) noexcept; +void apply_control_box_if_changed( + Rml::Element* element, std::optional& appliedBox, ControlRect box) noexcept; +void apply_control_transform_if_changed( + Rml::Element* element, std::optional& appliedTransform, float scale) noexcept; +void apply_control_dock_classes(Rml::Element* element, ControlAnchor anchor) noexcept; + +} // namespace dusk::ui diff --git a/src/dusk/ui/touch_controls_editor.cpp b/src/dusk/ui/touch_controls_editor.cpp new file mode 100644 index 0000000000..539494d42f --- /dev/null +++ b/src/dusk/ui/touch_controls_editor.cpp @@ -0,0 +1,630 @@ +#include "touch_controls_editor.hpp" + +#include "modal.hpp" + +#include "Z2AudioLib/Z2SeMgr.h" +#include "dusk/config.hpp" +#include "dusk/settings.h" +#include "m_Do/m_Do_audio.h" + +#include + +#include +#include +#include +#include + +namespace dusk::ui { +namespace { + +constexpr float kDragThresholdDp = 6.f; +constexpr float kMinControlDp = 36.f; +constexpr float kMinTriggerWidthDp = 44.f; +constexpr float kMinTriggerHeightDp = 32.f; +constexpr float kMinActionBarWidthDp = 112.f; +constexpr float kMinActionBarHeightDp = 36.f; +constexpr float kMinScale = 0.25f; + +struct HandleBinding { + const char* id = nullptr; + TouchControlsEditor::EditHandle handle = TouchControlsEditor::EditHandle::Move; +}; + +constexpr std::array kHandleBindings = { + HandleBinding{"editor-handle-left", TouchControlsEditor::EditHandle::Left}, + HandleBinding{"editor-handle-right", TouchControlsEditor::EditHandle::Right}, + HandleBinding{"editor-handle-top", TouchControlsEditor::EditHandle::Top}, + HandleBinding{"editor-handle-bottom", TouchControlsEditor::EditHandle::Bottom}, + HandleBinding{"editor-handle-top-left", TouchControlsEditor::EditHandle::TopLeft}, + HandleBinding{"editor-handle-top-right", TouchControlsEditor::EditHandle::TopRight}, + HandleBinding{"editor-handle-bottom-left", TouchControlsEditor::EditHandle::BottomLeft}, + HandleBinding{"editor-handle-bottom-right", TouchControlsEditor::EditHandle::BottomRight}, +}; + +Rml::String touch_controls_editor_document_source() { + const auto fragment = touch_controls_rml_fragment(); + return Rml::String{R"RML( + + + + + + +)RML"} + Rml::String{fragment.data(), fragment.size()} + Rml::String{R"RML( + + + + + + + + + + + + + + + + + +)RML"}; +} + +bool is_corner(TouchControlsEditor::EditHandle handle) noexcept { + using EditHandle = TouchControlsEditor::EditHandle; + return handle == EditHandle::TopLeft || handle == EditHandle::TopRight || + handle == EditHandle::BottomLeft || handle == EditHandle::BottomRight; +} + +bool is_horizontal_edge(TouchControlsEditor::EditHandle handle) noexcept { + using EditHandle = TouchControlsEditor::EditHandle; + return handle == EditHandle::Left || handle == EditHandle::Right; +} + +bool is_vertical_edge(TouchControlsEditor::EditHandle handle) noexcept { + using EditHandle = TouchControlsEditor::EditHandle; + return handle == EditHandle::Top || handle == EditHandle::Bottom; +} + +bool control_valid(std::size_t index) noexcept { + return index < touch_layout_controls().size(); +} + +float squared_distance(Rml::Vector2f a, Rml::Vector2f b) noexcept { + const auto delta = a - b; + return delta.x * delta.x + delta.y * delta.y; +} + +} // namespace + +TouchControlsEditor::TouchControlsEditor() + : Document(touch_controls_editor_document_source()), + mRoot(mDocument != nullptr ? mDocument->GetElementById("root") : nullptr), + mSelectionFrame( + mDocument != nullptr ? mDocument->GetElementById("editor-selection-frame") : nullptr), + mSaveButton(mDocument != nullptr ? mDocument->GetElementById("editor-save") : nullptr), + mResetButton(mDocument != nullptr ? mDocument->GetElementById("editor-reset") : nullptr), + mCancelButton(mDocument != nullptr ? mDocument->GetElementById("editor-cancel") : nullptr), + mWorkingLayout(getSettings().game.touchControlsLayout.getValue()) { + mWorkingLayout.version = ControlLayout::Version; + + const auto controls = touch_layout_controls(); + for (std::size_t i = 0; i < controls.size() && i < mElements.size(); ++i) { + mElements[i].root = + mDocument != nullptr ? mDocument->GetElementById(controls[i].elementId) : nullptr; + } + + bind_control_events(); + bind_handle_events(); + bind_toolbar_events(); + + listen(mRoot, aurora::rmlui::TouchStartEvent, [this](Rml::Event& event) { + if (event.GetTargetElement() != mRoot) { + return; + } + clear_selected_control(); + event.StopPropagation(); + }); + listen(mRoot, Rml::EventId::Mousedown, [this](Rml::Event& event) { + const s32 button = event.GetParameter("button", -1); + if (button != 0 || event.GetTargetElement() != mRoot) { + return; + } + clear_selected_control(); + event.StopPropagation(); + }); + listen(mRoot, aurora::rmlui::TouchMoveEvent, [this](Rml::Event& event) { + if (continue_edit(touch_event_position(event))) { + event.StopPropagation(); + } + }); + listen(mRoot, aurora::rmlui::TouchEndEvent, [this](Rml::Event& event) { + if (end_edit(true, touch_event_id(event), false)) { + event.StopPropagation(); + } + }); + listen(mRoot, aurora::rmlui::TouchCancelEvent, [this](Rml::Event& event) { + if (end_edit(true, touch_event_id(event), true)) { + event.StopPropagation(); + } + }); + listen(mRoot, Rml::EventId::Mousemove, [this](Rml::Event& event) { + if (continue_edit(mouse_event_position(event))) { + event.StopPropagation(); + } + }); + listen(mRoot, Rml::EventId::Mouseup, [this](Rml::Event& event) { + if (end_edit(false, 0, false)) { + event.StopPropagation(); + } + }); + listen(mRoot, Rml::EventId::Transitionend, [this](Rml::Event& event) { + if (event.GetTargetElement() == mRoot && !mRoot->HasAttribute("open") && + Document::visible()) + { + Document::hide(mPendingClose); + } + }); +} + +void TouchControlsEditor::show() { + Document::show(); + if (mRoot != nullptr) { + mRoot->SetAttribute("open", ""); + } +} + +void TouchControlsEditor::hide(bool close) { + if (mRoot != nullptr) { + mRoot->RemoveAttribute("open"); + mPendingClose = close; + } else { + Document::hide(close); + } +} + +void TouchControlsEditor::update() { + sync_control_layouts(); + sync_selection_frame(); + Document::update(); +} + +bool TouchControlsEditor::focus() { + return mSaveButton != nullptr && mSaveButton->Focus(true); +} + +void TouchControlsEditor::bind_control_events() noexcept { + const auto controls = touch_layout_controls(); + for (std::size_t i = 0; i < controls.size() && i < mElements.size(); ++i) { + auto* element = mElements[i].root; + if (element == nullptr) { + continue; + } + + listen(element, aurora::rmlui::TouchStartEvent, [this, i](Rml::Event& event) { + if (begin_edit(i, EditHandle::Move, touch_event_position(event), true, + touch_event_id(event))) + { + event.StopPropagation(); + } + }); + listen(element, Rml::EventId::Mousedown, [this, i](Rml::Event& event) { + const s32 button = event.GetParameter("button", -1); + if (button != 0) { + return; + } + if (begin_edit(i, EditHandle::Move, mouse_event_position(event), false)) { + event.StopPropagation(); + } + }); + } +} + +void TouchControlsEditor::bind_handle_events() noexcept { + for (const auto& binding : kHandleBindings) { + auto* element = mDocument != nullptr ? mDocument->GetElementById(binding.id) : nullptr; + if (element == nullptr) { + continue; + } + + listen(element, aurora::rmlui::TouchStartEvent, [this, handle = binding.handle]( + Rml::Event& event) { + if (!control_valid(mSelectedIndex)) { + return; + } + if (begin_edit(mSelectedIndex, handle, touch_event_position(event), true, + touch_event_id(event))) + { + event.StopPropagation(); + } + }); + listen(element, Rml::EventId::Mousedown, [this, handle = binding.handle](Rml::Event& event) { + const s32 button = event.GetParameter("button", -1); + if (button != 0 || !control_valid(mSelectedIndex)) { + return; + } + if (begin_edit(mSelectedIndex, handle, mouse_event_position(event), false)) { + event.StopPropagation(); + } + }); + } +} + +void TouchControlsEditor::bind_toolbar_events() noexcept { + bind_button_command(mSaveButton, &TouchControlsEditor::save_layout); + bind_button_command(mResetButton, &TouchControlsEditor::request_reset); + bind_button_command(mCancelButton, &TouchControlsEditor::cancel_edit); +} + +void TouchControlsEditor::bind_button_command( + Rml::Element* element, void (TouchControlsEditor::*callback)()) noexcept { + if (element == nullptr) { + return; + } + + listen(element, Rml::EventId::Click, [this, callback](Rml::Event& event) { + (this->*callback)(); + event.StopPropagation(); + }); + listen(element, Rml::EventId::Keydown, [this, callback](Rml::Event& event) { + if (map_nav_event(event) != NavCommand::Confirm) { + return; + } + (this->*callback)(); + event.StopPropagation(); + }); +} + +void TouchControlsEditor::sync_control_layouts() noexcept { + auto* context = mDocument != nullptr ? mDocument->GetContext() : nullptr; + const auto docSize = touch_document_size_dp(context); + if (docSize.w <= 0.f || docSize.h <= 0.f || context == nullptr) { + return; + } + + const auto controls = touch_layout_controls(); + for (std::size_t i = 0; i < controls.size() && i < mElements.size(); ++i) { + const auto layout = resolve_control_layout(props_for(i), docSize); + auto& element = mElements[i]; + element.layout.visualRect = layout.visual; + element.layout.layoutScale = layout.scale; + if (element.root != nullptr) { + element.root->SetPseudoClass("hidden", false); + } + apply_control_box_if_changed(element.root, element.layout.appliedBox, layout.box); + apply_control_dock_classes( + element.root, touch_control_dock_anchor(layout.visual, docSize)); + apply_control_transform_if_changed( + element.root, element.layout.appliedTransform, element.layout.layoutScale); + } +} + +void TouchControlsEditor::sync_selection_frame() noexcept { + const bool hasSelection = + control_valid(mSelectedIndex) && mElements[mSelectedIndex].layout.visualRect; + if (mSelectionFrame == nullptr) { + return; + } + + mSelectionFrame->SetClass("visible", hasSelection); + for (std::size_t i = 0; i < mElements.size(); ++i) { + if (mElements[i].root != nullptr) { + mElements[i].root->SetClass("editor-selected", hasSelection && i == mSelectedIndex); + } + } + if (!hasSelection) { + mAppliedSelectionFrame = std::nullopt; + return; + } + + apply_control_box_if_changed( + mSelectionFrame, mAppliedSelectionFrame, *mElements[mSelectedIndex].layout.visualRect); +} + +void TouchControlsEditor::set_selected_control(std::size_t index) noexcept { + if (!control_valid(index)) { + clear_selected_control(); + return; + } + mSelectedIndex = index; + sync_selection_frame(); +} + +void TouchControlsEditor::clear_selected_control() noexcept { + mSelectedIndex = kTouchLayoutControlCount; + sync_selection_frame(); +} + +ControlProps TouchControlsEditor::props_for(std::size_t index) const { + const auto controls = touch_layout_controls(); + if (!control_valid(index)) { + return {}; + } + + const auto& info = controls[index]; + if (const auto iter = mWorkingLayout.controls.find(info.layoutId); + iter != mWorkingLayout.controls.end()) + { + return iter->second; + } + return info.props; +} + +void TouchControlsEditor::store_props( + std::size_t index, ControlRect visual, ControlProps props) noexcept { + if (!control_valid(index)) { + return; + } + + auto* context = mDocument != nullptr ? mDocument->GetContext() : nullptr; + const auto docSize = touch_document_size_dp(context); + if (docSize.w <= 0.f || docSize.h <= 0.f) { + return; + } + + props.w = std::max(props.w, 1.f); + props.h = std::max(props.h, 1.f); + props.scale = std::max(props.scale, kMinScale); + props = encode_control_props(visual, docSize, props, touch_control_dock_anchor(visual, docSize)); + mWorkingLayout.version = ControlLayout::Version; + mWorkingLayout.controls[std::string{touch_layout_controls()[index].layoutId}] = props; + sync_control_layouts(); + sync_selection_frame(); +} + +void TouchControlsEditor::restore_active_control() noexcept { + if (!control_valid(mPointerEdit.index)) { + return; + } + + auto& controls = mWorkingLayout.controls; + const auto key = std::string{touch_layout_controls()[mPointerEdit.index].layoutId}; + if (mPointerEdit.storedProps) { + controls[key] = *mPointerEdit.storedProps; + } else { + controls.erase(key); + } + sync_control_layouts(); + sync_selection_frame(); +} + +bool TouchControlsEditor::begin_edit( + std::size_t index, EditHandle handle, Rml::Vector2f positionPx, bool touch, + SDL_FingerID touchId) noexcept { + if (!control_valid(index) || mPointerEdit.active) { + return false; + } + + auto* context = mDocument != nullptr ? mDocument->GetContext() : nullptr; + const auto docSize = touch_document_size_dp(context); + if (docSize.w <= 0.f || docSize.h <= 0.f) { + return false; + } + + const auto props = props_for(index); + const auto layout = resolve_control_layout(props, docSize); + std::optional storedProps; + if (const auto iter = mWorkingLayout.controls.find(touch_layout_controls()[index].layoutId); + iter != mWorkingLayout.controls.end()) + { + storedProps = iter->second; + } + + mPointerEdit = { + .index = index, + .touchId = touchId, + .startPointerDp = pointer_position_dp(positionPx), + .startVisual = layout.visual, + .startProps = props, + .storedProps = storedProps, + .handle = handle, + .active = true, + .touch = touch, + }; + set_selected_control(index); + return true; +} + +bool TouchControlsEditor::continue_edit(Rml::Vector2f positionPx) noexcept { + if (!mPointerEdit.active) { + return false; + } + + const auto pointerDp = pointer_position_dp(positionPx); + if (!mPointerEdit.dragging) { + if (squared_distance(pointerDp, mPointerEdit.startPointerDp) < + kDragThresholdDp * kDragThresholdDp) + { + return true; + } + mPointerEdit.dragging = true; + } + + auto props = mPointerEdit.startProps; + auto rect = rect_for_edit(pointerDp, props); + rect = clamp_visual_rect(mPointerEdit.index, rect); + if (is_corner(mPointerEdit.handle)) { + props.scale = std::max(rect.w / std::max(mPointerEdit.startProps.w, 1.f), kMinScale); + } else if (is_horizontal_edge(mPointerEdit.handle)) { + props.w = rect.w / std::max(props.scale, kMinScale); + } else if (is_vertical_edge(mPointerEdit.handle)) { + props.h = rect.h / std::max(props.scale, kMinScale); + } + store_props(mPointerEdit.index, rect, props); + return true; +} + +bool TouchControlsEditor::end_edit(bool touch, SDL_FingerID touchId, bool cancelled) noexcept { + if (!mPointerEdit.active || mPointerEdit.touch != touch || + (touch && mPointerEdit.touchId != touchId)) + { + return false; + } + + if (cancelled && mPointerEdit.dragging) { + restore_active_control(); + } + mPointerEdit = {}; + return true; +} + +Rml::Vector2f TouchControlsEditor::pointer_position_dp(Rml::Vector2f positionPx) const noexcept { + auto* context = mDocument != nullptr ? mDocument->GetContext() : nullptr; + return positionPx / touch_dp_scale(context); +} + +ControlRect TouchControlsEditor::rect_for_edit( + Rml::Vector2f pointerDp, ControlProps& props) const noexcept { + const auto& edit = mPointerEdit; + auto rect = edit.startVisual; + const auto delta = pointerDp - edit.startPointerDp; + + switch (edit.handle) { + case EditHandle::Move: + rect.l += delta.x; + rect.t += delta.y; + return rect; + case EditHandle::Left: { + const float right = edit.startVisual.l + edit.startVisual.w; + rect.l = pointerDp.x; + rect.w = right - rect.l; + return rect; + } + case EditHandle::Right: + rect.w = pointerDp.x - edit.startVisual.l; + return rect; + case EditHandle::Top: { + const float bottom = edit.startVisual.t + edit.startVisual.h; + rect.t = pointerDp.y; + rect.h = bottom - rect.t; + return rect; + } + case EditHandle::Bottom: + rect.h = pointerDp.y - edit.startVisual.t; + return rect; + case EditHandle::TopLeft: + case EditHandle::TopRight: + case EditHandle::BottomLeft: + case EditHandle::BottomRight: + break; + } + + auto* context = mDocument != nullptr ? mDocument->GetContext() : nullptr; + const auto docSize = touch_document_size_dp(context); + const bool left = edit.handle == EditHandle::TopLeft || edit.handle == EditHandle::BottomLeft; + const bool top = edit.handle == EditHandle::TopLeft || edit.handle == EditHandle::TopRight; + const Rml::Vector2f fixed{ + left ? edit.startVisual.l + edit.startVisual.w : edit.startVisual.l, + top ? edit.startVisual.t + edit.startVisual.h : edit.startVisual.t, + }; + const float desiredW = left ? fixed.x - pointerDp.x : pointerDp.x - fixed.x; + const float desiredH = top ? fixed.y - pointerDp.y : pointerDp.y - fixed.y; + const auto minSize = min_visual_size(edit.index); + const float minRatio = + std::max(minSize.x / std::max(edit.startVisual.w, 1.f), + minSize.y / std::max(edit.startVisual.h, 1.f)); + const float maxW = left ? fixed.x : docSize.w - fixed.x; + const float maxH = top ? fixed.y : docSize.h - fixed.y; + const float maxRatio = + std::max(minRatio, std::min(maxW / std::max(edit.startVisual.w, 1.f), + maxH / std::max(edit.startVisual.h, 1.f))); + const float ratio = + std::clamp(std::max(desiredW / std::max(edit.startVisual.w, 1.f), + desiredH / std::max(edit.startVisual.h, 1.f)), + minRatio, maxRatio); + + rect.w = edit.startVisual.w * ratio; + rect.h = edit.startVisual.h * ratio; + rect.l = left ? fixed.x - rect.w : fixed.x; + rect.t = top ? fixed.y - rect.h : fixed.y; + props.scale = std::max(edit.startProps.scale * ratio, kMinScale); + return rect; +} + +ControlRect TouchControlsEditor::clamp_visual_rect(std::size_t index, ControlRect rect) const noexcept { + auto* context = mDocument != nullptr ? mDocument->GetContext() : nullptr; + const auto docSize = touch_document_size_dp(context); + if (docSize.w <= 0.f || docSize.h <= 0.f || !control_valid(index)) { + return rect; + } + + const auto minSize = min_visual_size(index); + const float minW = std::min(minSize.x, docSize.w); + const float minH = std::min(minSize.y, docSize.h); + rect.w = std::clamp(rect.w, minW, docSize.w); + rect.h = std::clamp(rect.h, minH, docSize.h); + rect.l = std::clamp(rect.l, 0.f, std::max(0.f, docSize.w - rect.w)); + rect.t = std::clamp(rect.t, 0.f, std::max(0.f, docSize.h - rect.h)); + return rect; +} + +Rml::Vector2f TouchControlsEditor::min_visual_size(std::size_t index) const noexcept { + if (!control_valid(index)) { + return {kMinControlDp, kMinControlDp}; + } + + const auto id = touch_layout_controls()[index].layoutId; + if (id == "actionBar") { + return {kMinActionBarWidthDp, kMinActionBarHeightDp}; + } + if (id == "triggerL" || id == "triggerR" || id == "buttonZ" || id == "skip") { + return {kMinTriggerWidthDp, kMinTriggerHeightDp}; + } + return {kMinControlDp, kMinControlDp}; +} + +bool TouchControlsEditor::handle_nav_command(Rml::Event& event, NavCommand cmd) { + if (cmd == NavCommand::Cancel || cmd == NavCommand::Menu) { + cancel_edit(); + return true; + } + return Document::handle_nav_command(event, cmd); +} + +void TouchControlsEditor::save_layout() { + mWorkingLayout.version = ControlLayout::Version; + getSettings().game.touchControlsLayout.setValue(mWorkingLayout); + config::Save(); + mDoAud_seStartMenu(kSoundItemChange); + pop(); +} + +void TouchControlsEditor::request_reset() { + auto dismiss = [](Modal& modal) { modal.pop(); }; + push(std::make_unique(Modal::Props{ + .title = "Reset Touch Layout?", + .bodyRml = "Reset controls to their default layout. This will not be saved until you press Save.", + .actions = + { + ModalAction{ + .label = "Reset", + .onPressed = + [this, dismiss](Modal& modal) { + reset_working_layout(); + mDoAud_seStartMenu(kSoundItemChange); + dismiss(modal); + }, + }, + ModalAction{ + .label = "Cancel", + .onPressed = dismiss, + }, + }, + })); +} + +void TouchControlsEditor::reset_working_layout() noexcept { + mWorkingLayout = ControlLayout{}; + mWorkingLayout.version = ControlLayout::Version; + mPointerEdit = {}; + sync_control_layouts(); + sync_selection_frame(); +} + +void TouchControlsEditor::cancel_edit() { + mDoAud_seStartMenu(kSoundWindowClose); + pop(); +} + +} // namespace dusk::ui diff --git a/src/dusk/ui/touch_controls_editor.hpp b/src/dusk/ui/touch_controls_editor.hpp new file mode 100644 index 0000000000..4af33d8fbc --- /dev/null +++ b/src/dusk/ui/touch_controls_editor.hpp @@ -0,0 +1,98 @@ +#pragma once + +#include "controls.hpp" +#include "document.hpp" +#include "touch_controls_common.hpp" + +#include +#include +#include + +namespace dusk::ui { + +class TouchControlsEditor final : public Document { +public: + TouchControlsEditor(); + + void show() override; + void hide(bool close) override; + void update() override; + bool focus() override; + + enum class EditHandle { + Move, + Left, + Right, + Top, + Bottom, + TopLeft, + TopRight, + BottomLeft, + BottomRight, + }; + +private: + struct LayoutState { + std::optional visualRect; + std::optional appliedBox; + float layoutScale = 1.0f; + std::optional appliedTransform; + }; + + struct EditElement { + Rml::Element* root = nullptr; + LayoutState layout; + }; + + struct PointerEdit { + std::size_t index = kTouchLayoutControlCount; + SDL_FingerID touchId = 0; + Rml::Vector2f startPointerDp; + ControlRect startVisual; + ControlProps startProps; + std::optional storedProps; + EditHandle handle = EditHandle::Move; + bool active = false; + bool touch = false; + bool dragging = false; + }; + + void bind_control_events() noexcept; + void bind_handle_events() noexcept; + void bind_toolbar_events() noexcept; + void bind_button_command( + Rml::Element* element, void (TouchControlsEditor::*callback)()) noexcept; + void sync_control_layouts() noexcept; + void sync_selection_frame() noexcept; + void set_selected_control(std::size_t index) noexcept; + void clear_selected_control() noexcept; + ControlProps props_for(std::size_t index) const; + void store_props(std::size_t index, ControlRect visual, ControlProps props) noexcept; + void restore_active_control() noexcept; + bool begin_edit(std::size_t index, EditHandle handle, Rml::Vector2f positionPx, bool touch, + SDL_FingerID touchId = 0) noexcept; + bool continue_edit(Rml::Vector2f positionPx) noexcept; + bool end_edit(bool touch, SDL_FingerID touchId, bool cancelled) noexcept; + Rml::Vector2f pointer_position_dp(Rml::Vector2f positionPx) const noexcept; + ControlRect rect_for_edit(Rml::Vector2f pointerDp, ControlProps& props) const noexcept; + ControlRect clamp_visual_rect(std::size_t index, ControlRect rect) const noexcept; + Rml::Vector2f min_visual_size(std::size_t index) const noexcept; + bool handle_nav_command(Rml::Event& event, NavCommand cmd) override; + void save_layout(); + void request_reset(); + void reset_working_layout() noexcept; + void cancel_edit(); + + Rml::Element* mRoot = nullptr; + Rml::Element* mSelectionFrame = nullptr; + Rml::Element* mSaveButton = nullptr; + Rml::Element* mResetButton = nullptr; + Rml::Element* mCancelButton = nullptr; + std::array mElements{}; + ControlLayout mWorkingLayout; + PointerEdit mPointerEdit; + std::optional mAppliedSelectionFrame; + std::size_t mSelectedIndex = kTouchLayoutControlCount; +}; + +} // namespace dusk::ui diff --git a/src/dusk/ui/ui.cpp b/src/dusk/ui/ui.cpp index af05d0f476..0d9d0b7e1e 100644 --- a/src/dusk/ui/ui.cpp +++ b/src/dusk/ui/ui.cpp @@ -1,7 +1,11 @@ #include "ui.hpp" #include -#include +#include +#include +#include +#include +#include #include #include #include @@ -11,11 +15,12 @@ #include #include "aurora/lib/window.hpp" +#include "dusk/config.hpp" #include "dusk/io.hpp" #include "input.hpp" +#include "icon_provider.hpp" #include "prelaunch.hpp" #include "window.hpp" -#include "dusk/config.hpp" namespace dusk::ui { namespace { @@ -56,11 +61,13 @@ bool initialize() noexcept { load_font("MaterialSymbolsRounded-Regular.ttf"); load_font("NotoMono-Regular.ttf"); + register_icon_texture_provider(); sInitialized = true; return true; } void shutdown() noexcept { + unregister_icon_texture_provider(); sDocumentStack.clear(); sPassiveDocuments.clear(); sConnectedGamepads.clear(); diff --git a/src/f_ap/f_ap_game.cpp b/src/f_ap/f_ap_game.cpp index e2e8a61168..ca11ccbe64 100644 --- a/src/f_ap/f_ap_game.cpp +++ b/src/f_ap/f_ap_game.cpp @@ -29,6 +29,7 @@ #include "tracy/Tracy.hpp" #include #include +#include "dusk/menu_pointer.h" #endif fapGm_HIO_c::fapGm_HIO_c() { @@ -743,6 +744,7 @@ static void fapGm_AfterRecord() { BOOL isRecording = false; static void duskExecute() { + dusk::menu_pointer::begin_game_frame(); dusk::input::handleGamepadColor(); updateAutoSave(); @@ -842,6 +844,7 @@ void fapGm_Execute() { #ifdef TARGET_PC dusk::speedrun::onGameFrame(); dusk::AchievementSystem::get().tick(); + dusk::menu_pointer::end_game_frame(); #endif } diff --git a/src/m_Do/m_Do_controller_pad.cpp b/src/m_Do/m_Do_controller_pad.cpp index 8ba03fc63b..f7eaa92ca2 100644 --- a/src/m_Do/m_Do_controller_pad.cpp +++ b/src/m_Do/m_Do_controller_pad.cpp @@ -12,6 +12,11 @@ #include "m_Do/m_Do_main.h" #include "tracy/Tracy.hpp" +#if TARGET_PC +#include "dusk/menu_pointer.h" +#include "dusk/ui/touch_controls.hpp" +#endif + JUTGamePad* mDoCPd_c::m_gamePad[4]; interface_of_controller_pad mDoCPd_c::m_cpadInfo[4]; @@ -58,6 +63,9 @@ void mDoCPd_c::create() { void mDoCPd_c::read() { ZoneScoped; +#if TARGET_PC + dusk::ui::sync_virtual_input(); +#endif JUTGamePad::read(); if (!mDoRst::isReset() && mDoRst::is3ButtonReset()) { @@ -88,6 +96,12 @@ void mDoCPd_c::read() { cLib_memSet(interface, 0, sizeof(interface_of_controller_pad)); } else { convert(interface, *pad); +#if TARGET_PC + const u32 suppressedButtons = dusk::menu_pointer::suppressed_pad_buttons(i); + interface->mButtonFlags &= ~suppressedButtons; + interface->mPressedButtonFlags &= ~suppressedButtons; + dusk::menu_pointer::finish_pad_suppression_read(i); +#endif LRlockCheck(interface); } #if DEBUG diff --git a/src/m_Do/m_Do_main.cpp b/src/m_Do/m_Do_main.cpp index 8fedae1f6a..4694146714 100644 --- a/src/m_Do/m_Do_main.cpp +++ b/src/m_Do/m_Do_main.cpp @@ -65,6 +65,7 @@ #include "dusk/ui/overlay.hpp" #include "dusk/ui/prelaunch.hpp" #include "dusk/ui/preset.hpp" +#include "dusk/ui/touch_controls.hpp" #include "dusk/ui/ui.hpp" #include "version.h" @@ -663,6 +664,7 @@ int game_main(int argc, char* argv[]) { dusk::texture_replacements::reload(); dusk::ui::initialize(); dusk::ui::push_document(std::make_unique(), true, true); + dusk::ui::push_document(std::make_unique(), false, true); dusk::ui::push_document(std::make_unique(), false); // Invalidate a bad saved isoPath so that Dusklight can't get blocked from starting up.