VERY experimental Nintendo Switch 2 emulator
C++
input_common: Create virtual amiibo driver
german7756b1301938c0
diff --git a/src/common/input.h b/src/common/input.hindex 825b0d650d..8365cc36ed 100644--- a/src/common/input.h+++ b/src/common/input.h@@ -76,6 +76,19 @@ enum class PollingError {Unknown,};+// Nfc reply from the controller+enum class NfcState {+ Success,+ NewAmiibo,+ WaitingForAmiibo,+ AmiiboRemoved,+ NotAnAmiibo,+ NotSupported,+ WrongDeviceState,+ WriteFailed,+ Unknown,+};+// Ir camera reply from the controllerenum class CameraError {None,@@ -202,6 +215,11 @@ struct CameraStatus {std::vector<u8> data{};};+struct NfcStatus {+ NfcState state{};+ std::vector<u8> data{};+};+// List of buttons to be passed to Qt that can be translatedenum class ButtonNames {Undefined,@@ -260,6 +278,7 @@ struct CallbackStatus {BatteryStatus battery_status{};VibrationStatus vibration_status{};CameraStatus camera_status{};+ NfcStatus nfc_status{};};// Triggered once every input change@@ -312,6 +331,14 @@ public:virtual CameraError SetCameraFormat([[maybe_unused]] CameraFormat camera_format) {return CameraError::NotSupported;}++ virtual NfcState SupportsNfc() {+ return NfcState::NotSupported;+ }++ virtual NfcState WriteNfcData([[maybe_unused]] const std::vector<u8>& data) {+ return NfcState::NotSupported;+ }};/// An abstract class template for a factory that can create input devices.diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txtindex 4b91b88cee..2cf9eb97f4 100644--- a/src/input_common/CMakeLists.txt+++ b/src/input_common/CMakeLists.txt@@ -18,6 +18,8 @@ add_library(input_common STATICdrivers/touch_screen.hdrivers/udp_client.cppdrivers/udp_client.h+ drivers/virtual_amiibo.cpp+ drivers/virtual_amiibo.hhelpers/stick_from_buttons.cpphelpers/stick_from_buttons.hhelpers/touch_from_buttons.cppdiff --git a/src/input_common/drivers/virtual_amiibo.cpp b/src/input_common/drivers/virtual_amiibo.cppnew file mode 100644index 0000000000..8fadb1322a--- /dev/null+++ b/src/input_common/drivers/virtual_amiibo.cpp@@ -0,0 +1,101 @@+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#include <cstring>+#include <fmt/format.h>++#include "common/fs/file.h"+#include "common/fs/fs.h"+#include "common/fs/path_util.h"+#include "common/logging/log.h"+#include "common/settings.h"+#include "input_common/drivers/virtual_amiibo.h"++namespace InputCommon {+constexpr PadIdentifier identifier = {+ .guid = Common::UUID{},+ .port = 0,+ .pad = 0,+};++VirtualAmiibo::VirtualAmiibo(std::string input_engine_) : InputEngine(std::move(input_engine_)) {}++VirtualAmiibo::~VirtualAmiibo() {}++Common::Input::PollingError VirtualAmiibo::SetPollingMode(+ [[maybe_unused]] const PadIdentifier& identifier_,+ const Common::Input::PollingMode polling_mode_) {+ polling_mode = polling_mode_;++ if (polling_mode == Common::Input::PollingMode::NFC) {+ if (state == State::Initialized) {+ state = State::WaitingForAmiibo;+ }+ } else {+ if (state == State::AmiiboIsOpen) {+ CloseAmiibo();+ }+ }++ return Common::Input::PollingError::None;+}++Common::Input::NfcState VirtualAmiibo::SupportsNfc(+ [[maybe_unused]] const PadIdentifier& identifier_) {+ return Common::Input::NfcState::Success;+}++Common::Input::NfcState VirtualAmiibo::WriteNfcData(+ [[maybe_unused]] const PadIdentifier& identifier_, const std::vector<u8>& data) {+ const Common::FS::IOFile amiibo_file{file_path, Common::FS::FileAccessMode::ReadWrite,+ Common::FS::FileType::BinaryFile};++ if (!amiibo_file.IsOpen()) {+ LOG_ERROR(Core, "Amiibo is already on use");+ return Common::Input::NfcState::WriteFailed;+ }++ if (!amiibo_file.Write(data)) {+ LOG_ERROR(Service_NFP, "Error writting to file");+ return Common::Input::NfcState::WriteFailed;+ }++ return Common::Input::NfcState::Success;+}++VirtualAmiibo::State VirtualAmiibo::GetCurrentState() const {+ return state;+}++VirtualAmiibo::Info VirtualAmiibo::LoadAmiibo(const std::string& filename) {+ const Common::FS::IOFile amiibo_file{filename, Common::FS::FileAccessMode::Read,+ Common::FS::FileType::BinaryFile};++ if (state != State::WaitingForAmiibo) {+ return Info::WrongDeviceState;+ }++ if (!amiibo_file.IsOpen()) {+ return Info::UnableToLoad;+ }++ amiibo_data.resize(amiibo_size);++ if (amiibo_file.Read(amiibo_data) < amiibo_size_without_password) {+ return Info::NotAnAmiibo;+ }++ file_path = filename;+ state = State::AmiiboIsOpen;+ SetNfc(identifier, {Common::Input::NfcState::NewAmiibo, amiibo_data});+ return Info::Success;+}++VirtualAmiibo::Info VirtualAmiibo::CloseAmiibo() {+ state = polling_mode == Common::Input::PollingMode::NFC ? State::WaitingForAmiibo+ : State::Initialized;+ SetNfc(identifier, {Common::Input::NfcState::AmiiboRemoved, {}});+ return Info::Success;+}++} // namespace InputCommondiff --git a/src/input_common/drivers/virtual_amiibo.h b/src/input_common/drivers/virtual_amiibo.hnew file mode 100644index 0000000000..5790e4a1ff--- /dev/null+++ b/src/input_common/drivers/virtual_amiibo.h@@ -0,0 +1,61 @@+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#pragma once++#include <array>+#include <string>+#include <vector>++#include "common/common_types.h"+#include "input_common/input_engine.h"++namespace Common::FS {+class IOFile;+}++namespace InputCommon {++class VirtualAmiibo final : public InputEngine {+public:+ enum class State {+ Initialized,+ WaitingForAmiibo,+ AmiiboIsOpen,+ };++ enum class Info {+ Success,+ UnableToLoad,+ NotAnAmiibo,+ WrongDeviceState,+ Unknown,+ };++ explicit VirtualAmiibo(std::string input_engine_);+ ~VirtualAmiibo() override;++ // Sets polling mode to a controller+ Common::Input::PollingError SetPollingMode(+ const PadIdentifier& identifier_, const Common::Input::PollingMode polling_mode_) override;++ Common::Input::NfcState SupportsNfc(const PadIdentifier& identifier_) override;++ Common::Input::NfcState WriteNfcData(const PadIdentifier& identifier_,+ const std::vector<u8>& data) override;++ State GetCurrentState() const;++ Info LoadAmiibo(const std::string& amiibo_file);+ Info CloseAmiibo();++private:+ static constexpr std::size_t amiibo_size = 0x21C;+ static constexpr std::size_t amiibo_size_without_password = amiibo_size - 0x8;++ std::string file_path{};+ State state{State::Initialized};+ std::vector<u8> amiibo_data;+ Common::Input::PollingMode polling_mode{Common::Input::PollingMode::Pasive};+};+} // namespace InputCommondiff --git a/src/input_common/input_engine.cpp b/src/input_common/input_engine.cppindex 6ede0e4b0e..61cfd0911c 100644--- a/src/input_common/input_engine.cpp+++ b/src/input_common/input_engine.cpp@@ -102,6 +102,17 @@ void InputEngine::SetCamera(const PadIdentifier& identifier,TriggerOnCameraChange(identifier, value);}+void InputEngine::SetNfc(const PadIdentifier& identifier, const Common::Input::NfcStatus& value) {+ {+ std::scoped_lock lock{mutex};+ ControllerData& controller = controller_list.at(identifier);+ if (!configuring) {+ controller.nfc = value;+ }+ }+ TriggerOnNfcChange(identifier, value);+}+bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {std::scoped_lock lock{mutex};const auto controller_iter = controller_list.find(identifier);@@ -189,6 +200,18 @@ Common::Input::CameraStatus InputEngine::GetCamera(const PadIdentifier& identifireturn controller.camera;}+Common::Input::NfcStatus InputEngine::GetNfc(const PadIdentifier& identifier) const {+ std::scoped_lock lock{mutex};+ const auto controller_iter = controller_list.find(identifier);+ if (controller_iter == controller_list.cend()) {+ LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),+ identifier.pad, identifier.port);+ return {};+ }+ const ControllerData& controller = controller_iter->second;+ return controller.nfc;+}+void InputEngine::ResetButtonState() {for (const auto& controller : controller_list) {for (const auto& button : controller.second.buttons) {@@ -355,6 +378,20 @@ void InputEngine::TriggerOnCameraChange(const PadIdentifier& identifier,}}+void InputEngine::TriggerOnNfcChange(const PadIdentifier& identifier,+ [[maybe_unused]] const Common::Input::NfcStatus& value) {+ std::scoped_lock lock{mutex_callback};+ for (const auto& poller_pair : callback_list) {+ const InputIdentifier& poller = poller_pair.second;+ if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Nfc, 0)) {+ continue;+ }+ if (poller.callback.on_change) {+ poller.callback.on_change();+ }+ }+}+bool InputEngine::IsInputIdentifierEqual(const InputIdentifier& input_identifier,const PadIdentifier& identifier, EngineInputType type,int index) const {diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.hindex f6b3c46104..9b8470c6f0 100644--- a/src/input_common/input_engine.h+++ b/src/input_common/input_engine.h@@ -42,6 +42,7 @@ enum class EngineInputType {Camera,HatButton,Motion,+ Nfc,};namespace std {@@ -127,6 +128,17 @@ public:return Common::Input::CameraError::NotSupported;}+ // Request nfc data from a controller+ virtual Common::Input::NfcState SupportsNfc([[maybe_unused]] const PadIdentifier& identifier) {+ return Common::Input::NfcState::NotSupported;+ }++ // Writes data to an nfc tag+ virtual Common::Input::NfcState WriteNfcData([[maybe_unused]] const PadIdentifier& identifier,+ [[maybe_unused]] const std::vector<u8>& data) {+ return Common::Input::NfcState::NotSupported;+ }+// Returns the engine name[[nodiscard]] const std::string& GetEngineName() const;@@ -183,6 +195,7 @@ public:Common::Input::BatteryLevel GetBattery(const PadIdentifier& identifier) const;BasicMotion GetMotion(const PadIdentifier& identifier, int motion) const;Common::Input::CameraStatus GetCamera(const PadIdentifier& identifier) const;+ Common::Input::NfcStatus GetNfc(const PadIdentifier& identifier) const;int SetCallback(InputIdentifier input_identifier);void SetMappingCallback(MappingCallback callback);@@ -195,6 +208,7 @@ protected:void SetBattery(const PadIdentifier& identifier, Common::Input::BatteryLevel value);void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);void SetCamera(const PadIdentifier& identifier, const Common::Input::CameraStatus& value);+ void SetNfc(const PadIdentifier& identifier, const Common::Input::NfcStatus& value);virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {return "Unknown";@@ -208,6 +222,7 @@ private:std::unordered_map<int, BasicMotion> motions;Common::Input::BatteryLevel battery{};Common::Input::CameraStatus camera{};+ Common::Input::NfcStatus nfc{};};void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value);@@ -218,6 +233,7 @@ private:const BasicMotion& value);void TriggerOnCameraChange(const PadIdentifier& identifier,const Common::Input::CameraStatus& value);+ void TriggerOnNfcChange(const PadIdentifier& identifier, const Common::Input::NfcStatus& value);bool IsInputIdentifierEqual(const InputIdentifier& input_identifier,const PadIdentifier& identifier, EngineInputType type,