From b42c3ce21db249d5e3bc04b4f73202e757da317c Mon Sep 17 00:00:00 2001 From: MonsterDruide1 <5958456@gmail.com> Date: Fri, 18 Jun 2021 16:15:42 +0200 Subject: input_common/tas: Base playback & recording system The base playback system supports up to 8 controllers (specified by `PLAYER_NUMBER` in `tas_input.h`), which all change their inputs simulataneously when `TAS::UpdateThread` is called. The recording system uses the controller debugger to read the state of the first controller and forwards that data to the TASing system for recording. Currently, this process sadly is not frame-perfect and pixel-accurate. Co-authored-by: Naii-the-Baf Co-authored-by: Narr-the-Reg --- src/common/settings.h | 7 + src/input_common/CMakeLists.txt | 4 + src/input_common/main.cpp | 48 +++ src/input_common/main.h | 23 ++ src/input_common/tas/tas_input.cpp | 340 +++++++++++++++++++++ src/input_common/tas/tas_input.h | 163 ++++++++++ src/input_common/tas/tas_poller.cpp | 101 ++++++ src/input_common/tas/tas_poller.h | 43 +++ src/yuzu/configuration/configure_input_player.cpp | 30 +- .../configure_input_player_widget.cpp | 16 + .../configuration/configure_input_player_widget.h | 3 + src/yuzu/debugger/controller.cpp | 22 +- src/yuzu/debugger/controller.h | 24 +- src/yuzu/main.cpp | 3 +- 14 files changed, 818 insertions(+), 9 deletions(-) create mode 100644 src/input_common/tas/tas_input.cpp create mode 100644 src/input_common/tas/tas_input.h create mode 100644 src/input_common/tas/tas_poller.cpp create mode 100644 src/input_common/tas/tas_poller.h (limited to 'src') diff --git a/src/common/settings.h b/src/common/settings.h index b1bddb895..29b888f10 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -14,6 +14,7 @@ #include #include +#include #include "common/common_types.h" #include "common/settings_input.h" @@ -499,6 +500,7 @@ struct Values { // Controls InputSetting> players; + std::shared_ptr inputSubsystem = NULL; Setting use_docked_mode{true, "use_docked_mode"}; @@ -512,9 +514,14 @@ struct Values { "motion_device"}; BasicSetting udp_input_servers{"127.0.0.1:26760", "udp_input_servers"}; + BasicSetting tas_enable{false, "tas_enable"}; + BasicSetting tas_reset{ false, "tas_reset" }; + BasicSetting tas_record{ false, "tas_record" }; + BasicSetting mouse_panning{false, "mouse_panning"}; BasicRangedSetting mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"}; BasicSetting mouse_enabled{false, "mouse_enabled"}; + std::string mouse_device; MouseButtonsRaw mouse_buttons; diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt index c4283a952..dd13d948f 100644 --- a/src/input_common/CMakeLists.txt +++ b/src/input_common/CMakeLists.txt @@ -21,6 +21,10 @@ add_library(input_common STATIC mouse/mouse_poller.h sdl/sdl.cpp sdl/sdl.h + tas/tas_input.cpp + tas/tas_input.h + tas/tas_poller.cpp + tas/tas_poller.h udp/client.cpp udp/client.h udp/protocol.cpp diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp index ff23230f0..4f170493e 100644 --- a/src/input_common/main.cpp +++ b/src/input_common/main.cpp @@ -13,6 +13,8 @@ #include "input_common/motion_from_button.h" #include "input_common/mouse/mouse_input.h" #include "input_common/mouse/mouse_poller.h" +#include "input_common/tas/tas_input.h" +#include "input_common/tas/tas_poller.h" #include "input_common/touch_from_button.h" #include "input_common/udp/client.h" #include "input_common/udp/udp.h" @@ -60,6 +62,12 @@ struct InputSubsystem::Impl { Input::RegisterFactory("mouse", mousemotion); mousetouch = std::make_shared(mouse); Input::RegisterFactory("mouse", mousetouch); + + tas = std::make_shared(); + tasbuttons = std::make_shared(tas); + Input::RegisterFactory("tas", tasbuttons); + tasanalog = std::make_shared(tas); + Input::RegisterFactory("tas", tasanalog); } void Shutdown() { @@ -94,12 +102,19 @@ struct InputSubsystem::Impl { mouseanalog.reset(); mousemotion.reset(); mousetouch.reset(); + + Input::UnregisterFactory("tas"); + Input::UnregisterFactory("tas"); + + tasbuttons.reset(); + tasanalog.reset(); } [[nodiscard]] std::vector GetInputDevices() const { std::vector devices = { Common::ParamPackage{{"display", "Any"}, {"class", "any"}}, Common::ParamPackage{{"display", "Keyboard/Mouse"}, {"class", "keyboard"}}, + Common::ParamPackage{{"display", "TAS"}, {"class", "tas"}}, }; #ifdef HAVE_SDL2 auto sdl_devices = sdl->GetInputDevices(); @@ -120,6 +135,9 @@ struct InputSubsystem::Impl { if (params.Get("class", "") == "gcpad") { return gcadapter->GetAnalogMappingForDevice(params); } + if (params.Get("class", "") == "tas") { + return tas->GetAnalogMappingForDevice(params); + } #ifdef HAVE_SDL2 if (params.Get("class", "") == "sdl") { return sdl->GetAnalogMappingForDevice(params); @@ -136,6 +154,9 @@ struct InputSubsystem::Impl { if (params.Get("class", "") == "gcpad") { return gcadapter->GetButtonMappingForDevice(params); } + if (params.Get("class", "") == "tas") { + return tas->GetButtonMappingForDevice(params); + } #ifdef HAVE_SDL2 if (params.Get("class", "") == "sdl") { return sdl->GetButtonMappingForDevice(params); @@ -174,9 +195,12 @@ struct InputSubsystem::Impl { std::shared_ptr mouseanalog; std::shared_ptr mousemotion; std::shared_ptr mousetouch; + std::shared_ptr tasbuttons; + std::shared_ptr tasanalog; std::shared_ptr udp; std::shared_ptr gcadapter; std::shared_ptr mouse; + std::shared_ptr tas; }; InputSubsystem::InputSubsystem() : impl{std::make_unique()} {} @@ -207,6 +231,14 @@ const MouseInput::Mouse* InputSubsystem::GetMouse() const { return impl->mouse.get(); } +TasInput::Tas* InputSubsystem::GetTas() { + return impl->tas.get(); +} + +const TasInput::Tas* InputSubsystem::GetTas() const { + return impl->tas.get(); +} + std::vector InputSubsystem::GetInputDevices() const { return impl->GetInputDevices(); } @@ -287,6 +319,22 @@ const MouseTouchFactory* InputSubsystem::GetMouseTouch() const { return impl->mousetouch.get(); } +TasButtonFactory* InputSubsystem::GetTasButtons() { + return impl->tasbuttons.get(); +} + +const TasButtonFactory* InputSubsystem::GetTasButtons() const { + return impl->tasbuttons.get(); +} + +TasAnalogFactory* InputSubsystem::GetTasAnalogs() { + return impl->tasanalog.get(); +} + +const TasAnalogFactory* InputSubsystem::GetTasAnalogs() const { + return impl->tasanalog.get(); +} + void InputSubsystem::ReloadInputDevices() { if (!impl->udp) { return; diff --git a/src/input_common/main.h b/src/input_common/main.h index 5d6f26385..1d06fc5f5 100644 --- a/src/input_common/main.h +++ b/src/input_common/main.h @@ -29,6 +29,10 @@ namespace MouseInput { class Mouse; } +namespace TasInput { +class Tas; +} + namespace InputCommon { namespace Polling { @@ -64,6 +68,8 @@ class MouseButtonFactory; class MouseAnalogFactory; class MouseMotionFactory; class MouseTouchFactory; +class TasButtonFactory; +class TasAnalogFactory; class Keyboard; /** @@ -103,6 +109,11 @@ public: /// Retrieves the underlying mouse device. [[nodiscard]] const MouseInput::Mouse* GetMouse() const; + /// Retrieves the underlying tas device. + [[nodiscard]] TasInput::Tas* GetTas(); + + /// Retrieves the underlying tas device. + [[nodiscard]] const TasInput::Tas* GetTas() const; /** * Returns all available input devices that this Factory can create a new device with. * Each returned ParamPackage should have a `display` field used for display, a class field for @@ -168,6 +179,18 @@ public: /// Retrieves the underlying udp touch handler. [[nodiscard]] const MouseTouchFactory* GetMouseTouch() const; + /// Retrieves the underlying tas button handler. + [[nodiscard]] TasButtonFactory* GetTasButtons(); + + /// Retrieves the underlying tas button handler. + [[nodiscard]] const TasButtonFactory* GetTasButtons() const; + + /// Retrieves the underlying tas touch handler. + [[nodiscard]] TasAnalogFactory* GetTasAnalogs(); + + /// Retrieves the underlying tas touch handler. + [[nodiscard]] const TasAnalogFactory* GetTasAnalogs() const; + /// Reloads the input devices void ReloadInputDevices(); diff --git a/src/input_common/tas/tas_input.cpp b/src/input_common/tas/tas_input.cpp new file mode 100644 index 000000000..343641945 --- /dev/null +++ b/src/input_common/tas/tas_input.cpp @@ -0,0 +1,340 @@ +// Copyright 2021 yuzu Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. + +#include +#include +#include +#include +#include +#include +#include + +#include "common/fs/file.h" +#include "common/fs/fs_types.h" +#include "common/fs/path_util.h" +#include "common/logging/log.h" +#include "common/settings.h" +#include "input_common/tas/tas_input.h" + +namespace TasInput { + +Tas::Tas() { + LoadTasFiles(); +} + +Tas::~Tas() { + update_thread_running = false; +} + +void Tas::RefreshTasFile() { + refresh_tas_fle = true; +} +void Tas::LoadTasFiles() { + scriptLength = 0; + for (int i = 0; i < PLAYER_NUMBER; i++) { + LoadTasFile(i); + if (newCommands[i].size() > scriptLength) + scriptLength = newCommands[i].size(); + } +} +void Tas::LoadTasFile(int playerIndex) { + LOG_DEBUG(Input, "LoadTasFile()"); + if (!newCommands[playerIndex].empty()) { + newCommands[playerIndex].clear(); + } + std::string file = Common::FS::ReadStringFromFile( + Common::FS::GetYuzuPathString(Common::FS::YuzuPath::TASFile) + "script0-" + + std::to_string(playerIndex + 1) + ".txt", + Common::FS::FileType::BinaryFile); + std::stringstream command_line(file); + std::string line; + int frameNo = 0; + TASCommand empty = {.buttons = 0, .l_axis = {0.f, 0.f}, .r_axis = {0.f, 0.f}}; + while (std::getline(command_line, line, '\n')) { + if (line.empty()) + continue; + LOG_DEBUG(Input, "Loading line: {}", line); + std::smatch m; + + std::stringstream linestream(line); + std::string segment; + std::vector seglist; + + while (std::getline(linestream, segment, ' ')) { + seglist.push_back(segment); + } + + if (seglist.size() < 4) + continue; + + while (frameNo < std::stoi(seglist.at(0))) { + newCommands[playerIndex].push_back(empty); + frameNo++; + } + + TASCommand command = { + .buttons = ReadCommandButtons(seglist.at(1)), + .l_axis = ReadCommandAxis(seglist.at(2)), + .r_axis = ReadCommandAxis(seglist.at(3)), + }; + newCommands[playerIndex].push_back(command); + frameNo++; + } + LOG_INFO(Input, "TAS file loaded! {} frames", frameNo); +} + +void Tas::WriteTasFile() { + LOG_DEBUG(Input, "WriteTasFile()"); + std::string output_text = ""; + for (int frame = 0; frame < (signed)recordCommands.size(); frame++) { + if (!output_text.empty()) + output_text += "\n"; + TASCommand line = recordCommands.at(frame); + output_text += std::to_string(frame) + " " + WriteCommandButtons(line.buttons) + " " + + WriteCommandAxis(line.l_axis) + " " + WriteCommandAxis(line.r_axis); + } + size_t bytesWritten = Common::FS::WriteStringToFile( + Common::FS::GetYuzuPathString(Common::FS::YuzuPath::TASFile) + "record.txt", + Common::FS::FileType::TextFile, output_text); + if (bytesWritten == output_text.size()) + LOG_INFO(Input, "TAS file written to file!"); + else + LOG_ERROR(Input, "Writing the TAS-file has failed! {} / {} bytes written", bytesWritten, + output_text.size()); +} + +void Tas::RecordInput(u32 buttons, std::array, 2> axes) { + lastInput = {buttons, flipY(axes[0]), flipY(axes[1])}; +} + +std::pair Tas::flipY(std::pair old) const { + auto [x, y] = old; + return {x, -y}; +} + +std::string Tas::GetStatusDescription() { + if (Settings::values.tas_record) { + return "Recording TAS: " + std::to_string(recordCommands.size()); + } + if (Settings::values.tas_enable) { + return "Playing TAS: " + std::to_string(current_command) + "/" + + std::to_string(scriptLength); + } + return "TAS not running: " + std::to_string(current_command) + "/" + + std::to_string(scriptLength); +} + +std::string debugButtons(u32 buttons) { + return "{ " + TasInput::Tas::buttonsToString(buttons) + " }"; +} + +std::string debugJoystick(float x, float y) { + return "[ " + std::to_string(x) + "," + std::to_string(y) + " ]"; +} + +std::string debugInput(TasData data) { + return "{ " + debugButtons(data.buttons) + " , " + debugJoystick(data.axis[0], data.axis[1]) + + " , " + debugJoystick(data.axis[2], data.axis[3]) + " }"; +} + +std::string debugInputs(std::array arr) { + std::string returns = "[ "; + for (size_t i = 0; i < arr.size(); i++) { + returns += debugInput(arr[i]); + if (i != arr.size() - 1) + returns += " , "; + } + return returns + "]"; +} + +void Tas::UpdateThread() { + if (update_thread_running) { + if (Settings::values.pauseTasOnLoad && Settings::values.cpuBoosted) { + for (int i = 0; i < PLAYER_NUMBER; i++) { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + + if (Settings::values.tas_record) { + recordCommands.push_back(lastInput); + } + if (!Settings::values.tas_record && !recordCommands.empty()) { + WriteTasFile(); + Settings::values.tas_reset = true; + refresh_tas_fle = true; + recordCommands.clear(); + } + if (Settings::values.tas_reset) { + current_command = 0; + if (refresh_tas_fle) { + LoadTasFiles(); + refresh_tas_fle = false; + } + Settings::values.tas_reset = false; + LoadTasFiles(); + LOG_DEBUG(Input, "tas_reset done"); + } + if (Settings::values.tas_enable) { + if ((signed)current_command < scriptLength) { + LOG_INFO(Input, "Playing TAS {}/{}", current_command, scriptLength); + size_t frame = current_command++; + for (int i = 0; i < PLAYER_NUMBER; i++) { + if (frame < newCommands[i].size()) { + TASCommand command = newCommands[i][frame]; + tas_data[i].buttons = command.buttons; + auto [l_axis_x, l_axis_y] = command.l_axis; + tas_data[i].axis[0] = l_axis_x; + tas_data[i].axis[1] = l_axis_y; + auto [r_axis_x, r_axis_y] = command.r_axis; + tas_data[i].axis[2] = r_axis_x; + tas_data[i].axis[3] = r_axis_y; + } else { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + } else { + Settings::values.tas_enable = false; + current_command = 0; + for (int i = 0; i < PLAYER_NUMBER; i++) { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + } else { + for (int i = 0; i < PLAYER_NUMBER; i++) { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + } + LOG_DEBUG(Input, "TAS inputs: {}", debugInputs(tas_data)); +} + +TasAnalog Tas::ReadCommandAxis(const std::string line) const { + std::stringstream linestream(line); + std::string segment; + std::vector seglist; + + while (std::getline(linestream, segment, ';')) { + seglist.push_back(segment); + } + + const float x = std::stof(seglist.at(0)) / 32767.f; + const float y = std::stof(seglist.at(1)) / 32767.f; + + return {x, y}; +} + +u32 Tas::ReadCommandButtons(const std::string data) const { + std::stringstream button_text(data); + std::string line; + u32 buttons = 0; + while (std::getline(button_text, line, ';')) { + for (auto [text, tas_button] : text_to_tas_button) { + if (text == line) { + buttons |= static_cast(tas_button); + break; + } + } + } + return buttons; +} + +std::string Tas::WriteCommandAxis(TasAnalog data) const { + auto [x, y] = data; + std::string line; + line += std::to_string(static_cast(x * 32767)); + line += ";"; + line += std::to_string(static_cast(y * 32767)); + return line; +} + +std::string Tas::WriteCommandButtons(u32 data) const { + if (data == 0) + return "NONE"; + + std::string line; + u32 index = 0; + while (data > 0) { + if ((data & 1) == 1) { + for (auto [text, tas_button] : text_to_tas_button) { + if (tas_button == static_cast(1 << index)) { + if (line.size() > 0) + line += ";"; + line += text; + break; + } + } + } + index++; + data >>= 1; + } + return line; +} + +InputCommon::ButtonMapping Tas::GetButtonMappingForDevice( + const Common::ParamPackage& params) const { + // This list is missing ZL/ZR since those are not considered buttons. + // We will add those afterwards + // This list also excludes any button that can't be really mapped + static constexpr std::array, 20> + switch_to_tas_button = { + std::pair{Settings::NativeButton::A, TasButton::BUTTON_A}, + {Settings::NativeButton::B, TasButton::BUTTON_B}, + {Settings::NativeButton::X, TasButton::BUTTON_X}, + {Settings::NativeButton::Y, TasButton::BUTTON_Y}, + {Settings::NativeButton::LStick, TasButton::STICK_L}, + {Settings::NativeButton::RStick, TasButton::STICK_R}, + {Settings::NativeButton::L, TasButton::TRIGGER_L}, + {Settings::NativeButton::R, TasButton::TRIGGER_R}, + {Settings::NativeButton::Plus, TasButton::BUTTON_PLUS}, + {Settings::NativeButton::Minus, TasButton::BUTTON_MINUS}, + {Settings::NativeButton::DLeft, TasButton::BUTTON_LEFT}, + {Settings::NativeButton::DUp, TasButton::BUTTON_UP}, + {Settings::NativeButton::DRight, TasButton::BUTTON_RIGHT}, + {Settings::NativeButton::DDown, TasButton::BUTTON_DOWN}, + {Settings::NativeButton::SL, TasButton::BUTTON_SL}, + {Settings::NativeButton::SR, TasButton::BUTTON_SR}, + {Settings::NativeButton::Screenshot, TasButton::BUTTON_CAPTURE}, + {Settings::NativeButton::Home, TasButton::BUTTON_HOME}, + {Settings::NativeButton::ZL, TasButton::TRIGGER_ZL}, + {Settings::NativeButton::ZR, TasButton::TRIGGER_ZR}, + }; + + InputCommon::ButtonMapping mapping{}; + for (const auto& [switch_button, tas_button] : switch_to_tas_button) { + Common::ParamPackage button_params({{"engine", "tas"}}); + button_params.Set("pad", params.Get("pad", 0)); + button_params.Set("button", static_cast(tas_button)); + mapping.insert_or_assign(switch_button, std::move(button_params)); + } + + return mapping; +} + +InputCommon::AnalogMapping Tas::GetAnalogMappingForDevice( + const Common::ParamPackage& params) const { + + InputCommon::AnalogMapping mapping = {}; + Common::ParamPackage left_analog_params; + left_analog_params.Set("engine", "tas"); + left_analog_params.Set("pad", params.Get("pad", 0)); + left_analog_params.Set("axis_x", static_cast(TasAxes::StickX)); + left_analog_params.Set("axis_y", static_cast(TasAxes::StickY)); + mapping.insert_or_assign(Settings::NativeAnalog::LStick, std::move(left_analog_params)); + Common::ParamPackage right_analog_params; + right_analog_params.Set("engine", "tas"); + right_analog_params.Set("pad", params.Get("pad", 0)); + right_analog_params.Set("axis_x", static_cast(TasAxes::SubstickX)); + right_analog_params.Set("axis_y", static_cast(TasAxes::SubstickY)); + mapping.insert_or_assign(Settings::NativeAnalog::RStick, std::move(right_analog_params)); + return mapping; +} + +const TasData& Tas::GetTasState(std::size_t pad) const { + return tas_data[pad]; +} +} // namespace TasInput diff --git a/src/input_common/tas/tas_input.h b/src/input_common/tas/tas_input.h new file mode 100644 index 000000000..0a152a04f --- /dev/null +++ b/src/input_common/tas/tas_input.h @@ -0,0 +1,163 @@ +// Copyright 2020 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include + +#include "common/common_types.h" +#include "core/frontend/input.h" +#include "input_common/main.h" + +#define PLAYER_NUMBER 8 + +namespace TasInput { + +using TasAnalog = std::tuple; + +enum class TasButton : u32 { + BUTTON_A = 0x000001, + BUTTON_B = 0x000002, + BUTTON_X = 0x000004, + BUTTON_Y = 0x000008, + STICK_L = 0x000010, + STICK_R = 0x000020, + TRIGGER_L = 0x000040, + TRIGGER_R = 0x000080, + TRIGGER_ZL = 0x000100, + TRIGGER_ZR = 0x000200, + BUTTON_PLUS = 0x000400, + BUTTON_MINUS = 0x000800, + BUTTON_LEFT = 0x001000, + BUTTON_UP = 0x002000, + BUTTON_RIGHT = 0x004000, + BUTTON_DOWN = 0x008000, + BUTTON_SL = 0x010000, + BUTTON_SR = 0x020000, + BUTTON_HOME = 0x040000, + BUTTON_CAPTURE = 0x080000, +}; + +static const std::array, 20> text_to_tas_button = { + std::pair{"KEY_A", TasButton::BUTTON_A}, + {"KEY_B", TasButton::BUTTON_B}, + {"KEY_X", TasButton::BUTTON_X}, + {"KEY_Y", TasButton::BUTTON_Y}, + {"KEY_LSTICK", TasButton::STICK_L}, + {"KEY_RSTICK", TasButton::STICK_R}, + {"KEY_L", TasButton::TRIGGER_L}, + {"KEY_R", TasButton::TRIGGER_R}, + {"KEY_PLUS", TasButton::BUTTON_PLUS}, + {"KEY_MINUS", TasButton::BUTTON_MINUS}, + {"KEY_DLEFT", TasButton::BUTTON_LEFT}, + {"KEY_DUP", TasButton::BUTTON_UP}, + {"KEY_DRIGHT", TasButton::BUTTON_RIGHT}, + {"KEY_DDOWN", TasButton::BUTTON_DOWN}, + {"KEY_SL", TasButton::BUTTON_SL}, + {"KEY_SR", TasButton::BUTTON_SR}, + {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE}, + {"KEY_HOME", TasButton::BUTTON_HOME}, + {"KEY_ZL", TasButton::TRIGGER_ZL}, + {"KEY_ZR", TasButton::TRIGGER_ZR}, +}; + +enum class TasAxes : u8 { + StickX, + StickY, + SubstickX, + SubstickY, + Undefined, +}; + +struct TasData { + u32 buttons{}; + std::array axis{}; +}; + +class Tas { +public: + Tas(); + ~Tas(); + + static std::string buttonsToString(u32 button) { + std::string returns; + if ((button & static_cast(TasInput::TasButton::BUTTON_A)) != 0) + returns += ", A"; + if ((button & static_cast(TasInput::TasButton::BUTTON_B)) != 0) + returns += ", B"; + if ((button & static_cast(TasInput::TasButton::BUTTON_X)) != 0) + returns += ", X"; + if ((button & static_cast(TasInput::TasButton::BUTTON_Y)) != 0) + returns += ", Y"; + if ((button & static_cast(TasInput::TasButton::STICK_L)) != 0) + returns += ", STICK_L"; + if ((button & static_cast(TasInput::TasButton::STICK_R)) != 0) + returns += ", STICK_R"; + if ((button & static_cast(TasInput::TasButton::TRIGGER_L)) != 0) + returns += ", TRIGGER_L"; + if ((button & static_cast(TasInput::TasButton::TRIGGER_R)) != 0) + returns += ", TRIGGER_R"; + if ((button & static_cast(TasInput::TasButton::TRIGGER_ZL)) != 0) + returns += ", TRIGGER_ZL"; + if ((button & static_cast(TasInput::TasButton::TRIGGER_ZR)) != 0) + returns += ", TRIGGER_ZR"; + if ((button & static_cast(TasInput::TasButton::BUTTON_PLUS)) != 0) + returns += ", PLUS"; + if ((button & static_cast(TasInput::TasButton::BUTTON_MINUS)) != 0) + returns += ", MINUS"; + if ((button & static_cast(TasInput::TasButton::BUTTON_LEFT)) != 0) + returns += ", LEFT"; + if ((button & static_cast(TasInput::TasButton::BUTTON_UP)) != 0) + returns += ", UP"; + if ((button & static_cast(TasInput::TasButton::BUTTON_RIGHT)) != 0) + returns += ", RIGHT"; + if ((button & static_cast(TasInput::TasButton::BUTTON_DOWN)) != 0) + returns += ", DOWN"; + if ((button & static_cast(TasInput::TasButton::BUTTON_SL)) != 0) + returns += ", SL"; + if ((button & static_cast(TasInput::TasButton::BUTTON_SR)) != 0) + returns += ", SR"; + if ((button & static_cast(TasInput::TasButton::BUTTON_HOME)) != 0) + returns += ", HOME"; + if ((button & static_cast(TasInput::TasButton::BUTTON_CAPTURE)) != 0) + returns += ", CAPTURE"; + return returns.length() != 0 ? returns.substr(2) : ""; + } + + void RefreshTasFile(); + void LoadTasFiles(); + void RecordInput(u32 buttons, std::array, 2> axes); + void UpdateThread(); + std::string GetStatusDescription(); + + InputCommon::ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) const; + InputCommon::AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) const; + [[nodiscard]] const TasData& GetTasState(std::size_t pad) const; + +private: + struct TASCommand { + u32 buttons{}; + TasAnalog l_axis{}; + TasAnalog r_axis{}; + }; + void LoadTasFile(int playerIndex); + void WriteTasFile(); + TasAnalog ReadCommandAxis(const std::string line) const; + u32 ReadCommandButtons(const std::string line) const; + std::string WriteCommandButtons(u32 data) const; + std::string WriteCommandAxis(TasAnalog data) const; + std::pair flipY(std::pair old) const; + + size_t scriptLength{0}; + std::array tas_data; + bool update_thread_running{true}; + bool refresh_tas_fle{false}; + std::array, PLAYER_NUMBER> newCommands{}; + std::vector recordCommands{}; + std::size_t current_command{0}; + TASCommand lastInput{}; // only used for recording +}; +} // namespace TasInput diff --git a/src/input_common/tas/tas_poller.cpp b/src/input_common/tas/tas_poller.cpp new file mode 100644 index 000000000..15810d6b0 --- /dev/null +++ b/src/input_common/tas/tas_poller.cpp @@ -0,0 +1,101 @@ +// Copyright 2021 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include + +#include "common/settings.h" +#include "common/threadsafe_queue.h" +#include "input_common/tas/tas_input.h" +#include "input_common/tas/tas_poller.h" + +namespace InputCommon { + +class TasButton final : public Input::ButtonDevice { +public: + explicit TasButton(u32 button_, u32 pad_, const TasInput::Tas* tas_input_) + : button(button_), pad(pad_), tas_input(tas_input_) {} + + bool GetStatus() const override { + return (tas_input->GetTasState(pad).buttons & button) != 0; + } + +private: + const u32 button; + const u32 pad; + const TasInput::Tas* tas_input; +}; + +TasButtonFactory::TasButtonFactory(std::shared_ptr tas_input_) + : tas_input(std::move(tas_input_)) {} + +std::unique_ptr TasButtonFactory::Create(const Common::ParamPackage& params) { + const auto button_id = params.Get("button", 0); + const auto pad = params.Get("pad", 0); + + return std::make_unique(button_id, pad, tas_input.get()); +} + +class TasAnalog final : public Input::AnalogDevice { +public: + explicit TasAnalog(u32 pad_, u32 axis_x_, u32 axis_y_, const TasInput::Tas* tas_input_) + : pad(pad_), axis_x(axis_x_), axis_y(axis_y_), tas_input(tas_input_) {} + + float GetAxis(u32 axis) const { + std::lock_guard lock{mutex}; + return tas_input->GetTasState(pad).axis.at(axis); + } + + std::pair GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const { + float x = GetAxis(analog_axis_x); + float y = GetAxis(analog_axis_y); + + // Make sure the coordinates are in the unit circle, + // otherwise normalize it. + float r = x * x + y * y; + if (r > 1.0f) { + r = std::sqrt(r); + x /= r; + y /= r; + } + + return {x, y}; + } + + std::tuple GetStatus() const override { + return GetAnalog(axis_x, axis_y); + } + + Input::AnalogProperties GetAnalogProperties() const override { + return {0.0f, 1.0f, 0.5f}; + } + +private: + const u32 pad; + const u32 axis_x; + const u32 axis_y; + const TasInput::Tas* tas_input; + mutable std::mutex mutex; +}; + +/// An analog device factory that creates analog devices from GC Adapter +TasAnalogFactory::TasAnalogFactory(std::shared_ptr tas_input_) + : tas_input(std::move(tas_input_)) {} + +/** + * Creates analog device from joystick axes + * @param params contains parameters for creating the device: + * - "port": the nth gcpad on the adapter + * - "axis_x": the index of the axis to be bind as x-axis + * - "axis_y": the index of the axis to be bind as y-axis + */ +std::unique_ptr TasAnalogFactory::Create(const Common::ParamPackage& params) { + const auto pad = static_cast(params.Get("pad", 0)); + const auto axis_x = static_cast(params.Get("axis_x", 0)); + const auto axis_y = static_cast(params.Get("axis_y", 1)); + + return std::make_unique(pad, axis_x, axis_y, tas_input.get()); +} + +} // namespace InputCommon diff --git a/src/input_common/tas/tas_poller.h b/src/input_common/tas/tas_poller.h new file mode 100644 index 000000000..1bc0d173b --- /dev/null +++ b/src/input_common/tas/tas_poller.h @@ -0,0 +1,43 @@ +// Copyright 2021 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include "core/frontend/input.h" +#include "input_common/tas/tas_input.h" + +namespace InputCommon { + +/** + * A button device factory representing a mouse. It receives mouse events and forward them + * to all button devices it created. + */ +class TasButtonFactory final : public Input::Factory { +public: + explicit TasButtonFactory(std::shared_ptr tas_input_); + + /** + * Creates a button device from a button press + * @param params contains parameters for creating the device: + * - "code": the code of the key to bind with the button + */ + std::unique_ptr Create(const Common::ParamPackage& params) override; + +private: + std::shared_ptr tas_input; +}; + +/// An analog device factory that creates analog devices from mouse +class TasAnalogFactory final : public Input::Factory { +public: + explicit TasAnalogFactory(std::shared_ptr tas_input_); + + std::unique_ptr Create(const Common::ParamPackage& params) override; + +private: + std::shared_ptr tas_input; +}; + +} // namespace InputCommon diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp index 7527c068b..88f4bf388 100644 --- a/src/yuzu/configuration/configure_input_player.cpp +++ b/src/yuzu/configuration/configure_input_player.cpp @@ -124,6 +124,19 @@ QString ButtonToText(const Common::ParamPackage& param) { return GetKeyName(param.Get("code", 0)); } + if (param.Get("engine", "") == "tas") { + if (param.Has("axis")) { + const QString axis_str = QString::fromStdString(param.Get("axis", "")); + + return QObject::tr("TAS Axis %1").arg(axis_str); + } + if (param.Has("button")) { + const QString button_str = QString::number(int(std::log2(param.Get("button", 0)))); + return QObject::tr("TAS Btn %1").arg(button_str); + } + return GetKeyName(param.Get("code", 0)); + } + if (param.Get("engine", "") == "cemuhookudp") { if (param.Has("pad_index")) { const QString motion_str = QString::fromStdString(param.Get("pad_index", "")); @@ -187,7 +200,8 @@ QString AnalogToText(const Common::ParamPackage& param, const std::string& dir) const QString axis_y_str = QString::fromStdString(param.Get("axis_y", "")); const bool invert_x = param.Get("invert_x", "+") == "-"; const bool invert_y = param.Get("invert_y", "+") == "-"; - if (engine_str == "sdl" || engine_str == "gcpad" || engine_str == "mouse") { + if (engine_str == "sdl" || engine_str == "gcpad" || engine_str == "mouse" || + engine_str == "tas") { if (dir == "modifier") { return QObject::tr("[unused]"); } @@ -926,9 +940,9 @@ void ConfigureInputPlayer::UpdateUI() { int slider_value; auto& param = analogs_param[analog_id]; - const bool is_controller = param.Get("engine", "") == "sdl" || - param.Get("engine", "") == "gcpad" || - param.Get("engine", "") == "mouse"; + const bool is_controller = + param.Get("engine", "") == "sdl" || param.Get("engine", "") == "gcpad" || + param.Get("engine", "") == "mouse" || param.Get("engine", "") == "tas"; if (is_controller) { if (!param.Has("deadzone")) { @@ -1045,8 +1059,12 @@ int ConfigureInputPlayer::GetIndexFromControllerType(Settings::ControllerType ty void ConfigureInputPlayer::UpdateInputDevices() { input_devices = input_subsystem->GetInputDevices(); ui->comboDevices->clear(); - for (auto device : input_devices) { - ui->comboDevices->addItem(QString::fromStdString(device.Get("display", "Unknown")), {}); + for (auto& device : input_devices) { + const std::string display = device.Get("display", "Unknown"); + ui->comboDevices->addItem(QString::fromStdString(display), {}); + if (display == "TAS") { + device.Set("pad", static_cast(player_index)); + } } } diff --git a/src/yuzu/configuration/configure_input_player_widget.cpp b/src/yuzu/configuration/configure_input_player_widget.cpp index 9c890ed5d..e649e2169 100644 --- a/src/yuzu/configuration/configure_input_player_widget.cpp +++ b/src/yuzu/configuration/configure_input_player_widget.cpp @@ -220,8 +220,20 @@ void PlayerControlPreview::UpdateInput() { } } + ControllerInput input{}; if (input_changed) { update(); + input.changed = true; + } + input.axis_values[Settings::NativeAnalog::LStick] = { + axis_values[Settings::NativeAnalog::LStick].value.x(), + axis_values[Settings::NativeAnalog::LStick].value.y()}; + input.axis_values[Settings::NativeAnalog::RStick] = { + axis_values[Settings::NativeAnalog::RStick].value.x(), + axis_values[Settings::NativeAnalog::RStick].value.y()}; + input.button_values = button_values; + if (controller_callback.input != NULL) { + controller_callback.input(std::move(input)); } if (mapping_active) { @@ -229,6 +241,10 @@ void PlayerControlPreview::UpdateInput() { } } +void PlayerControlPreview::SetCallBack(ControllerCallback callback_) { + controller_callback = callback_; +} + void PlayerControlPreview::paintEvent(QPaintEvent* event) { QFrame::paintEvent(event); QPainter p(this); diff --git a/src/yuzu/configuration/configure_input_player_widget.h b/src/yuzu/configuration/configure_input_player_widget.h index f4a6a5e1b..f4bbfa528 100644 --- a/src/yuzu/configuration/configure_input_player_widget.h +++ b/src/yuzu/configuration/configure_input_player_widget.h @@ -9,6 +9,7 @@ #include #include "common/settings.h" #include "core/frontend/input.h" +#include "yuzu/debugger/controller.h" class QLabel; @@ -33,6 +34,7 @@ public: void BeginMappingAnalog(std::size_t button_id); void EndMapping(); void UpdateInput(); + void SetCallBack(ControllerCallback callback_); protected: void paintEvent(QPaintEvent* event) override; @@ -181,6 +183,7 @@ private: using StickArray = std::array, Settings::NativeAnalog::NUM_STICKS_HID>; + ControllerCallback controller_callback; bool is_enabled{}; bool mapping_active{}; int blink_counter{}; diff --git a/src/yuzu/debugger/controller.cpp b/src/yuzu/debugger/controller.cpp index c1fc69578..822d033d1 100644 --- a/src/yuzu/debugger/controller.cpp +++ b/src/yuzu/debugger/controller.cpp @@ -6,10 +6,13 @@ #include #include #include "common/settings.h" +#include "input_common/main.h" +#include "input_common/tas/tas_input.h" #include "yuzu/configuration/configure_input_player_widget.h" #include "yuzu/debugger/controller.h" -ControllerDialog::ControllerDialog(QWidget* parent) : QWidget(parent, Qt::Dialog) { +ControllerDialog::ControllerDialog(QWidget* parent, InputCommon::InputSubsystem* input_subsystem_) + : QWidget(parent, Qt::Dialog), input_subsystem{input_subsystem_} { setObjectName(QStringLiteral("Controller")); setWindowTitle(tr("Controller P1")); resize(500, 350); @@ -38,6 +41,9 @@ void ControllerDialog::refreshConfiguration() { constexpr std::size_t player = 0; widget->SetPlayerInputRaw(player, players[player].buttons, players[player].analogs); widget->SetControllerType(players[player].controller_type); + ControllerCallback callback{[this](ControllerInput input) { InputController(input); }}; + widget->SetCallBack(callback); + widget->repaint(); widget->SetConnectedStatus(players[player].connected); } @@ -67,3 +73,17 @@ void ControllerDialog::hideEvent(QHideEvent* ev) { widget->SetConnectedStatus(false); QWidget::hideEvent(ev); } + +void ControllerDialog::RefreshTasFile() { + input_subsystem->GetTas()->RefreshTasFile(); +} + +void ControllerDialog::InputController(ControllerInput input) { + u32 buttons = 0; + int index = 0; + for (bool btn : input.button_values) { + buttons += (btn ? 1 : 0) << index; + index++; + } + input_subsystem->GetTas()->RecordInput(buttons, input.axis_values); +} \ No newline at end of file diff --git a/src/yuzu/debugger/controller.h b/src/yuzu/debugger/controller.h index c54750070..659923e1b 100644 --- a/src/yuzu/debugger/controller.h +++ b/src/yuzu/debugger/controller.h @@ -4,18 +4,36 @@ #pragma once +#include #include +#include "common/settings.h" class QAction; class QHideEvent; class QShowEvent; class PlayerControlPreview; +namespace InputCommon { +class InputSubsystem; +} + +struct ControllerInput { + std::array, Settings::NativeAnalog::NUM_STICKS_HID> axis_values{}; + std::array button_values{}; + bool changed{}; +}; + +struct ControllerCallback { + std::function input; + std::function update; +}; + class ControllerDialog : public QWidget { Q_OBJECT public: - explicit ControllerDialog(QWidget* parent = nullptr); + explicit ControllerDialog(QWidget* parent = nullptr, + InputCommon::InputSubsystem* input_subsystem_ = nullptr); /// Returns a QAction that can be used to toggle visibility of this dialog. QAction* toggleViewAction(); @@ -26,6 +44,10 @@ protected: void hideEvent(QHideEvent* ev) override; private: + void RefreshTasFile(); + void InputController(ControllerInput input); QAction* toggle_view_action = nullptr; + QFileSystemWatcher* watcher = nullptr; PlayerControlPreview* widget; + InputCommon::InputSubsystem* input_subsystem; }; diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp index f4e49001d..22489231b 100644 --- a/src/yuzu/main.cpp +++ b/src/yuzu/main.cpp @@ -193,6 +193,7 @@ GMainWindow::GMainWindow() config{std::make_unique()}, vfs{std::make_shared()}, provider{std::make_unique()} { Common::Log::Initialize(); + Settings::values.inputSubsystem = input_subsystem; LoadTranslation(); setAcceptDrops(true); @@ -841,7 +842,7 @@ void GMainWindow::InitializeDebugWidgets() { waitTreeWidget->hide(); debug_menu->addAction(waitTreeWidget->toggleViewAction()); - controller_dialog = new ControllerDialog(this); + controller_dialog = new ControllerDialog(this, input_subsystem.get()); controller_dialog->hide(); debug_menu->addAction(controller_dialog->toggleViewAction()); -- cgit v1.2.3