emulated_controller.cpp 48 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442
  1. // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  3. #include <algorithm>
  4. #include "common/polyfill_ranges.h"
  5. #include "common/thread.h"
  6. #include "core/hid/emulated_controller.h"
  7. #include "core/hid/input_converter.h"
  8. namespace Core::HID {
  9. constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
  10. constexpr s32 HID_TRIGGER_MAX = 0x7fff;
  11. EmulatedController::EmulatedController(NpadIdType npad_id_type_) : npad_id_type(npad_id_type_) {}
  12. EmulatedController::~EmulatedController() = default;
  13. NpadStyleIndex EmulatedController::MapSettingsTypeToNPad(Settings::ControllerType type) {
  14. switch (type) {
  15. case Settings::ControllerType::ProController:
  16. return NpadStyleIndex::ProController;
  17. case Settings::ControllerType::DualJoyconDetached:
  18. return NpadStyleIndex::JoyconDual;
  19. case Settings::ControllerType::LeftJoycon:
  20. return NpadStyleIndex::JoyconLeft;
  21. case Settings::ControllerType::RightJoycon:
  22. return NpadStyleIndex::JoyconRight;
  23. case Settings::ControllerType::Handheld:
  24. return NpadStyleIndex::Handheld;
  25. case Settings::ControllerType::GameCube:
  26. return NpadStyleIndex::GameCube;
  27. case Settings::ControllerType::Pokeball:
  28. return NpadStyleIndex::Pokeball;
  29. case Settings::ControllerType::NES:
  30. return NpadStyleIndex::NES;
  31. case Settings::ControllerType::SNES:
  32. return NpadStyleIndex::SNES;
  33. case Settings::ControllerType::N64:
  34. return NpadStyleIndex::N64;
  35. case Settings::ControllerType::SegaGenesis:
  36. return NpadStyleIndex::SegaGenesis;
  37. default:
  38. return NpadStyleIndex::ProController;
  39. }
  40. }
  41. Settings::ControllerType EmulatedController::MapNPadToSettingsType(NpadStyleIndex type) {
  42. switch (type) {
  43. case NpadStyleIndex::ProController:
  44. return Settings::ControllerType::ProController;
  45. case NpadStyleIndex::JoyconDual:
  46. return Settings::ControllerType::DualJoyconDetached;
  47. case NpadStyleIndex::JoyconLeft:
  48. return Settings::ControllerType::LeftJoycon;
  49. case NpadStyleIndex::JoyconRight:
  50. return Settings::ControllerType::RightJoycon;
  51. case NpadStyleIndex::Handheld:
  52. return Settings::ControllerType::Handheld;
  53. case NpadStyleIndex::GameCube:
  54. return Settings::ControllerType::GameCube;
  55. case NpadStyleIndex::Pokeball:
  56. return Settings::ControllerType::Pokeball;
  57. case NpadStyleIndex::NES:
  58. return Settings::ControllerType::NES;
  59. case NpadStyleIndex::SNES:
  60. return Settings::ControllerType::SNES;
  61. case NpadStyleIndex::N64:
  62. return Settings::ControllerType::N64;
  63. case NpadStyleIndex::SegaGenesis:
  64. return Settings::ControllerType::SegaGenesis;
  65. default:
  66. return Settings::ControllerType::ProController;
  67. }
  68. }
  69. void EmulatedController::ReloadFromSettings() {
  70. const auto player_index = NpadIdTypeToIndex(npad_id_type);
  71. const auto& player = Settings::values.players.GetValue()[player_index];
  72. for (std::size_t index = 0; index < player.buttons.size(); ++index) {
  73. button_params[index] = Common::ParamPackage(player.buttons[index]);
  74. }
  75. for (std::size_t index = 0; index < player.analogs.size(); ++index) {
  76. stick_params[index] = Common::ParamPackage(player.analogs[index]);
  77. }
  78. for (std::size_t index = 0; index < player.motions.size(); ++index) {
  79. motion_params[index] = Common::ParamPackage(player.motions[index]);
  80. }
  81. controller.colors_state.fullkey = {
  82. .body = GetNpadColor(player.body_color_left),
  83. .button = GetNpadColor(player.button_color_left),
  84. };
  85. controller.colors_state.left = {
  86. .body = GetNpadColor(player.body_color_left),
  87. .button = GetNpadColor(player.button_color_left),
  88. };
  89. controller.colors_state.right = {
  90. .body = GetNpadColor(player.body_color_right),
  91. .button = GetNpadColor(player.button_color_right),
  92. };
  93. // Other or debug controller should always be a pro controller
  94. if (npad_id_type != NpadIdType::Other) {
  95. SetNpadStyleIndex(MapSettingsTypeToNPad(player.controller_type));
  96. original_npad_type = npad_type;
  97. } else {
  98. SetNpadStyleIndex(NpadStyleIndex::ProController);
  99. original_npad_type = npad_type;
  100. }
  101. Disconnect();
  102. if (player.connected) {
  103. Connect();
  104. }
  105. ReloadInput();
  106. }
  107. void EmulatedController::LoadDevices() {
  108. // TODO(german77): Use more buttons to detect the correct device
  109. const auto left_joycon = button_params[Settings::NativeButton::DRight];
  110. const auto right_joycon = button_params[Settings::NativeButton::A];
  111. // Triggers for GC controllers
  112. trigger_params[LeftIndex] = button_params[Settings::NativeButton::ZL];
  113. trigger_params[RightIndex] = button_params[Settings::NativeButton::ZR];
  114. battery_params[LeftIndex] = left_joycon;
  115. battery_params[RightIndex] = right_joycon;
  116. battery_params[LeftIndex].Set("battery", true);
  117. battery_params[RightIndex].Set("battery", true);
  118. camera_params = Common::ParamPackage{"engine:camera,camera:1"};
  119. nfc_params = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
  120. output_params[LeftIndex] = left_joycon;
  121. output_params[RightIndex] = right_joycon;
  122. output_params[2] = camera_params;
  123. output_params[3] = nfc_params;
  124. output_params[LeftIndex].Set("output", true);
  125. output_params[RightIndex].Set("output", true);
  126. output_params[2].Set("output", true);
  127. output_params[3].Set("output", true);
  128. LoadTASParams();
  129. std::ranges::transform(button_params, button_devices.begin(), Common::Input::CreateInputDevice);
  130. std::ranges::transform(stick_params, stick_devices.begin(), Common::Input::CreateInputDevice);
  131. std::ranges::transform(motion_params, motion_devices.begin(), Common::Input::CreateInputDevice);
  132. std::ranges::transform(trigger_params, trigger_devices.begin(),
  133. Common::Input::CreateInputDevice);
  134. std::ranges::transform(battery_params, battery_devices.begin(),
  135. Common::Input::CreateInputDevice);
  136. camera_devices = Common::Input::CreateInputDevice(camera_params);
  137. nfc_devices = Common::Input::CreateInputDevice(nfc_params);
  138. std::ranges::transform(output_params, output_devices.begin(),
  139. Common::Input::CreateOutputDevice);
  140. // Initialize TAS devices
  141. std::ranges::transform(tas_button_params, tas_button_devices.begin(),
  142. Common::Input::CreateInputDevice);
  143. std::ranges::transform(tas_stick_params, tas_stick_devices.begin(),
  144. Common::Input::CreateInputDevice);
  145. }
  146. void EmulatedController::LoadTASParams() {
  147. const auto player_index = NpadIdTypeToIndex(npad_id_type);
  148. Common::ParamPackage common_params{};
  149. common_params.Set("engine", "tas");
  150. common_params.Set("port", static_cast<int>(player_index));
  151. for (auto& param : tas_button_params) {
  152. param = common_params;
  153. }
  154. for (auto& param : tas_stick_params) {
  155. param = common_params;
  156. }
  157. // TODO(german77): Replace this with an input profile or something better
  158. tas_button_params[Settings::NativeButton::A].Set("button", 0);
  159. tas_button_params[Settings::NativeButton::B].Set("button", 1);
  160. tas_button_params[Settings::NativeButton::X].Set("button", 2);
  161. tas_button_params[Settings::NativeButton::Y].Set("button", 3);
  162. tas_button_params[Settings::NativeButton::LStick].Set("button", 4);
  163. tas_button_params[Settings::NativeButton::RStick].Set("button", 5);
  164. tas_button_params[Settings::NativeButton::L].Set("button", 6);
  165. tas_button_params[Settings::NativeButton::R].Set("button", 7);
  166. tas_button_params[Settings::NativeButton::ZL].Set("button", 8);
  167. tas_button_params[Settings::NativeButton::ZR].Set("button", 9);
  168. tas_button_params[Settings::NativeButton::Plus].Set("button", 10);
  169. tas_button_params[Settings::NativeButton::Minus].Set("button", 11);
  170. tas_button_params[Settings::NativeButton::DLeft].Set("button", 12);
  171. tas_button_params[Settings::NativeButton::DUp].Set("button", 13);
  172. tas_button_params[Settings::NativeButton::DRight].Set("button", 14);
  173. tas_button_params[Settings::NativeButton::DDown].Set("button", 15);
  174. tas_button_params[Settings::NativeButton::SL].Set("button", 16);
  175. tas_button_params[Settings::NativeButton::SR].Set("button", 17);
  176. tas_button_params[Settings::NativeButton::Home].Set("button", 18);
  177. tas_button_params[Settings::NativeButton::Screenshot].Set("button", 19);
  178. tas_stick_params[Settings::NativeAnalog::LStick].Set("axis_x", 0);
  179. tas_stick_params[Settings::NativeAnalog::LStick].Set("axis_y", 1);
  180. tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_x", 2);
  181. tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
  182. }
  183. void EmulatedController::ReloadInput() {
  184. // If you load any device here add the equivalent to the UnloadInput() function
  185. LoadDevices();
  186. for (std::size_t index = 0; index < button_devices.size(); ++index) {
  187. if (!button_devices[index]) {
  188. continue;
  189. }
  190. const auto uuid = Common::UUID{button_params[index].Get("guid", "")};
  191. button_devices[index]->SetCallback({
  192. .on_change =
  193. [this, index, uuid](const Common::Input::CallbackStatus& callback) {
  194. SetButton(callback, index, uuid);
  195. },
  196. });
  197. button_devices[index]->ForceUpdate();
  198. }
  199. for (std::size_t index = 0; index < stick_devices.size(); ++index) {
  200. if (!stick_devices[index]) {
  201. continue;
  202. }
  203. const auto uuid = Common::UUID{stick_params[index].Get("guid", "")};
  204. stick_devices[index]->SetCallback({
  205. .on_change =
  206. [this, index, uuid](const Common::Input::CallbackStatus& callback) {
  207. SetStick(callback, index, uuid);
  208. },
  209. });
  210. stick_devices[index]->ForceUpdate();
  211. }
  212. for (std::size_t index = 0; index < trigger_devices.size(); ++index) {
  213. if (!trigger_devices[index]) {
  214. continue;
  215. }
  216. const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")};
  217. trigger_devices[index]->SetCallback({
  218. .on_change =
  219. [this, index, uuid](const Common::Input::CallbackStatus& callback) {
  220. SetTrigger(callback, index, uuid);
  221. },
  222. });
  223. trigger_devices[index]->ForceUpdate();
  224. }
  225. for (std::size_t index = 0; index < battery_devices.size(); ++index) {
  226. if (!battery_devices[index]) {
  227. continue;
  228. }
  229. battery_devices[index]->SetCallback({
  230. .on_change =
  231. [this, index](const Common::Input::CallbackStatus& callback) {
  232. SetBattery(callback, index);
  233. },
  234. });
  235. battery_devices[index]->ForceUpdate();
  236. }
  237. for (std::size_t index = 0; index < motion_devices.size(); ++index) {
  238. if (!motion_devices[index]) {
  239. continue;
  240. }
  241. motion_devices[index]->SetCallback({
  242. .on_change =
  243. [this, index](const Common::Input::CallbackStatus& callback) {
  244. SetMotion(callback, index);
  245. },
  246. });
  247. motion_devices[index]->ForceUpdate();
  248. }
  249. if (camera_devices) {
  250. camera_devices->SetCallback({
  251. .on_change =
  252. [this](const Common::Input::CallbackStatus& callback) { SetCamera(callback); },
  253. });
  254. camera_devices->ForceUpdate();
  255. }
  256. if (nfc_devices) {
  257. if (npad_id_type == NpadIdType::Handheld || npad_id_type == NpadIdType::Player1) {
  258. nfc_devices->SetCallback({
  259. .on_change =
  260. [this](const Common::Input::CallbackStatus& callback) { SetNfc(callback); },
  261. });
  262. nfc_devices->ForceUpdate();
  263. }
  264. }
  265. // Use a common UUID for TAS
  266. static constexpr Common::UUID TAS_UUID = Common::UUID{
  267. {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
  268. // Register TAS devices. No need to force update
  269. for (std::size_t index = 0; index < tas_button_devices.size(); ++index) {
  270. if (!tas_button_devices[index]) {
  271. continue;
  272. }
  273. tas_button_devices[index]->SetCallback({
  274. .on_change =
  275. [this, index](const Common::Input::CallbackStatus& callback) {
  276. SetButton(callback, index, TAS_UUID);
  277. },
  278. });
  279. }
  280. for (std::size_t index = 0; index < tas_stick_devices.size(); ++index) {
  281. if (!tas_stick_devices[index]) {
  282. continue;
  283. }
  284. tas_stick_devices[index]->SetCallback({
  285. .on_change =
  286. [this, index](const Common::Input::CallbackStatus& callback) {
  287. SetStick(callback, index, TAS_UUID);
  288. },
  289. });
  290. }
  291. }
  292. void EmulatedController::UnloadInput() {
  293. for (auto& button : button_devices) {
  294. button.reset();
  295. }
  296. for (auto& stick : stick_devices) {
  297. stick.reset();
  298. }
  299. for (auto& motion : motion_devices) {
  300. motion.reset();
  301. }
  302. for (auto& trigger : trigger_devices) {
  303. trigger.reset();
  304. }
  305. for (auto& battery : battery_devices) {
  306. battery.reset();
  307. }
  308. for (auto& output : output_devices) {
  309. output.reset();
  310. }
  311. for (auto& button : tas_button_devices) {
  312. button.reset();
  313. }
  314. for (auto& stick : tas_stick_devices) {
  315. stick.reset();
  316. }
  317. camera_devices.reset();
  318. nfc_devices.reset();
  319. }
  320. void EmulatedController::EnableConfiguration() {
  321. is_configuring = true;
  322. tmp_is_connected = is_connected;
  323. tmp_npad_type = npad_type;
  324. }
  325. void EmulatedController::DisableConfiguration() {
  326. is_configuring = false;
  327. // Apply temporary npad type to the real controller
  328. if (tmp_npad_type != npad_type) {
  329. if (is_connected) {
  330. Disconnect();
  331. }
  332. SetNpadStyleIndex(tmp_npad_type);
  333. original_npad_type = tmp_npad_type;
  334. }
  335. // Apply temporary connected status to the real controller
  336. if (tmp_is_connected != is_connected) {
  337. if (tmp_is_connected) {
  338. Connect();
  339. return;
  340. }
  341. Disconnect();
  342. }
  343. }
  344. void EmulatedController::EnableSystemButtons() {
  345. std::scoped_lock lock{mutex};
  346. system_buttons_enabled = true;
  347. }
  348. void EmulatedController::DisableSystemButtons() {
  349. std::scoped_lock lock{mutex};
  350. system_buttons_enabled = false;
  351. }
  352. void EmulatedController::ResetSystemButtons() {
  353. std::scoped_lock lock{mutex};
  354. controller.home_button_state.home.Assign(false);
  355. controller.capture_button_state.capture.Assign(false);
  356. }
  357. bool EmulatedController::IsConfiguring() const {
  358. return is_configuring;
  359. }
  360. void EmulatedController::SaveCurrentConfig() {
  361. const auto player_index = NpadIdTypeToIndex(npad_id_type);
  362. auto& player = Settings::values.players.GetValue()[player_index];
  363. player.connected = is_connected;
  364. player.controller_type = MapNPadToSettingsType(npad_type);
  365. for (std::size_t index = 0; index < player.buttons.size(); ++index) {
  366. player.buttons[index] = button_params[index].Serialize();
  367. }
  368. for (std::size_t index = 0; index < player.analogs.size(); ++index) {
  369. player.analogs[index] = stick_params[index].Serialize();
  370. }
  371. for (std::size_t index = 0; index < player.motions.size(); ++index) {
  372. player.motions[index] = motion_params[index].Serialize();
  373. }
  374. }
  375. void EmulatedController::RestoreConfig() {
  376. if (!is_configuring) {
  377. return;
  378. }
  379. ReloadFromSettings();
  380. }
  381. std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
  382. std::vector<Common::ParamPackage> devices;
  383. for (const auto& param : button_params) {
  384. if (!param.Has("engine")) {
  385. continue;
  386. }
  387. const auto devices_it = std::find_if(
  388. devices.begin(), devices.end(), [&param](const Common::ParamPackage& param_) {
  389. return param.Get("engine", "") == param_.Get("engine", "") &&
  390. param.Get("guid", "") == param_.Get("guid", "") &&
  391. param.Get("port", 0) == param_.Get("port", 0) &&
  392. param.Get("pad", 0) == param_.Get("pad", 0);
  393. });
  394. if (devices_it != devices.end()) {
  395. continue;
  396. }
  397. auto& device = devices.emplace_back();
  398. device.Set("engine", param.Get("engine", ""));
  399. device.Set("guid", param.Get("guid", ""));
  400. device.Set("port", param.Get("port", 0));
  401. device.Set("pad", param.Get("pad", 0));
  402. }
  403. for (const auto& param : stick_params) {
  404. if (!param.Has("engine")) {
  405. continue;
  406. }
  407. if (param.Get("engine", "") == "analog_from_button") {
  408. continue;
  409. }
  410. const auto devices_it = std::find_if(
  411. devices.begin(), devices.end(), [&param](const Common::ParamPackage& param_) {
  412. return param.Get("engine", "") == param_.Get("engine", "") &&
  413. param.Get("guid", "") == param_.Get("guid", "") &&
  414. param.Get("port", 0) == param_.Get("port", 0) &&
  415. param.Get("pad", 0) == param_.Get("pad", 0);
  416. });
  417. if (devices_it != devices.end()) {
  418. continue;
  419. }
  420. auto& device = devices.emplace_back();
  421. device.Set("engine", param.Get("engine", ""));
  422. device.Set("guid", param.Get("guid", ""));
  423. device.Set("port", param.Get("port", 0));
  424. device.Set("pad", param.Get("pad", 0));
  425. }
  426. return devices;
  427. }
  428. Common::ParamPackage EmulatedController::GetButtonParam(std::size_t index) const {
  429. if (index >= button_params.size()) {
  430. return {};
  431. }
  432. return button_params[index];
  433. }
  434. Common::ParamPackage EmulatedController::GetStickParam(std::size_t index) const {
  435. if (index >= stick_params.size()) {
  436. return {};
  437. }
  438. return stick_params[index];
  439. }
  440. Common::ParamPackage EmulatedController::GetMotionParam(std::size_t index) const {
  441. if (index >= motion_params.size()) {
  442. return {};
  443. }
  444. return motion_params[index];
  445. }
  446. void EmulatedController::SetButtonParam(std::size_t index, Common::ParamPackage param) {
  447. if (index >= button_params.size()) {
  448. return;
  449. }
  450. button_params[index] = std::move(param);
  451. ReloadInput();
  452. }
  453. void EmulatedController::SetStickParam(std::size_t index, Common::ParamPackage param) {
  454. if (index >= stick_params.size()) {
  455. return;
  456. }
  457. stick_params[index] = std::move(param);
  458. ReloadInput();
  459. }
  460. void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage param) {
  461. if (index >= motion_params.size()) {
  462. return;
  463. }
  464. motion_params[index] = std::move(param);
  465. ReloadInput();
  466. }
  467. void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
  468. Common::UUID uuid) {
  469. if (index >= controller.button_values.size()) {
  470. return;
  471. }
  472. std::unique_lock lock{mutex};
  473. bool value_changed = false;
  474. const auto new_status = TransformToButton(callback);
  475. auto& current_status = controller.button_values[index];
  476. // Only read button values that have the same uuid or are pressed once
  477. if (current_status.uuid != uuid) {
  478. if (!new_status.value) {
  479. return;
  480. }
  481. }
  482. current_status.toggle = new_status.toggle;
  483. current_status.uuid = uuid;
  484. // Update button status with current
  485. if (!current_status.toggle) {
  486. current_status.locked = false;
  487. if (current_status.value != new_status.value) {
  488. current_status.value = new_status.value;
  489. value_changed = true;
  490. }
  491. } else {
  492. // Toggle button and lock status
  493. if (new_status.value && !current_status.locked) {
  494. current_status.locked = true;
  495. current_status.value = !current_status.value;
  496. value_changed = true;
  497. }
  498. // Unlock button ready for next press
  499. if (!new_status.value && current_status.locked) {
  500. current_status.locked = false;
  501. }
  502. }
  503. if (!value_changed) {
  504. return;
  505. }
  506. if (is_configuring) {
  507. controller.npad_button_state.raw = NpadButton::None;
  508. controller.debug_pad_button_state.raw = 0;
  509. lock.unlock();
  510. TriggerOnChange(ControllerTriggerType::Button, false);
  511. return;
  512. }
  513. // GC controllers have triggers not buttons
  514. if (npad_type == NpadStyleIndex::GameCube) {
  515. if (index == Settings::NativeButton::ZR) {
  516. return;
  517. }
  518. if (index == Settings::NativeButton::ZL) {
  519. return;
  520. }
  521. }
  522. switch (index) {
  523. case Settings::NativeButton::A:
  524. controller.npad_button_state.a.Assign(current_status.value);
  525. controller.debug_pad_button_state.a.Assign(current_status.value);
  526. break;
  527. case Settings::NativeButton::B:
  528. controller.npad_button_state.b.Assign(current_status.value);
  529. controller.debug_pad_button_state.b.Assign(current_status.value);
  530. break;
  531. case Settings::NativeButton::X:
  532. controller.npad_button_state.x.Assign(current_status.value);
  533. controller.debug_pad_button_state.x.Assign(current_status.value);
  534. break;
  535. case Settings::NativeButton::Y:
  536. controller.npad_button_state.y.Assign(current_status.value);
  537. controller.debug_pad_button_state.y.Assign(current_status.value);
  538. break;
  539. case Settings::NativeButton::LStick:
  540. controller.npad_button_state.stick_l.Assign(current_status.value);
  541. break;
  542. case Settings::NativeButton::RStick:
  543. controller.npad_button_state.stick_r.Assign(current_status.value);
  544. break;
  545. case Settings::NativeButton::L:
  546. controller.npad_button_state.l.Assign(current_status.value);
  547. controller.debug_pad_button_state.l.Assign(current_status.value);
  548. break;
  549. case Settings::NativeButton::R:
  550. controller.npad_button_state.r.Assign(current_status.value);
  551. controller.debug_pad_button_state.r.Assign(current_status.value);
  552. break;
  553. case Settings::NativeButton::ZL:
  554. controller.npad_button_state.zl.Assign(current_status.value);
  555. controller.debug_pad_button_state.zl.Assign(current_status.value);
  556. break;
  557. case Settings::NativeButton::ZR:
  558. controller.npad_button_state.zr.Assign(current_status.value);
  559. controller.debug_pad_button_state.zr.Assign(current_status.value);
  560. break;
  561. case Settings::NativeButton::Plus:
  562. controller.npad_button_state.plus.Assign(current_status.value);
  563. controller.debug_pad_button_state.plus.Assign(current_status.value);
  564. break;
  565. case Settings::NativeButton::Minus:
  566. controller.npad_button_state.minus.Assign(current_status.value);
  567. controller.debug_pad_button_state.minus.Assign(current_status.value);
  568. break;
  569. case Settings::NativeButton::DLeft:
  570. controller.npad_button_state.left.Assign(current_status.value);
  571. controller.debug_pad_button_state.d_left.Assign(current_status.value);
  572. break;
  573. case Settings::NativeButton::DUp:
  574. controller.npad_button_state.up.Assign(current_status.value);
  575. controller.debug_pad_button_state.d_up.Assign(current_status.value);
  576. break;
  577. case Settings::NativeButton::DRight:
  578. controller.npad_button_state.right.Assign(current_status.value);
  579. controller.debug_pad_button_state.d_right.Assign(current_status.value);
  580. break;
  581. case Settings::NativeButton::DDown:
  582. controller.npad_button_state.down.Assign(current_status.value);
  583. controller.debug_pad_button_state.d_down.Assign(current_status.value);
  584. break;
  585. case Settings::NativeButton::SL:
  586. controller.npad_button_state.left_sl.Assign(current_status.value);
  587. controller.npad_button_state.right_sl.Assign(current_status.value);
  588. break;
  589. case Settings::NativeButton::SR:
  590. controller.npad_button_state.left_sr.Assign(current_status.value);
  591. controller.npad_button_state.right_sr.Assign(current_status.value);
  592. break;
  593. case Settings::NativeButton::Home:
  594. if (!system_buttons_enabled) {
  595. break;
  596. }
  597. controller.home_button_state.home.Assign(current_status.value);
  598. break;
  599. case Settings::NativeButton::Screenshot:
  600. if (!system_buttons_enabled) {
  601. break;
  602. }
  603. controller.capture_button_state.capture.Assign(current_status.value);
  604. break;
  605. }
  606. lock.unlock();
  607. if (!is_connected) {
  608. if (npad_id_type == NpadIdType::Player1 && npad_type != NpadStyleIndex::Handheld) {
  609. Connect();
  610. }
  611. if (npad_id_type == NpadIdType::Handheld && npad_type == NpadStyleIndex::Handheld) {
  612. Connect();
  613. }
  614. }
  615. TriggerOnChange(ControllerTriggerType::Button, true);
  616. }
  617. void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
  618. Common::UUID uuid) {
  619. if (index >= controller.stick_values.size()) {
  620. return;
  621. }
  622. std::unique_lock lock{mutex};
  623. const auto stick_value = TransformToStick(callback);
  624. // Only read stick values that have the same uuid or are over the threshold to avoid flapping
  625. if (controller.stick_values[index].uuid != uuid) {
  626. if (!stick_value.down && !stick_value.up && !stick_value.left && !stick_value.right) {
  627. return;
  628. }
  629. }
  630. controller.stick_values[index] = stick_value;
  631. controller.stick_values[index].uuid = uuid;
  632. if (is_configuring) {
  633. controller.analog_stick_state.left = {};
  634. controller.analog_stick_state.right = {};
  635. lock.unlock();
  636. TriggerOnChange(ControllerTriggerType::Stick, false);
  637. return;
  638. }
  639. const AnalogStickState stick{
  640. .x = static_cast<s32>(controller.stick_values[index].x.value * HID_JOYSTICK_MAX),
  641. .y = static_cast<s32>(controller.stick_values[index].y.value * HID_JOYSTICK_MAX),
  642. };
  643. switch (index) {
  644. case Settings::NativeAnalog::LStick:
  645. controller.analog_stick_state.left = stick;
  646. controller.npad_button_state.stick_l_left.Assign(controller.stick_values[index].left);
  647. controller.npad_button_state.stick_l_up.Assign(controller.stick_values[index].up);
  648. controller.npad_button_state.stick_l_right.Assign(controller.stick_values[index].right);
  649. controller.npad_button_state.stick_l_down.Assign(controller.stick_values[index].down);
  650. break;
  651. case Settings::NativeAnalog::RStick:
  652. controller.analog_stick_state.right = stick;
  653. controller.npad_button_state.stick_r_left.Assign(controller.stick_values[index].left);
  654. controller.npad_button_state.stick_r_up.Assign(controller.stick_values[index].up);
  655. controller.npad_button_state.stick_r_right.Assign(controller.stick_values[index].right);
  656. controller.npad_button_state.stick_r_down.Assign(controller.stick_values[index].down);
  657. break;
  658. }
  659. lock.unlock();
  660. TriggerOnChange(ControllerTriggerType::Stick, true);
  661. }
  662. void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callback,
  663. std::size_t index, Common::UUID uuid) {
  664. if (index >= controller.trigger_values.size()) {
  665. return;
  666. }
  667. std::unique_lock lock{mutex};
  668. const auto trigger_value = TransformToTrigger(callback);
  669. // Only read trigger values that have the same uuid or are pressed once
  670. if (controller.trigger_values[index].uuid != uuid) {
  671. if (!trigger_value.pressed.value) {
  672. return;
  673. }
  674. }
  675. controller.trigger_values[index] = trigger_value;
  676. controller.trigger_values[index].uuid = uuid;
  677. if (is_configuring) {
  678. controller.gc_trigger_state.left = 0;
  679. controller.gc_trigger_state.right = 0;
  680. lock.unlock();
  681. TriggerOnChange(ControllerTriggerType::Trigger, false);
  682. return;
  683. }
  684. // Only GC controllers have analog triggers
  685. if (npad_type != NpadStyleIndex::GameCube) {
  686. return;
  687. }
  688. const auto& trigger = controller.trigger_values[index];
  689. switch (index) {
  690. case Settings::NativeTrigger::LTrigger:
  691. controller.gc_trigger_state.left = static_cast<s32>(trigger.analog.value * HID_TRIGGER_MAX);
  692. controller.npad_button_state.zl.Assign(trigger.pressed.value);
  693. break;
  694. case Settings::NativeTrigger::RTrigger:
  695. controller.gc_trigger_state.right =
  696. static_cast<s32>(trigger.analog.value * HID_TRIGGER_MAX);
  697. controller.npad_button_state.zr.Assign(trigger.pressed.value);
  698. break;
  699. }
  700. lock.unlock();
  701. TriggerOnChange(ControllerTriggerType::Trigger, true);
  702. }
  703. void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback,
  704. std::size_t index) {
  705. if (index >= controller.motion_values.size()) {
  706. return;
  707. }
  708. std::unique_lock lock{mutex};
  709. auto& raw_status = controller.motion_values[index].raw_status;
  710. auto& emulated = controller.motion_values[index].emulated;
  711. raw_status = TransformToMotion(callback);
  712. emulated.SetAcceleration(Common::Vec3f{
  713. raw_status.accel.x.value,
  714. raw_status.accel.y.value,
  715. raw_status.accel.z.value,
  716. });
  717. emulated.SetGyroscope(Common::Vec3f{
  718. raw_status.gyro.x.value,
  719. raw_status.gyro.y.value,
  720. raw_status.gyro.z.value,
  721. });
  722. emulated.SetGyroThreshold(raw_status.gyro.x.properties.threshold);
  723. emulated.UpdateRotation(raw_status.delta_timestamp);
  724. emulated.UpdateOrientation(raw_status.delta_timestamp);
  725. force_update_motion = raw_status.force_update;
  726. if (is_configuring) {
  727. lock.unlock();
  728. TriggerOnChange(ControllerTriggerType::Motion, false);
  729. return;
  730. }
  731. auto& motion = controller.motion_state[index];
  732. motion.accel = emulated.GetAcceleration();
  733. motion.gyro = emulated.GetGyroscope();
  734. motion.rotation = emulated.GetRotations();
  735. motion.orientation = emulated.GetOrientation();
  736. motion.is_at_rest = !emulated.IsMoving(motion_sensitivity);
  737. lock.unlock();
  738. TriggerOnChange(ControllerTriggerType::Motion, true);
  739. }
  740. void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callback,
  741. std::size_t index) {
  742. if (index >= controller.battery_values.size()) {
  743. return;
  744. }
  745. std::unique_lock lock{mutex};
  746. controller.battery_values[index] = TransformToBattery(callback);
  747. if (is_configuring) {
  748. lock.unlock();
  749. TriggerOnChange(ControllerTriggerType::Battery, false);
  750. return;
  751. }
  752. bool is_charging = false;
  753. bool is_powered = false;
  754. NpadBatteryLevel battery_level = 0;
  755. switch (controller.battery_values[index]) {
  756. case Common::Input::BatteryLevel::Charging:
  757. is_charging = true;
  758. is_powered = true;
  759. battery_level = 6;
  760. break;
  761. case Common::Input::BatteryLevel::Medium:
  762. battery_level = 6;
  763. break;
  764. case Common::Input::BatteryLevel::Low:
  765. battery_level = 4;
  766. break;
  767. case Common::Input::BatteryLevel::Critical:
  768. battery_level = 2;
  769. break;
  770. case Common::Input::BatteryLevel::Empty:
  771. battery_level = 0;
  772. break;
  773. case Common::Input::BatteryLevel::None:
  774. case Common::Input::BatteryLevel::Full:
  775. default:
  776. is_powered = true;
  777. battery_level = 8;
  778. break;
  779. }
  780. switch (index) {
  781. case LeftIndex:
  782. controller.battery_state.left = {
  783. .is_powered = is_powered,
  784. .is_charging = is_charging,
  785. .battery_level = battery_level,
  786. };
  787. break;
  788. case RightIndex:
  789. controller.battery_state.right = {
  790. .is_powered = is_powered,
  791. .is_charging = is_charging,
  792. .battery_level = battery_level,
  793. };
  794. break;
  795. case DualIndex:
  796. controller.battery_state.dual = {
  797. .is_powered = is_powered,
  798. .is_charging = is_charging,
  799. .battery_level = battery_level,
  800. };
  801. break;
  802. }
  803. lock.unlock();
  804. TriggerOnChange(ControllerTriggerType::Battery, true);
  805. }
  806. void EmulatedController::SetCamera(const Common::Input::CallbackStatus& callback) {
  807. std::unique_lock lock{mutex};
  808. controller.camera_values = TransformToCamera(callback);
  809. if (is_configuring) {
  810. lock.unlock();
  811. TriggerOnChange(ControllerTriggerType::IrSensor, false);
  812. return;
  813. }
  814. controller.camera_state.sample++;
  815. controller.camera_state.format =
  816. static_cast<Core::IrSensor::ImageTransferProcessorFormat>(controller.camera_values.format);
  817. controller.camera_state.data = controller.camera_values.data;
  818. lock.unlock();
  819. TriggerOnChange(ControllerTriggerType::IrSensor, true);
  820. }
  821. void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {
  822. std::unique_lock lock{mutex};
  823. controller.nfc_values = TransformToNfc(callback);
  824. if (is_configuring) {
  825. lock.unlock();
  826. TriggerOnChange(ControllerTriggerType::Nfc, false);
  827. return;
  828. }
  829. controller.nfc_state = {
  830. controller.nfc_values.state,
  831. controller.nfc_values.data,
  832. };
  833. lock.unlock();
  834. TriggerOnChange(ControllerTriggerType::Nfc, true);
  835. }
  836. bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue vibration) {
  837. if (device_index >= output_devices.size()) {
  838. return false;
  839. }
  840. if (!output_devices[device_index]) {
  841. return false;
  842. }
  843. const auto player_index = NpadIdTypeToIndex(npad_id_type);
  844. const auto& player = Settings::values.players.GetValue()[player_index];
  845. const f32 strength = static_cast<f32>(player.vibration_strength) / 100.0f;
  846. if (!player.vibration_enabled) {
  847. return false;
  848. }
  849. // Exponential amplification is too strong at low amplitudes. Switch to a linear
  850. // amplification if strength is set below 0.7f
  851. const Common::Input::VibrationAmplificationType type =
  852. strength > 0.7f ? Common::Input::VibrationAmplificationType::Exponential
  853. : Common::Input::VibrationAmplificationType::Linear;
  854. const Common::Input::VibrationStatus status = {
  855. .low_amplitude = std::min(vibration.low_amplitude * strength, 1.0f),
  856. .low_frequency = vibration.low_frequency,
  857. .high_amplitude = std::min(vibration.high_amplitude * strength, 1.0f),
  858. .high_frequency = vibration.high_frequency,
  859. .type = type,
  860. };
  861. return output_devices[device_index]->SetVibration(status) ==
  862. Common::Input::VibrationError::None;
  863. }
  864. bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
  865. const auto player_index = NpadIdTypeToIndex(npad_id_type);
  866. const auto& player = Settings::values.players.GetValue()[player_index];
  867. if (!player.vibration_enabled) {
  868. return false;
  869. }
  870. if (device_index >= output_devices.size()) {
  871. return false;
  872. }
  873. if (!output_devices[device_index]) {
  874. return false;
  875. }
  876. return output_devices[device_index]->IsVibrationEnabled();
  877. }
  878. bool EmulatedController::SetPollingMode(Common::Input::PollingMode polling_mode) {
  879. LOG_INFO(Service_HID, "Set polling mode {}", polling_mode);
  880. auto& output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
  881. auto& nfc_output_device = output_devices[3];
  882. const auto virtual_nfc_result = nfc_output_device->SetPollingMode(polling_mode);
  883. const auto mapped_nfc_result = output_device->SetPollingMode(polling_mode);
  884. return virtual_nfc_result == Common::Input::PollingError::None ||
  885. mapped_nfc_result == Common::Input::PollingError::None;
  886. }
  887. bool EmulatedController::SetCameraFormat(
  888. Core::IrSensor::ImageTransferProcessorFormat camera_format) {
  889. LOG_INFO(Service_HID, "Set camera format {}", camera_format);
  890. auto& right_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
  891. auto& camera_output_device = output_devices[2];
  892. if (right_output_device->SetCameraFormat(static_cast<Common::Input::CameraFormat>(
  893. camera_format)) == Common::Input::CameraError::None) {
  894. return true;
  895. }
  896. // Fallback to Qt camera if native device doesn't have support
  897. return camera_output_device->SetCameraFormat(static_cast<Common::Input::CameraFormat>(
  898. camera_format)) == Common::Input::CameraError::None;
  899. }
  900. bool EmulatedController::HasNfc() const {
  901. const auto& nfc_output_device = output_devices[3];
  902. switch (npad_type) {
  903. case NpadStyleIndex::JoyconRight:
  904. case NpadStyleIndex::JoyconDual:
  905. case NpadStyleIndex::ProController:
  906. case NpadStyleIndex::Handheld:
  907. break;
  908. default:
  909. return false;
  910. }
  911. const bool has_virtual_nfc =
  912. npad_id_type == NpadIdType::Player1 || npad_id_type == NpadIdType::Handheld;
  913. const bool is_virtual_nfc_supported =
  914. nfc_output_device->SupportsNfc() != Common::Input::NfcState::NotSupported;
  915. return is_connected && (has_virtual_nfc && is_virtual_nfc_supported);
  916. }
  917. bool EmulatedController::WriteNfc(const std::vector<u8>& data) {
  918. auto& nfc_output_device = output_devices[3];
  919. return nfc_output_device->WriteNfcData(data) == Common::Input::NfcState::Success;
  920. }
  921. void EmulatedController::SetLedPattern() {
  922. for (auto& device : output_devices) {
  923. if (!device) {
  924. continue;
  925. }
  926. const LedPattern pattern = GetLedPattern();
  927. const Common::Input::LedStatus status = {
  928. .led_1 = pattern.position1 != 0,
  929. .led_2 = pattern.position2 != 0,
  930. .led_3 = pattern.position3 != 0,
  931. .led_4 = pattern.position4 != 0,
  932. };
  933. device->SetLED(status);
  934. }
  935. }
  936. void EmulatedController::SetSupportedNpadStyleTag(NpadStyleTag supported_styles) {
  937. supported_style_tag = supported_styles;
  938. if (!is_connected) {
  939. return;
  940. }
  941. // Attempt to reconnect with the original type
  942. if (npad_type != original_npad_type) {
  943. Disconnect();
  944. const auto current_npad_type = npad_type;
  945. SetNpadStyleIndex(original_npad_type);
  946. if (IsControllerSupported()) {
  947. Connect();
  948. return;
  949. }
  950. SetNpadStyleIndex(current_npad_type);
  951. Connect();
  952. }
  953. if (IsControllerSupported()) {
  954. return;
  955. }
  956. Disconnect();
  957. // Fallback Fullkey controllers to Pro controllers
  958. if (IsControllerFullkey() && supported_style_tag.fullkey) {
  959. LOG_WARNING(Service_HID, "Reconnecting controller type {} as Pro controller", npad_type);
  960. SetNpadStyleIndex(NpadStyleIndex::ProController);
  961. Connect();
  962. return;
  963. }
  964. // Fallback Dual joycon controllers to Pro controllers
  965. if (npad_type == NpadStyleIndex::JoyconDual && supported_style_tag.fullkey) {
  966. LOG_WARNING(Service_HID, "Reconnecting controller type {} as Pro controller", npad_type);
  967. SetNpadStyleIndex(NpadStyleIndex::ProController);
  968. Connect();
  969. return;
  970. }
  971. // Fallback Pro controllers to Dual joycon
  972. if (npad_type == NpadStyleIndex::ProController && supported_style_tag.joycon_dual) {
  973. LOG_WARNING(Service_HID, "Reconnecting controller type {} as Dual Joycons", npad_type);
  974. SetNpadStyleIndex(NpadStyleIndex::JoyconDual);
  975. Connect();
  976. return;
  977. }
  978. LOG_ERROR(Service_HID, "Controller type {} is not supported. Disconnecting controller",
  979. npad_type);
  980. }
  981. bool EmulatedController::IsControllerFullkey(bool use_temporary_value) const {
  982. std::scoped_lock lock{mutex};
  983. const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
  984. switch (type) {
  985. case NpadStyleIndex::ProController:
  986. case NpadStyleIndex::GameCube:
  987. case NpadStyleIndex::NES:
  988. case NpadStyleIndex::SNES:
  989. case NpadStyleIndex::N64:
  990. case NpadStyleIndex::SegaGenesis:
  991. return true;
  992. default:
  993. return false;
  994. }
  995. }
  996. bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
  997. std::scoped_lock lock{mutex};
  998. const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
  999. switch (type) {
  1000. case NpadStyleIndex::ProController:
  1001. return supported_style_tag.fullkey.As<bool>();
  1002. case NpadStyleIndex::Handheld:
  1003. return supported_style_tag.handheld.As<bool>();
  1004. case NpadStyleIndex::JoyconDual:
  1005. return supported_style_tag.joycon_dual.As<bool>();
  1006. case NpadStyleIndex::JoyconLeft:
  1007. return supported_style_tag.joycon_left.As<bool>();
  1008. case NpadStyleIndex::JoyconRight:
  1009. return supported_style_tag.joycon_right.As<bool>();
  1010. case NpadStyleIndex::GameCube:
  1011. return supported_style_tag.gamecube.As<bool>();
  1012. case NpadStyleIndex::Pokeball:
  1013. return supported_style_tag.palma.As<bool>();
  1014. case NpadStyleIndex::NES:
  1015. return supported_style_tag.lark.As<bool>();
  1016. case NpadStyleIndex::SNES:
  1017. return supported_style_tag.lucia.As<bool>();
  1018. case NpadStyleIndex::N64:
  1019. return supported_style_tag.lagoon.As<bool>();
  1020. case NpadStyleIndex::SegaGenesis:
  1021. return supported_style_tag.lager.As<bool>();
  1022. default:
  1023. return false;
  1024. }
  1025. }
  1026. void EmulatedController::Connect(bool use_temporary_value) {
  1027. if (!IsControllerSupported(use_temporary_value)) {
  1028. const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
  1029. LOG_ERROR(Service_HID, "Controller type {} is not supported", type);
  1030. return;
  1031. }
  1032. std::unique_lock lock{mutex};
  1033. if (is_configuring) {
  1034. tmp_is_connected = true;
  1035. lock.unlock();
  1036. TriggerOnChange(ControllerTriggerType::Connected, false);
  1037. return;
  1038. }
  1039. if (is_connected) {
  1040. return;
  1041. }
  1042. is_connected = true;
  1043. lock.unlock();
  1044. TriggerOnChange(ControllerTriggerType::Connected, true);
  1045. }
  1046. void EmulatedController::Disconnect() {
  1047. std::unique_lock lock{mutex};
  1048. if (is_configuring) {
  1049. tmp_is_connected = false;
  1050. lock.unlock();
  1051. TriggerOnChange(ControllerTriggerType::Disconnected, false);
  1052. return;
  1053. }
  1054. if (!is_connected) {
  1055. return;
  1056. }
  1057. is_connected = false;
  1058. lock.unlock();
  1059. TriggerOnChange(ControllerTriggerType::Disconnected, true);
  1060. }
  1061. bool EmulatedController::IsConnected(bool get_temporary_value) const {
  1062. std::scoped_lock lock{mutex};
  1063. if (get_temporary_value && is_configuring) {
  1064. return tmp_is_connected;
  1065. }
  1066. return is_connected;
  1067. }
  1068. NpadIdType EmulatedController::GetNpadIdType() const {
  1069. std::scoped_lock lock{mutex};
  1070. return npad_id_type;
  1071. }
  1072. NpadStyleIndex EmulatedController::GetNpadStyleIndex(bool get_temporary_value) const {
  1073. std::scoped_lock lock{mutex};
  1074. if (get_temporary_value && is_configuring) {
  1075. return tmp_npad_type;
  1076. }
  1077. return npad_type;
  1078. }
  1079. void EmulatedController::SetNpadStyleIndex(NpadStyleIndex npad_type_) {
  1080. std::unique_lock lock{mutex};
  1081. if (is_configuring) {
  1082. if (tmp_npad_type == npad_type_) {
  1083. return;
  1084. }
  1085. tmp_npad_type = npad_type_;
  1086. lock.unlock();
  1087. TriggerOnChange(ControllerTriggerType::Type, false);
  1088. return;
  1089. }
  1090. if (npad_type == npad_type_) {
  1091. return;
  1092. }
  1093. if (is_connected) {
  1094. LOG_WARNING(Service_HID, "Controller {} type changed while it's connected",
  1095. NpadIdTypeToIndex(npad_id_type));
  1096. }
  1097. npad_type = npad_type_;
  1098. lock.unlock();
  1099. TriggerOnChange(ControllerTriggerType::Type, true);
  1100. }
  1101. LedPattern EmulatedController::GetLedPattern() const {
  1102. switch (npad_id_type) {
  1103. case NpadIdType::Player1:
  1104. return LedPattern{1, 0, 0, 0};
  1105. case NpadIdType::Player2:
  1106. return LedPattern{1, 1, 0, 0};
  1107. case NpadIdType::Player3:
  1108. return LedPattern{1, 1, 1, 0};
  1109. case NpadIdType::Player4:
  1110. return LedPattern{1, 1, 1, 1};
  1111. case NpadIdType::Player5:
  1112. return LedPattern{1, 0, 0, 1};
  1113. case NpadIdType::Player6:
  1114. return LedPattern{1, 0, 1, 0};
  1115. case NpadIdType::Player7:
  1116. return LedPattern{1, 0, 1, 1};
  1117. case NpadIdType::Player8:
  1118. return LedPattern{0, 1, 1, 0};
  1119. default:
  1120. return LedPattern{0, 0, 0, 0};
  1121. }
  1122. }
  1123. ButtonValues EmulatedController::GetButtonsValues() const {
  1124. std::scoped_lock lock{mutex};
  1125. return controller.button_values;
  1126. }
  1127. SticksValues EmulatedController::GetSticksValues() const {
  1128. std::scoped_lock lock{mutex};
  1129. return controller.stick_values;
  1130. }
  1131. TriggerValues EmulatedController::GetTriggersValues() const {
  1132. std::scoped_lock lock{mutex};
  1133. return controller.trigger_values;
  1134. }
  1135. ControllerMotionValues EmulatedController::GetMotionValues() const {
  1136. std::scoped_lock lock{mutex};
  1137. return controller.motion_values;
  1138. }
  1139. ColorValues EmulatedController::GetColorsValues() const {
  1140. std::scoped_lock lock{mutex};
  1141. return controller.color_values;
  1142. }
  1143. BatteryValues EmulatedController::GetBatteryValues() const {
  1144. std::scoped_lock lock{mutex};
  1145. return controller.battery_values;
  1146. }
  1147. CameraValues EmulatedController::GetCameraValues() const {
  1148. std::scoped_lock lock{mutex};
  1149. return controller.camera_values;
  1150. }
  1151. HomeButtonState EmulatedController::GetHomeButtons() const {
  1152. std::scoped_lock lock{mutex};
  1153. if (is_configuring) {
  1154. return {};
  1155. }
  1156. return controller.home_button_state;
  1157. }
  1158. CaptureButtonState EmulatedController::GetCaptureButtons() const {
  1159. std::scoped_lock lock{mutex};
  1160. if (is_configuring) {
  1161. return {};
  1162. }
  1163. return controller.capture_button_state;
  1164. }
  1165. NpadButtonState EmulatedController::GetNpadButtons() const {
  1166. std::scoped_lock lock{mutex};
  1167. if (is_configuring) {
  1168. return {};
  1169. }
  1170. return controller.npad_button_state;
  1171. }
  1172. DebugPadButton EmulatedController::GetDebugPadButtons() const {
  1173. std::scoped_lock lock{mutex};
  1174. if (is_configuring) {
  1175. return {};
  1176. }
  1177. return controller.debug_pad_button_state;
  1178. }
  1179. AnalogSticks EmulatedController::GetSticks() const {
  1180. std::unique_lock lock{mutex};
  1181. if (is_configuring) {
  1182. return {};
  1183. }
  1184. // Some drivers like stick from buttons need constant refreshing
  1185. for (auto& device : stick_devices) {
  1186. if (!device) {
  1187. continue;
  1188. }
  1189. lock.unlock();
  1190. device->SoftUpdate();
  1191. lock.lock();
  1192. }
  1193. return controller.analog_stick_state;
  1194. }
  1195. NpadGcTriggerState EmulatedController::GetTriggers() const {
  1196. std::scoped_lock lock{mutex};
  1197. if (is_configuring) {
  1198. return {};
  1199. }
  1200. return controller.gc_trigger_state;
  1201. }
  1202. MotionState EmulatedController::GetMotions() const {
  1203. std::unique_lock lock{mutex};
  1204. // Some drivers like mouse motion need constant refreshing
  1205. if (force_update_motion) {
  1206. for (auto& device : motion_devices) {
  1207. if (!device) {
  1208. continue;
  1209. }
  1210. lock.unlock();
  1211. device->ForceUpdate();
  1212. lock.lock();
  1213. }
  1214. }
  1215. return controller.motion_state;
  1216. }
  1217. ControllerColors EmulatedController::GetColors() const {
  1218. std::scoped_lock lock{mutex};
  1219. return controller.colors_state;
  1220. }
  1221. BatteryLevelState EmulatedController::GetBattery() const {
  1222. std::scoped_lock lock{mutex};
  1223. return controller.battery_state;
  1224. }
  1225. const CameraState& EmulatedController::GetCamera() const {
  1226. std::scoped_lock lock{mutex};
  1227. return controller.camera_state;
  1228. }
  1229. const NfcState& EmulatedController::GetNfc() const {
  1230. std::scoped_lock lock{mutex};
  1231. return controller.nfc_state;
  1232. }
  1233. NpadColor EmulatedController::GetNpadColor(u32 color) {
  1234. return {
  1235. .r = static_cast<u8>((color >> 16) & 0xFF),
  1236. .g = static_cast<u8>((color >> 8) & 0xFF),
  1237. .b = static_cast<u8>(color & 0xFF),
  1238. .a = 0xff,
  1239. };
  1240. }
  1241. void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npad_service_update) {
  1242. std::scoped_lock lock{callback_mutex};
  1243. for (const auto& poller_pair : callback_list) {
  1244. const ControllerUpdateCallback& poller = poller_pair.second;
  1245. if (!is_npad_service_update && poller.is_npad_service) {
  1246. continue;
  1247. }
  1248. if (poller.on_change) {
  1249. poller.on_change(type);
  1250. }
  1251. }
  1252. }
  1253. int EmulatedController::SetCallback(ControllerUpdateCallback update_callback) {
  1254. std::scoped_lock lock{callback_mutex};
  1255. callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
  1256. return last_callback_key++;
  1257. }
  1258. void EmulatedController::DeleteCallback(int key) {
  1259. std::scoped_lock lock{callback_mutex};
  1260. const auto& iterator = callback_list.find(key);
  1261. if (iterator == callback_list.end()) {
  1262. LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
  1263. return;
  1264. }
  1265. callback_list.erase(iterator);
  1266. }
  1267. } // namespace Core::HID