1
// SPDX-FileCopyrightText: 2019-2025 Connor McLaughlin <[email protected]> and contributors.
2
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
3

4
#include "analog_joystick.h"
5
#include "host.h"
6
#include "system.h"
7

8
#include "util/imgui_manager.h"
9
#include "util/input_manager.h"
10
#include "util/state_wrapper.h"
11

12
#include "common/bitutils.h"
13
#include "common/log.h"
14
#include "common/settings_interface.h"
15
#include "common/string_util.h"
16

17
#include "IconsFontAwesome6.h"
18
#include "IconsPromptFont.h"
19
#include "fmt/format.h"
20

21
LOG_CHANNEL(Controller);
22

23
AnalogJoystick::AnalogJoystick(u32 index) : Controller(index)
24
{
25
  m_axis_state.fill(0x80);
26
  Reset();
27
}
28

29
AnalogJoystick::~AnalogJoystick() = default;
30

31
ControllerType AnalogJoystick::GetType() const
32
{
33
  return ControllerType::AnalogJoystick;
34
}
35

36
void AnalogJoystick::Reset()
37
{
38
  m_transfer_state = TransferState::Idle;
39
  m_analog_mode = true;
40
  InputManager::SetPadLEDState(m_index, 1.0f);
41
}
42

43
bool AnalogJoystick::DoState(StateWrapper& sw, bool apply_input_state)
44
{
45
  if (!Controller::DoState(sw, apply_input_state))
46
    return false;
47

48
  const bool old_analog_mode = m_analog_mode;
49

50
  sw.Do(&m_analog_mode);
51

52
  u16 button_state = m_button_state;
53
  auto axis_state = m_axis_state;
54
  sw.Do(&button_state);
55
  sw.Do(&axis_state);
56

57
  if (apply_input_state)
58
  {
59
    m_button_state = button_state;
60
    m_axis_state = axis_state;
61
  }
62

63
  sw.Do(&m_transfer_state);
64

65
  if (sw.IsReading() && (old_analog_mode != m_analog_mode))
66
  {
67
    Host::AddIconOSDMessage(
68
      fmt::format("analog_mode_toggle_{}", m_index), ICON_FA_GAMEPAD,
69
      m_analog_mode ? fmt::format(TRANSLATE_FS("Controller", "Controller {} switched to analog mode."), m_index + 1u) :
70
                      fmt::format(TRANSLATE_FS("Controller", "Controller {} switched to digital mode."), m_index + 1u));
71
  }
72
  return true;
73
}
74

75
float AnalogJoystick::GetBindState(u32 index) const
76
{
77
  if (index >= LED_BIND_START_INDEX)
78
    return BoolToFloat(index == LED_BIND_START_INDEX && m_analog_mode);
79
  else if (index >= HALFAXIS_BIND_START_INDEX)
80
    return static_cast<float>(m_half_axis_state[index - HALFAXIS_BIND_START_INDEX]) * (1.0f / 255.0f);
81
  else if (index < static_cast<u32>(Button::Mode))
82
    return static_cast<float>(((m_button_state >> index) & 1u) ^ 1u);
83
  else
84
    return 0.0f;
85
}
86

87
void AnalogJoystick::SetBindState(u32 index, float value)
88
{
89
  if (index == static_cast<s32>(Button::Mode))
90
  {
91
    // analog toggle
92
    if (value >= 0.5f)
93
      ToggleAnalogMode();
94

95
    return;
96
  }
97
  else if (index >= static_cast<u32>(Button::Count))
98
  {
99
    const u32 sub_index = index - static_cast<u32>(Button::Count);
100
    if (sub_index >= static_cast<u32>(m_half_axis_state.size()))
101
      return;
102

103
    const u8 u8_value = static_cast<u8>(std::clamp(value * m_analog_sensitivity * 255.0f, 0.0f, 255.0f));
104
    if (m_half_axis_state[sub_index] == u8_value)
105
      return;
106

107
    m_half_axis_state[sub_index] = u8_value;
108

109
#define MERGE(pos, neg)                                                                                                \
110
  ((m_half_axis_state[static_cast<u32>(pos)] != 0) ? (127u + ((m_half_axis_state[static_cast<u32>(pos)] + 1u) / 2u)) : \
111
                                                     (127u - (m_half_axis_state[static_cast<u32>(neg)] / 2u)))
112

113
    const auto prev_axis_state = m_axis_state;
114

115
    switch (static_cast<HalfAxis>(sub_index))
116
    {
117
      case HalfAxis::LLeft:
118
      case HalfAxis::LRight:
119
        m_axis_state[static_cast<u8>(Axis::LeftX)] = ((m_invert_left_stick & 1u) != 0u) ?
120
                                                       MERGE(HalfAxis::LLeft, HalfAxis::LRight) :
121
                                                       MERGE(HalfAxis::LRight, HalfAxis::LLeft);
122
        break;
123

124
      case HalfAxis::LDown:
125
      case HalfAxis::LUp:
126
        m_axis_state[static_cast<u8>(Axis::LeftY)] = ((m_invert_left_stick & 2u) != 0u) ?
127
                                                       MERGE(HalfAxis::LUp, HalfAxis::LDown) :
128
                                                       MERGE(HalfAxis::LDown, HalfAxis::LUp);
129
        break;
130

131
      case HalfAxis::RLeft:
132
      case HalfAxis::RRight:
133
        m_axis_state[static_cast<u8>(Axis::RightX)] = ((m_invert_right_stick & 1u) != 0u) ?
134
                                                        MERGE(HalfAxis::RLeft, HalfAxis::RRight) :
135
                                                        MERGE(HalfAxis::RRight, HalfAxis::RLeft);
136
        break;
137

138
      case HalfAxis::RDown:
139
      case HalfAxis::RUp:
140
        m_axis_state[static_cast<u8>(Axis::RightY)] = ((m_invert_right_stick & 2u) != 0u) ?
141
                                                        MERGE(HalfAxis::RUp, HalfAxis::RDown) :
142
                                                        MERGE(HalfAxis::RDown, HalfAxis::RUp);
143
        break;
144

145
      default:
146
        break;
147
    }
148

149
    if (m_analog_deadzone > 0.0f)
150
    {
151
#define MERGE_F(pos, neg)                                                                                              \
152
  ((m_half_axis_state[static_cast<u32>(pos)] != 0) ?                                                                   \
153
     (static_cast<float>(m_half_axis_state[static_cast<u32>(pos)]) / 255.0f) :                                         \
154
     (static_cast<float>(m_half_axis_state[static_cast<u32>(neg)]) / -255.0f))
155

156
      float pos_x, pos_y;
157
      if (static_cast<HalfAxis>(sub_index) < HalfAxis::RLeft)
158
      {
159
        pos_x = ((m_invert_left_stick & 1u) != 0u) ? MERGE_F(HalfAxis::LLeft, HalfAxis::LRight) :
160
                                                     MERGE_F(HalfAxis::LRight, HalfAxis::LLeft);
161
        pos_y = ((m_invert_left_stick & 2u) != 0u) ? MERGE_F(HalfAxis::LUp, HalfAxis::LDown) :
162
                                                     MERGE_F(HalfAxis::LDown, HalfAxis::LUp);
163
      }
164
      else
165
      {
166
        pos_x = ((m_invert_right_stick & 1u) != 0u) ? MERGE_F(HalfAxis::RLeft, HalfAxis::RRight) :
167
                                                      MERGE_F(HalfAxis::RRight, HalfAxis::RLeft);
168
        pos_y = ((m_invert_right_stick & 2u) != 0u) ? MERGE_F(HalfAxis::RUp, HalfAxis::RDown) :
169
                                                      MERGE_F(HalfAxis::RDown, HalfAxis::RUp);
170
      }
171

172
      if (InCircularDeadzone(m_analog_deadzone, pos_x, pos_y))
173
      {
174
        // Set to 127 (center).
175
        if (static_cast<HalfAxis>(sub_index) < HalfAxis::RLeft)
176
          m_axis_state[static_cast<u8>(Axis::LeftX)] = m_axis_state[static_cast<u8>(Axis::LeftY)] = 127;
177
        else
178
          m_axis_state[static_cast<u8>(Axis::RightX)] = m_axis_state[static_cast<u8>(Axis::RightY)] = 127;
179
      }
180
#undef MERGE_F
181
    }
182

183
    if (std::memcmp(m_axis_state.data(), prev_axis_state.data(), m_axis_state.size()) != 0)
184
      System::SetRunaheadReplayFlag(true);
185

186
#undef MERGE
187

188
    return;
189
  }
190

191
  const u16 bit = u16(1) << static_cast<u8>(index);
192

193
  if (value >= 0.5f)
194
  {
195
    if (m_button_state & bit)
196
      System::SetRunaheadReplayFlag(false);
197

198
    m_button_state &= ~(bit);
199
  }
200
  else
201
  {
202
    if (!(m_button_state & bit))
203
      System::SetRunaheadReplayFlag(false);
204

205
    m_button_state |= bit;
206
  }
207
}
208

209
u32 AnalogJoystick::GetButtonStateBits() const
210
{
211
  return m_button_state ^ 0xFFFF;
212
}
213

214
std::optional<u32> AnalogJoystick::GetAnalogInputBytes() const
215
{
216
  return m_axis_state[static_cast<size_t>(Axis::LeftY)] << 24 | m_axis_state[static_cast<size_t>(Axis::LeftX)] << 16 |
217
         m_axis_state[static_cast<size_t>(Axis::RightY)] << 8 | m_axis_state[static_cast<size_t>(Axis::RightX)];
218
}
219

220
void AnalogJoystick::ResetTransferState()
221
{
222
  m_transfer_state = TransferState::Idle;
223
}
224

225
u16 AnalogJoystick::GetID() const
226
{
227
  static constexpr u16 DIGITAL_MODE_ID = 0x5A41;
228
  static constexpr u16 ANALOG_MODE_ID = 0x5A53;
229

230
  return m_analog_mode ? ANALOG_MODE_ID : DIGITAL_MODE_ID;
231
}
232

233
void AnalogJoystick::ToggleAnalogMode()
234
{
235
  m_analog_mode = !m_analog_mode;
236

237
  InputManager::SetPadLEDState(m_index, BoolToFloat(m_analog_mode));
238

239
  INFO_LOG("Joystick {} switched to {} mode.", m_index + 1u, m_analog_mode ? "analog" : "digital");
240
  Host::AddIconOSDMessage(
241
    fmt::format("analog_mode_toggle_{}", m_index), ICON_FA_GAMEPAD,
242
    m_analog_mode ? fmt::format(TRANSLATE_FS("Controller", "Controller {} switched to analog mode."), m_index + 1u) :
243
                    fmt::format(TRANSLATE_FS("Controller", "Controller {} switched to digital mode."), m_index + 1u));
244
}
245

246
bool AnalogJoystick::Transfer(const u8 data_in, u8* data_out)
247
{
248
  switch (m_transfer_state)
249
  {
250
    case TransferState::Idle:
251
    {
252
      *data_out = 0xFF;
253

254
      if (data_in == 0x01)
255
      {
256
        m_transfer_state = TransferState::Ready;
257
        return true;
258
      }
259
      return false;
260
    }
261

262
    case TransferState::Ready:
263
    {
264
      if (data_in == 0x42)
265
      {
266
        *data_out = Truncate8(GetID());
267
        m_transfer_state = TransferState::IDMSB;
268
        return true;
269
      }
270

271
      *data_out = 0xFF;
272
      return false;
273
    }
274

275
    case TransferState::IDMSB:
276
    {
277
      *data_out = Truncate8(GetID() >> 8);
278
      m_transfer_state = TransferState::ButtonsLSB;
279
      return true;
280
    }
281

282
    case TransferState::ButtonsLSB:
283
    {
284
      *data_out = Truncate8(m_button_state);
285
      m_transfer_state = TransferState::ButtonsMSB;
286
      return true;
287
    }
288

289
    case TransferState::ButtonsMSB:
290
    {
291
      *data_out = Truncate8(m_button_state >> 8);
292

293
      m_transfer_state = m_analog_mode ? TransferState::RightAxisX : TransferState::Idle;
294
      return m_analog_mode;
295
    }
296

297
    case TransferState::RightAxisX:
298
    {
299
      *data_out = Truncate8(m_axis_state[static_cast<u8>(Axis::RightX)]);
300
      m_transfer_state = TransferState::RightAxisY;
301
      return true;
302
    }
303

304
    case TransferState::RightAxisY:
305
    {
306
      *data_out = Truncate8(m_axis_state[static_cast<u8>(Axis::RightY)]);
307
      m_transfer_state = TransferState::LeftAxisX;
308
      return true;
309
    }
310

311
    case TransferState::LeftAxisX:
312
    {
313
      *data_out = Truncate8(m_axis_state[static_cast<u8>(Axis::LeftX)]);
314
      m_transfer_state = TransferState::LeftAxisY;
315
      return true;
316
    }
317

318
    case TransferState::LeftAxisY:
319
    {
320
      *data_out = Truncate8(m_axis_state[static_cast<u8>(Axis::LeftY)]);
321
      m_transfer_state = TransferState::Idle;
322
      return false;
323
    }
324

325
    default:
326
    {
327
      UnreachableCode();
328
      return false;
329
    }
330
  }
331
}
332

333
std::unique_ptr<AnalogJoystick> AnalogJoystick::Create(u32 index)
334
{
335
  return std::make_unique<AnalogJoystick>(index);
336
}
337

338
constinit const Controller::ControllerBindingInfo AnalogJoystick::s_binding_info[] = {
339
#define BUTTON(name, display_name, icon_name, button, genb)                                                            \
340
  {name, display_name, icon_name, static_cast<u32>(button), InputBindingInfo::Type::Button, genb}
341
#define AXIS(name, display_name, icon_name, halfaxis, genb)                                                            \
342
  {name,                                                                                                               \
343
   display_name,                                                                                                       \
344
   icon_name,                                                                                                          \
345
   HALFAXIS_BIND_START_INDEX + static_cast<u32>(halfaxis),                                                             \
346
   InputBindingInfo::Type::HalfAxis,                                                                                   \
347
   genb}
348
#define MODE_LED(name, display_name, icon_name, index, genb)                                                           \
349
  {name, display_name, icon_name, LED_BIND_START_INDEX + index, InputBindingInfo::Type::LED, genb}
350

351
  // clang-format off
352
  BUTTON("Up", TRANSLATE_NOOP("AnalogJoystick", "D-Pad Up"), ICON_PF_DPAD_UP, AnalogJoystick::Button::Up, GenericInputBinding::DPadUp),
353
  BUTTON("Right", TRANSLATE_NOOP("AnalogJoystick", "D-Pad Right"), ICON_PF_DPAD_RIGHT, AnalogJoystick::Button::Right, GenericInputBinding::DPadRight),
354
  BUTTON("Down", TRANSLATE_NOOP("AnalogJoystick", "D-Pad Down"), ICON_PF_DPAD_DOWN, AnalogJoystick::Button::Down, GenericInputBinding::DPadDown),
355
  BUTTON("Left", TRANSLATE_NOOP("AnalogJoystick", "D-Pad Left"), ICON_PF_DPAD_LEFT, AnalogJoystick::Button::Left, GenericInputBinding::DPadLeft),
356
  BUTTON("Triangle", TRANSLATE_NOOP("AnalogJoystick", "Triangle"), ICON_PF_BUTTON_TRIANGLE, AnalogJoystick::Button::Triangle, GenericInputBinding::Triangle),
357
  BUTTON("Circle", TRANSLATE_NOOP("AnalogJoystick", "Circle"), ICON_PF_BUTTON_CIRCLE, AnalogJoystick::Button::Circle, GenericInputBinding::Circle),
358
  BUTTON("Cross", TRANSLATE_NOOP("AnalogJoystick", "Cross"), ICON_PF_BUTTON_CROSS, AnalogJoystick::Button::Cross, GenericInputBinding::Cross),
359
  BUTTON("Square", TRANSLATE_NOOP("AnalogJoystick", "Square"), ICON_PF_BUTTON_SQUARE, AnalogJoystick::Button::Square, GenericInputBinding::Square),
360
  BUTTON("Select", TRANSLATE_NOOP("AnalogJoystick", "Select"), ICON_PF_SELECT_SHARE, AnalogJoystick::Button::Select, GenericInputBinding::Select),
361
  BUTTON("Start", TRANSLATE_NOOP("AnalogJoystick", "Start"), ICON_PF_START, AnalogJoystick::Button::Start, GenericInputBinding::Start),
362
  BUTTON("Mode", TRANSLATE_NOOP("AnalogJoystick", "Mode Toggle"), ICON_PF_ANALOG_LEFT_RIGHT, AnalogJoystick::Button::Mode, GenericInputBinding::System),
363
  BUTTON("L1", TRANSLATE_NOOP("AnalogJoystick", "L1"), ICON_PF_LEFT_SHOULDER_L1, AnalogJoystick::Button::L1, GenericInputBinding::L1),
364
  BUTTON("R1", TRANSLATE_NOOP("AnalogJoystick", "R1"), ICON_PF_RIGHT_SHOULDER_R1, AnalogJoystick::Button::R1, GenericInputBinding::R1),
365
  BUTTON("L2", TRANSLATE_NOOP("AnalogJoystick", "L2"), ICON_PF_LEFT_TRIGGER_L2, AnalogJoystick::Button::L2, GenericInputBinding::L2),
366
  BUTTON("R2", TRANSLATE_NOOP("AnalogJoystick", "R2"), ICON_PF_RIGHT_TRIGGER_R2, AnalogJoystick::Button::R2, GenericInputBinding::R2),
367
  BUTTON("L3", TRANSLATE_NOOP("AnalogJoystick", "L3"), ICON_PF_LEFT_ANALOG_CLICK, AnalogJoystick::Button::L3, GenericInputBinding::L3),
368
  BUTTON("R3", TRANSLATE_NOOP("AnalogJoystick", "R3"), ICON_PF_RIGHT_ANALOG_CLICK, AnalogJoystick::Button::R3, GenericInputBinding::R3),
369

370
  AXIS("LLeft", TRANSLATE_NOOP("AnalogJoystick", "Left Stick Left"), ICON_PF_LEFT_ANALOG_LEFT, AnalogJoystick::HalfAxis::LLeft, GenericInputBinding::LeftStickLeft),
371
  AXIS("LRight", TRANSLATE_NOOP("AnalogJoystick", "Left Stick Right"), ICON_PF_LEFT_ANALOG_RIGHT, AnalogJoystick::HalfAxis::LRight, GenericInputBinding::LeftStickRight),
372
  AXIS("LDown", TRANSLATE_NOOP("AnalogJoystick", "Left Stick Down"), ICON_PF_LEFT_ANALOG_DOWN, AnalogJoystick::HalfAxis::LDown, GenericInputBinding::LeftStickDown),
373
  AXIS("LUp", TRANSLATE_NOOP("AnalogJoystick", "Left Stick Up"), ICON_PF_LEFT_ANALOG_UP, AnalogJoystick::HalfAxis::LUp, GenericInputBinding::LeftStickUp),
374
  AXIS("RLeft", TRANSLATE_NOOP("AnalogJoystick", "Right Stick Left"), ICON_PF_RIGHT_ANALOG_LEFT, AnalogJoystick::HalfAxis::RLeft, GenericInputBinding::RightStickLeft),
375
  AXIS("RRight", TRANSLATE_NOOP("AnalogJoystick", "Right Stick Right"), ICON_PF_RIGHT_ANALOG_RIGHT, AnalogJoystick::HalfAxis::RRight, GenericInputBinding::RightStickRight),
376
  AXIS("RDown", TRANSLATE_NOOP("AnalogJoystick", "Right Stick Down"), ICON_PF_RIGHT_ANALOG_DOWN, AnalogJoystick::HalfAxis::RDown, GenericInputBinding::RightStickDown),
377
  AXIS("RUp", TRANSLATE_NOOP("AnalogJoystick", "Right Stick Up"), ICON_PF_RIGHT_ANALOG_UP, AnalogJoystick::HalfAxis::RUp, GenericInputBinding::RightStickUp),
378

379
  MODE_LED("ModeLED", TRANSLATE_NOOP("AnalogJoystick", "Mode LED"), ICON_PF_ANALOG_LEFT_RIGHT, 0, GenericInputBinding::ModeLED),
380
// clang-format on
381

382
#undef AXIS
383
#undef BUTTON
384
#undef MODE_LED
385
};
386

387
static constexpr const char* s_invert_settings[] = {
388
  TRANSLATE_NOOP("AnalogJoystick", "Not Inverted"), TRANSLATE_NOOP("AnalogJoystick", "Invert Left/Right"),
389
  TRANSLATE_NOOP("AnalogJoystick", "Invert Up/Down"), TRANSLATE_NOOP("AnalogJoystick", "Invert Left/Right + Up/Down"),
390
  nullptr};
391

392
static const SettingInfo s_settings[] = {
393
  {SettingInfo::Type::Float, "AnalogDeadzone", TRANSLATE_NOOP("AnalogJoystick", "Analog Deadzone"),
394
   TRANSLATE_NOOP("AnalogJoystick",
395
                  "Sets the analog stick deadzone, i.e. the fraction of the stick movement which will be ignored."),
396
   "0", "0", "1", "0.01", "%.0f%%", nullptr, 100.0f},
397
  {SettingInfo::Type::Float, "AnalogSensitivity", TRANSLATE_NOOP("AnalogJoystick", "Analog Sensitivity"),
398
   TRANSLATE_NOOP(
399
     "AnalogJoystick",
400
     "Sets the analog stick axis scaling factor. A value between 130% and 140% is recommended when using recent "
401
     "controllers, e.g. DualShock 4, Xbox One Controller."),
402
   "1.33", "0.01", "2", "0.01", "%.0f%%", nullptr, 100.0f},
403
  {SettingInfo::Type::IntegerList, "InvertLeftStick", TRANSLATE_NOOP("AnalogJoystick", "Invert Left Stick"),
404
   TRANSLATE_NOOP("AnalogJoystick", "Inverts the direction of the left analog stick."), "0", "0", "3", nullptr, nullptr,
405
   s_invert_settings, 0.0f},
406
  {SettingInfo::Type::IntegerList, "InvertRightStick", TRANSLATE_NOOP("AnalogJoystick", "Invert Right Stick"),
407
   TRANSLATE_NOOP("AnalogJoystick", "Inverts the direction of the right analog stick."), "0", "0", "3", nullptr,
408
   nullptr, s_invert_settings, 0.0f},
409
};
410

411
const Controller::ControllerInfo AnalogJoystick::INFO = {
412
  ControllerType::AnalogJoystick, "AnalogJoystick", TRANSLATE_NOOP("ControllerType", "Analog Joystick"),
413
  ICON_PF_FLIGHT_STICK,           s_binding_info,   s_settings};
414

415
void AnalogJoystick::LoadSettings(const SettingsInterface& si, const char* section, bool initial)
416
{
417
  Controller::LoadSettings(si, section, initial);
418
  m_analog_deadzone = std::clamp(si.GetFloatValue(section, "AnalogDeadzone", DEFAULT_STICK_DEADZONE), 0.0f, 1.0f);
419
  m_analog_sensitivity =
420
    std::clamp(si.GetFloatValue(section, "AnalogSensitivity", DEFAULT_STICK_SENSITIVITY), 0.01f, 3.0f);
421
  m_invert_left_stick = static_cast<u8>(si.GetIntValue(section, "InvertLeftStick", 0));
422
  m_invert_right_stick = static_cast<u8>(si.GetIntValue(section, "InvertRightStick", 0));
423
}
424

425