summaryrefslogtreecommitdiffstats
path: root/src/input_common
diff options
context:
space:
mode:
Diffstat (limited to 'src/input_common')
-rw-r--r--src/input_common/CMakeLists.txt4
-rw-r--r--src/input_common/main.cpp48
-rw-r--r--src/input_common/main.h23
-rw-r--r--src/input_common/tas/tas_input.cpp340
-rw-r--r--src/input_common/tas/tas_input.h163
-rw-r--r--src/input_common/tas/tas_poller.cpp101
-rw-r--r--src/input_common/tas/tas_poller.h43
7 files changed, 722 insertions, 0 deletions
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<Input::MotionDevice>("mouse", mousemotion);
mousetouch = std::make_shared<MouseTouchFactory>(mouse);
Input::RegisterFactory<Input::TouchDevice>("mouse", mousetouch);
+
+ tas = std::make_shared<TasInput::Tas>();
+ tasbuttons = std::make_shared<TasButtonFactory>(tas);
+ Input::RegisterFactory<Input::ButtonDevice>("tas", tasbuttons);
+ tasanalog = std::make_shared<TasAnalogFactory>(tas);
+ Input::RegisterFactory<Input::AnalogDevice>("tas", tasanalog);
}
void Shutdown() {
@@ -94,12 +102,19 @@ struct InputSubsystem::Impl {
mouseanalog.reset();
mousemotion.reset();
mousetouch.reset();
+
+ Input::UnregisterFactory<Input::ButtonDevice>("tas");
+ Input::UnregisterFactory<Input::AnalogDevice>("tas");
+
+ tasbuttons.reset();
+ tasanalog.reset();
}
[[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
std::vector<Common::ParamPackage> 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<MouseAnalogFactory> mouseanalog;
std::shared_ptr<MouseMotionFactory> mousemotion;
std::shared_ptr<MouseTouchFactory> mousetouch;
+ std::shared_ptr<TasButtonFactory> tasbuttons;
+ std::shared_ptr<TasAnalogFactory> tasanalog;
std::shared_ptr<CemuhookUDP::Client> udp;
std::shared_ptr<GCAdapter::Adapter> gcadapter;
std::shared_ptr<MouseInput::Mouse> mouse;
+ std::shared_ptr<TasInput::Tas> tas;
};
InputSubsystem::InputSubsystem() : impl{std::make_unique<Impl>()} {}
@@ -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<Common::ParamPackage> 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 <chrono>
+#include <cstring>
+#include <functional>
+#include <random>
+#include <regex>
+#include <thread>
+#include <boost/asio.hpp>
+
+#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<std::string> 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<std::pair<float, float>, 2> axes) {
+ lastInput = {buttons, flipY(axes[0]), flipY(axes[1])};
+}
+
+std::pair<float, float> Tas::flipY(std::pair<float, float> 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<TasData, PLAYER_NUMBER> 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<std::string> 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<u32>(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<int>(x * 32767));
+ line += ";";
+ line += std::to_string(static_cast<int>(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<TasButton>(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<std::pair<Settings::NativeButton::Values, TasButton>, 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<int>(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<int>(TasAxes::StickX));
+ left_analog_params.Set("axis_y", static_cast<int>(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<int>(TasAxes::SubstickX));
+ right_analog_params.Set("axis_y", static_cast<int>(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 <array>
+#include <mutex>
+#include <thread>
+
+#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<float, float>;
+
+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<std::pair<std::string, TasButton>, 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<float, 4> axis{};
+};
+
+class Tas {
+public:
+ Tas();
+ ~Tas();
+
+ static std::string buttonsToString(u32 button) {
+ std::string returns;
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_A)) != 0)
+ returns += ", A";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_B)) != 0)
+ returns += ", B";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_X)) != 0)
+ returns += ", X";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_Y)) != 0)
+ returns += ", Y";
+ if ((button & static_cast<u32>(TasInput::TasButton::STICK_L)) != 0)
+ returns += ", STICK_L";
+ if ((button & static_cast<u32>(TasInput::TasButton::STICK_R)) != 0)
+ returns += ", STICK_R";
+ if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_L)) != 0)
+ returns += ", TRIGGER_L";
+ if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_R)) != 0)
+ returns += ", TRIGGER_R";
+ if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_ZL)) != 0)
+ returns += ", TRIGGER_ZL";
+ if ((button & static_cast<u32>(TasInput::TasButton::TRIGGER_ZR)) != 0)
+ returns += ", TRIGGER_ZR";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_PLUS)) != 0)
+ returns += ", PLUS";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_MINUS)) != 0)
+ returns += ", MINUS";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_LEFT)) != 0)
+ returns += ", LEFT";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_UP)) != 0)
+ returns += ", UP";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_RIGHT)) != 0)
+ returns += ", RIGHT";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_DOWN)) != 0)
+ returns += ", DOWN";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_SL)) != 0)
+ returns += ", SL";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_SR)) != 0)
+ returns += ", SR";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_HOME)) != 0)
+ returns += ", HOME";
+ if ((button & static_cast<u32>(TasInput::TasButton::BUTTON_CAPTURE)) != 0)
+ returns += ", CAPTURE";
+ return returns.length() != 0 ? returns.substr(2) : "";
+ }
+
+ void RefreshTasFile();
+ void LoadTasFiles();
+ void RecordInput(u32 buttons, std::array<std::pair<float, float>, 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<float, float> flipY(std::pair<float, float> old) const;
+
+ size_t scriptLength{0};
+ std::array<TasData, PLAYER_NUMBER> tas_data;
+ bool update_thread_running{true};
+ bool refresh_tas_fle{false};
+ std::array<std::vector<TASCommand>, PLAYER_NUMBER> newCommands{};
+ std::vector<TASCommand> 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 <mutex>
+#include <utility>
+
+#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<TasInput::Tas> tas_input_)
+ : tas_input(std::move(tas_input_)) {}
+
+std::unique_ptr<Input::ButtonDevice> 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<TasButton>(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<float, float> 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<float, float> 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<TasInput::Tas> 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<Input::AnalogDevice> TasAnalogFactory::Create(const Common::ParamPackage& params) {
+ const auto pad = static_cast<u32>(params.Get("pad", 0));
+ const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
+ const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
+
+ return std::make_unique<TasAnalog>(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 <memory>
+#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<Input::ButtonDevice> {
+public:
+ explicit TasButtonFactory(std::shared_ptr<TasInput::Tas> 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<Input::ButtonDevice> Create(const Common::ParamPackage& params) override;
+
+private:
+ std::shared_ptr<TasInput::Tas> tas_input;
+};
+
+/// An analog device factory that creates analog devices from mouse
+class TasAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
+public:
+ explicit TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_);
+
+ std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override;
+
+private:
+ std::shared_ptr<TasInput::Tas> tas_input;
+};
+
+} // namespace InputCommon
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-31 07:50:10 +0100