summaryrefslogtreecommitdiffstats
path: root/src/input_common
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/input_common/CMakeLists.txt2
-rw-r--r--src/input_common/drivers/camera.cpp2
-rw-r--r--src/input_common/drivers/camera.h5
-rw-r--r--src/input_common/drivers/sdl_driver.cpp2
-rw-r--r--src/input_common/drivers/virtual_gamepad.cpp78
-rw-r--r--src/input_common/drivers/virtual_gamepad.h73
-rw-r--r--src/input_common/input_mapping.cpp6
-rw-r--r--src/input_common/main.cpp286
-rw-r--r--src/input_common/main.h7
9 files changed, 263 insertions, 198 deletions
diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index 7932aaab0..f24c89b04 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -20,6 +20,8 @@ add_library(input_common STATIC
drivers/udp_client.h
drivers/virtual_amiibo.cpp
drivers/virtual_amiibo.h
+ drivers/virtual_gamepad.cpp
+ drivers/virtual_gamepad.h
helpers/stick_from_buttons.cpp
helpers/stick_from_buttons.h
helpers/touch_from_buttons.cpp
diff --git a/src/input_common/drivers/camera.cpp b/src/input_common/drivers/camera.cpp
index dceea67e0..fad9177dc 100644
--- a/src/input_common/drivers/camera.cpp
+++ b/src/input_common/drivers/camera.cpp
@@ -17,7 +17,7 @@ Camera::Camera(std::string input_engine_) : InputEngine(std::move(input_engine_)
PreSetController(identifier);
}
-void Camera::SetCameraData(std::size_t width, std::size_t height, std::vector<u32> data) {
+void Camera::SetCameraData(std::size_t width, std::size_t height, std::span<const u32> data) {
const std::size_t desired_width = getImageWidth();
const std::size_t desired_height = getImageHeight();
status.data.resize(desired_width * desired_height);
diff --git a/src/input_common/drivers/camera.h b/src/input_common/drivers/camera.h
index b8a7c75e5..ead3e0fde 100644
--- a/src/input_common/drivers/camera.h
+++ b/src/input_common/drivers/camera.h
@@ -3,6 +3,8 @@
#pragma once
+#include <span>
+
#include "input_common/input_engine.h"
namespace InputCommon {
@@ -15,7 +17,7 @@ class Camera final : public InputEngine {
public:
explicit Camera(std::string input_engine_);
- void SetCameraData(std::size_t width, std::size_t height, std::vector<u32> data);
+ void SetCameraData(std::size_t width, std::size_t height, std::span<const u32> data);
std::size_t getImageWidth() const;
std::size_t getImageHeight() const;
@@ -23,6 +25,7 @@ public:
Common::Input::CameraError SetCameraFormat(const PadIdentifier& identifier_,
Common::Input::CameraFormat camera_format) override;
+private:
Common::Input::CameraStatus status{};
};
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index 8de86b61e..4818bb744 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -16,6 +16,8 @@ Common::UUID GetGUID(SDL_Joystick* joystick) {
const SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
std::array<u8, 16> data{};
std::memcpy(data.data(), guid.data, sizeof(data));
+ // Clear controller name crc
+ std::memset(data.data() + 2, 0, sizeof(u16));
return Common::UUID{data};
}
} // Anonymous namespace
diff --git a/src/input_common/drivers/virtual_gamepad.cpp b/src/input_common/drivers/virtual_gamepad.cpp
new file mode 100644
index 000000000..7db945aa6
--- /dev/null
+++ b/src/input_common/drivers/virtual_gamepad.cpp
@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "input_common/drivers/virtual_gamepad.h"
+
+namespace InputCommon {
+constexpr std::size_t PlayerIndexCount = 10;
+
+VirtualGamepad::VirtualGamepad(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+ for (std::size_t i = 0; i < PlayerIndexCount; i++) {
+ PreSetController(GetIdentifier(i));
+ }
+}
+
+void VirtualGamepad::SetButtonState(std::size_t player_index, int button_id, bool value) {
+ if (player_index > PlayerIndexCount) {
+ return;
+ }
+ const auto identifier = GetIdentifier(player_index);
+ SetButton(identifier, button_id, value);
+}
+
+void VirtualGamepad::SetButtonState(std::size_t player_index, VirtualButton button_id, bool value) {
+ SetButtonState(player_index, static_cast<int>(button_id), value);
+}
+
+void VirtualGamepad::SetStickPosition(std::size_t player_index, int axis_id, float x_value,
+ float y_value) {
+ if (player_index > PlayerIndexCount) {
+ return;
+ }
+ const auto identifier = GetIdentifier(player_index);
+ SetAxis(identifier, axis_id * 2, x_value);
+ SetAxis(identifier, (axis_id * 2) + 1, y_value);
+}
+
+void VirtualGamepad::SetStickPosition(std::size_t player_index, VirtualStick axis_id, float x_value,
+ float y_value) {
+ SetStickPosition(player_index, static_cast<int>(axis_id), x_value, y_value);
+}
+
+void VirtualGamepad::ResetControllers() {
+ for (std::size_t i = 0; i < PlayerIndexCount; i++) {
+ SetStickPosition(i, VirtualStick::Left, 0.0f, 0.0f);
+ SetStickPosition(i, VirtualStick::Right, 0.0f, 0.0f);
+
+ SetButtonState(i, VirtualButton::ButtonA, false);
+ SetButtonState(i, VirtualButton::ButtonB, false);
+ SetButtonState(i, VirtualButton::ButtonX, false);
+ SetButtonState(i, VirtualButton::ButtonY, false);
+ SetButtonState(i, VirtualButton::StickL, false);
+ SetButtonState(i, VirtualButton::StickR, false);
+ SetButtonState(i, VirtualButton::TriggerL, false);
+ SetButtonState(i, VirtualButton::TriggerR, false);
+ SetButtonState(i, VirtualButton::TriggerZL, false);
+ SetButtonState(i, VirtualButton::TriggerZR, false);
+ SetButtonState(i, VirtualButton::ButtonPlus, false);
+ SetButtonState(i, VirtualButton::ButtonMinus, false);
+ SetButtonState(i, VirtualButton::ButtonLeft, false);
+ SetButtonState(i, VirtualButton::ButtonUp, false);
+ SetButtonState(i, VirtualButton::ButtonRight, false);
+ SetButtonState(i, VirtualButton::ButtonDown, false);
+ SetButtonState(i, VirtualButton::ButtonSL, false);
+ SetButtonState(i, VirtualButton::ButtonSR, false);
+ SetButtonState(i, VirtualButton::ButtonHome, false);
+ SetButtonState(i, VirtualButton::ButtonCapture, false);
+ }
+}
+
+PadIdentifier VirtualGamepad::GetIdentifier(std::size_t player_index) const {
+ return {
+ .guid = Common::UUID{},
+ .port = player_index,
+ .pad = 0,
+ };
+}
+
+} // namespace InputCommon
diff --git a/src/input_common/drivers/virtual_gamepad.h b/src/input_common/drivers/virtual_gamepad.h
new file mode 100644
index 000000000..3df91cc6f
--- /dev/null
+++ b/src/input_common/drivers/virtual_gamepad.h
@@ -0,0 +1,73 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "input_common/input_engine.h"
+
+namespace InputCommon {
+
+/**
+ * A virtual controller that is always assigned to the game input
+ */
+class VirtualGamepad final : public InputEngine {
+public:
+ enum class VirtualButton {
+ ButtonA,
+ ButtonB,
+ ButtonX,
+ ButtonY,
+ StickL,
+ StickR,
+ TriggerL,
+ TriggerR,
+ TriggerZL,
+ TriggerZR,
+ ButtonPlus,
+ ButtonMinus,
+ ButtonLeft,
+ ButtonUp,
+ ButtonRight,
+ ButtonDown,
+ ButtonSL,
+ ButtonSR,
+ ButtonHome,
+ ButtonCapture,
+ };
+
+ enum class VirtualStick {
+ Left = 0,
+ Right = 1,
+ };
+
+ explicit VirtualGamepad(std::string input_engine_);
+
+ /**
+ * Sets the status of all buttons bound with the key to pressed
+ * @param player_index the player number that will take this action
+ * @param button_id the id of the button
+ * @param value indicates if the button is pressed or not
+ */
+ void SetButtonState(std::size_t player_index, int button_id, bool value);
+ void SetButtonState(std::size_t player_index, VirtualButton button_id, bool value);
+
+ /**
+ * Sets the status of all buttons bound with the key to released
+ * @param player_index the player number that will take this action
+ * @param axis_id the id of the axis to move
+ * @param x_value the position of the stick in the x axis
+ * @param y_value the position of the stick in the y axis
+ */
+ void SetStickPosition(std::size_t player_index, int axis_id, float x_value, float y_value);
+ void SetStickPosition(std::size_t player_index, VirtualStick axis_id, float x_value,
+ float y_value);
+
+ /// Restores all inputs into the neutral position
+ void ResetControllers();
+
+private:
+ /// Returns the correct identifier corresponding to the player index
+ PadIdentifier GetIdentifier(std::size_t player_index) const;
+};
+
+} // namespace InputCommon
diff --git a/src/input_common/input_mapping.cpp b/src/input_common/input_mapping.cpp
index 0fa4b1ddb..edd5287c1 100644
--- a/src/input_common/input_mapping.cpp
+++ b/src/input_common/input_mapping.cpp
@@ -200,12 +200,6 @@ bool MappingFactory::IsDriverValid(const MappingData& data) const {
return false;
}
// The following drivers don't need to be mapped
- if (data.engine == "tas") {
- return false;
- }
- if (data.engine == "touch") {
- return false;
- }
if (data.engine == "touch_from_button") {
return false;
}
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 942a13535..86deb4c7c 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -12,6 +12,7 @@
#include "input_common/drivers/touch_screen.h"
#include "input_common/drivers/udp_client.h"
#include "input_common/drivers/virtual_amiibo.h"
+#include "input_common/drivers/virtual_gamepad.h"
#include "input_common/helpers/stick_from_buttons.h"
#include "input_common/helpers/touch_from_buttons.h"
#include "input_common/input_engine.h"
@@ -25,73 +26,33 @@
namespace InputCommon {
struct InputSubsystem::Impl {
- void Initialize() {
- mapping_factory = std::make_shared<MappingFactory>();
+ template <typename Engine>
+ void RegisterEngine(std::string name, std::shared_ptr<Engine>& engine) {
MappingCallback mapping_callback{[this](const MappingData& data) { RegisterInput(data); }};
- keyboard = std::make_shared<Keyboard>("keyboard");
- keyboard->SetMappingCallback(mapping_callback);
- keyboard_factory = std::make_shared<InputFactory>(keyboard);
- keyboard_output_factory = std::make_shared<OutputFactory>(keyboard);
- Common::Input::RegisterInputFactory(keyboard->GetEngineName(), keyboard_factory);
- Common::Input::RegisterOutputFactory(keyboard->GetEngineName(), keyboard_output_factory);
-
- mouse = std::make_shared<Mouse>("mouse");
- mouse->SetMappingCallback(mapping_callback);
- mouse_factory = std::make_shared<InputFactory>(mouse);
- mouse_output_factory = std::make_shared<OutputFactory>(mouse);
- Common::Input::RegisterInputFactory(mouse->GetEngineName(), mouse_factory);
- Common::Input::RegisterOutputFactory(mouse->GetEngineName(), mouse_output_factory);
-
- touch_screen = std::make_shared<TouchScreen>("touch");
- touch_screen_factory = std::make_shared<InputFactory>(touch_screen);
- Common::Input::RegisterInputFactory(touch_screen->GetEngineName(), touch_screen_factory);
-
- gcadapter = std::make_shared<GCAdapter>("gcpad");
- gcadapter->SetMappingCallback(mapping_callback);
- gcadapter_input_factory = std::make_shared<InputFactory>(gcadapter);
- gcadapter_output_factory = std::make_shared<OutputFactory>(gcadapter);
- Common::Input::RegisterInputFactory(gcadapter->GetEngineName(), gcadapter_input_factory);
- Common::Input::RegisterOutputFactory(gcadapter->GetEngineName(), gcadapter_output_factory);
-
- udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
- udp_client->SetMappingCallback(mapping_callback);
- udp_client_input_factory = std::make_shared<InputFactory>(udp_client);
- udp_client_output_factory = std::make_shared<OutputFactory>(udp_client);
- Common::Input::RegisterInputFactory(udp_client->GetEngineName(), udp_client_input_factory);
- Common::Input::RegisterOutputFactory(udp_client->GetEngineName(),
- udp_client_output_factory);
-
- tas_input = std::make_shared<TasInput::Tas>("tas");
- tas_input->SetMappingCallback(mapping_callback);
- tas_input_factory = std::make_shared<InputFactory>(tas_input);
- tas_output_factory = std::make_shared<OutputFactory>(tas_input);
- Common::Input::RegisterInputFactory(tas_input->GetEngineName(), tas_input_factory);
- Common::Input::RegisterOutputFactory(tas_input->GetEngineName(), tas_output_factory);
-
- camera = std::make_shared<Camera>("camera");
- camera->SetMappingCallback(mapping_callback);
- camera_input_factory = std::make_shared<InputFactory>(camera);
- camera_output_factory = std::make_shared<OutputFactory>(camera);
- Common::Input::RegisterInputFactory(camera->GetEngineName(), camera_input_factory);
- Common::Input::RegisterOutputFactory(camera->GetEngineName(), camera_output_factory);
-
- virtual_amiibo = std::make_shared<VirtualAmiibo>("virtual_amiibo");
- virtual_amiibo->SetMappingCallback(mapping_callback);
- virtual_amiibo_input_factory = std::make_shared<InputFactory>(virtual_amiibo);
- virtual_amiibo_output_factory = std::make_shared<OutputFactory>(virtual_amiibo);
- Common::Input::RegisterInputFactory(virtual_amiibo->GetEngineName(),
- virtual_amiibo_input_factory);
- Common::Input::RegisterOutputFactory(virtual_amiibo->GetEngineName(),
- virtual_amiibo_output_factory);
+ engine = std::make_shared<Engine>(name);
+ engine->SetMappingCallback(mapping_callback);
+
+ std::shared_ptr<InputFactory> input_factory = std::make_shared<InputFactory>(engine);
+ std::shared_ptr<OutputFactory> output_factory = std::make_shared<OutputFactory>(engine);
+ Common::Input::RegisterInputFactory(engine->GetEngineName(), std::move(input_factory));
+ Common::Input::RegisterOutputFactory(engine->GetEngineName(), std::move(output_factory));
+ }
+
+ void Initialize() {
+ mapping_factory = std::make_shared<MappingFactory>();
+ RegisterEngine("keyboard", keyboard);
+ RegisterEngine("mouse", mouse);
+ RegisterEngine("touch", touch_screen);
+ RegisterEngine("gcpad", gcadapter);
+ RegisterEngine("cemuhookudp", udp_client);
+ RegisterEngine("tas", tas_input);
+ RegisterEngine("camera", camera);
+ RegisterEngine("virtual_amiibo", virtual_amiibo);
+ RegisterEngine("virtual_gamepad", virtual_gamepad);
#ifdef HAVE_SDL2
- sdl = std::make_shared<SDLDriver>("sdl");
- sdl->SetMappingCallback(mapping_callback);
- sdl_input_factory = std::make_shared<InputFactory>(sdl);
- sdl_output_factory = std::make_shared<OutputFactory>(sdl);
- Common::Input::RegisterInputFactory(sdl->GetEngineName(), sdl_input_factory);
- Common::Input::RegisterOutputFactory(sdl->GetEngineName(), sdl_output_factory);
+ RegisterEngine("sdl", sdl);
#endif
Common::Input::RegisterInputFactory("touch_from_button",
@@ -100,42 +61,25 @@ struct InputSubsystem::Impl {
std::make_shared<StickFromButton>());
}
- void Shutdown() {
- Common::Input::UnregisterInputFactory(keyboard->GetEngineName());
- Common::Input::UnregisterOutputFactory(keyboard->GetEngineName());
- keyboard.reset();
-
- Common::Input::UnregisterInputFactory(mouse->GetEngineName());
- Common::Input::UnregisterOutputFactory(mouse->GetEngineName());
- mouse.reset();
-
- Common::Input::UnregisterInputFactory(touch_screen->GetEngineName());
- touch_screen.reset();
-
- Common::Input::UnregisterInputFactory(gcadapter->GetEngineName());
- Common::Input::UnregisterOutputFactory(gcadapter->GetEngineName());
- gcadapter.reset();
-
- Common::Input::UnregisterInputFactory(udp_client->GetEngineName());
- Common::Input::UnregisterOutputFactory(udp_client->GetEngineName());
- udp_client.reset();
-
- Common::Input::UnregisterInputFactory(tas_input->GetEngineName());
- Common::Input::UnregisterOutputFactory(tas_input->GetEngineName());
- tas_input.reset();
-
- Common::Input::UnregisterInputFactory(camera->GetEngineName());
- Common::Input::UnregisterOutputFactory(camera->GetEngineName());
- camera.reset();
-
- Common::Input::UnregisterInputFactory(virtual_amiibo->GetEngineName());
- Common::Input::UnregisterOutputFactory(virtual_amiibo->GetEngineName());
- virtual_amiibo.reset();
+ template <typename Engine>
+ void UnregisterEngine(std::shared_ptr<Engine>& engine) {
+ Common::Input::UnregisterInputFactory(engine->GetEngineName());
+ Common::Input::UnregisterOutputFactory(engine->GetEngineName());
+ engine.reset();
+ }
+ void Shutdown() {
+ UnregisterEngine(keyboard);
+ UnregisterEngine(mouse);
+ UnregisterEngine(touch_screen);
+ UnregisterEngine(gcadapter);
+ UnregisterEngine(udp_client);
+ UnregisterEngine(tas_input);
+ UnregisterEngine(camera);
+ UnregisterEngine(virtual_amiibo);
+ UnregisterEngine(virtual_gamepad);
#ifdef HAVE_SDL2
- Common::Input::UnregisterInputFactory(sdl->GetEngineName());
- Common::Input::UnregisterOutputFactory(sdl->GetEngineName());
- sdl.reset();
+ UnregisterEngine(sdl);
#endif
Common::Input::UnregisterInputFactory("touch_from_button");
@@ -163,117 +107,86 @@ struct InputSubsystem::Impl {
return devices;
}
- [[nodiscard]] AnalogMapping GetAnalogMappingForDevice(
+ [[nodiscard]] std::shared_ptr<InputEngine> GetInputEngine(
const Common::ParamPackage& params) const {
if (!params.Has("engine") || params.Get("engine", "") == "any") {
- return {};
+ return nullptr;
}
const std::string engine = params.Get("engine", "");
+ if (engine == keyboard->GetEngineName()) {
+ return keyboard;
+ }
if (engine == mouse->GetEngineName()) {
- return mouse->GetAnalogMappingForDevice(params);
+ return mouse;
}
if (engine == gcadapter->GetEngineName()) {
- return gcadapter->GetAnalogMappingForDevice(params);
+ return gcadapter;
}
if (engine == udp_client->GetEngineName()) {
- return udp_client->GetAnalogMappingForDevice(params);
- }
- if (engine == tas_input->GetEngineName()) {
- return tas_input->GetAnalogMappingForDevice(params);
+ return udp_client;
}
#ifdef HAVE_SDL2
if (engine == sdl->GetEngineName()) {
- return sdl->GetAnalogMappingForDevice(params);
+ return sdl;
}
#endif
- return {};
+ return nullptr;
}
- [[nodiscard]] ButtonMapping GetButtonMappingForDevice(
+ [[nodiscard]] AnalogMapping GetAnalogMappingForDevice(
const Common::ParamPackage& params) const {
- if (!params.Has("engine") || params.Get("engine", "") == "any") {
+ const auto input_engine = GetInputEngine(params);
+
+ if (input_engine == nullptr) {
return {};
}
- const std::string engine = params.Get("engine", "");
- if (engine == gcadapter->GetEngineName()) {
- return gcadapter->GetButtonMappingForDevice(params);
- }
- if (engine == udp_client->GetEngineName()) {
- return udp_client->GetButtonMappingForDevice(params);
- }
- if (engine == tas_input->GetEngineName()) {
- return tas_input->GetButtonMappingForDevice(params);
- }
-#ifdef HAVE_SDL2
- if (engine == sdl->GetEngineName()) {
- return sdl->GetButtonMappingForDevice(params);
+
+ return input_engine->GetAnalogMappingForDevice(params);
+ }
+
+ [[nodiscard]] ButtonMapping GetButtonMappingForDevice(
+ const Common::ParamPackage& params) const {
+ const auto input_engine = GetInputEngine(params);
+
+ if (input_engine == nullptr) {
+ return {};
}
-#endif
- return {};
+
+ return input_engine->GetButtonMappingForDevice(params);
}
[[nodiscard]] MotionMapping GetMotionMappingForDevice(
const Common::ParamPackage& params) const {
- if (!params.Has("engine") || params.Get("engine", "") == "any") {
+ const auto input_engine = GetInputEngine(params);
+
+ if (input_engine == nullptr) {
return {};
}
- const std::string engine = params.Get("engine", "");
- if (engine == udp_client->GetEngineName()) {
- return udp_client->GetMotionMappingForDevice(params);
- }
-#ifdef HAVE_SDL2
- if (engine == sdl->GetEngineName()) {
- return sdl->GetMotionMappingForDevice(params);
- }
-#endif
- return {};
+
+ return input_engine->GetMotionMappingForDevice(params);
}
Common::Input::ButtonNames GetButtonName(const Common::ParamPackage& params) const {
if (!params.Has("engine") || params.Get("engine", "") == "any") {
return Common::Input::ButtonNames::Undefined;
}
- const std::string engine = params.Get("engine", "");
- if (engine == mouse->GetEngineName()) {
- return mouse->GetUIName(params);
- }
- if (engine == gcadapter->GetEngineName()) {
- return gcadapter->GetUIName(params);
- }
- if (engine == udp_client->GetEngineName()) {
- return udp_client->GetUIName(params);
- }
- if (engine == tas_input->GetEngineName()) {
- return tas_input->GetUIName(params);
- }
-#ifdef HAVE_SDL2
- if (engine == sdl->GetEngineName()) {
- return sdl->GetUIName(params);
+ const auto input_engine = GetInputEngine(params);
+
+ if (input_engine == nullptr) {
+ return Common::Input::ButtonNames::Invalid;
}
-#endif
- return Common::Input::ButtonNames::Invalid;
+
+ return input_engine->GetUIName(params);
}
bool IsStickInverted(const Common::ParamPackage& params) {
- const std::string engine = params.Get("engine", "");
- if (engine == mouse->GetEngineName()) {
- return mouse->IsStickInverted(params);
- }
- if (engine == gcadapter->GetEngineName()) {
- return gcadapter->IsStickInverted(params);
- }
- if (engine == udp_client->GetEngineName()) {
- return udp_client->IsStickInverted(params);
- }
- if (engine == tas_input->GetEngineName()) {
- return tas_input->IsStickInverted(params);
- }
-#ifdef HAVE_SDL2
- if (engine == sdl->GetEngineName()) {
- return sdl->IsStickInverted(params);
+ const auto input_engine = GetInputEngine(params);
+
+ if (input_engine == nullptr) {
+ return false;
}
-#endif
- return false;
+
+ return input_engine->IsStickInverted(params);
}
bool IsController(const Common::ParamPackage& params) {
@@ -290,6 +203,9 @@ struct InputSubsystem::Impl {
if (engine == tas_input->GetEngineName()) {
return true;
}
+ if (engine == virtual_gamepad->GetEngineName()) {
+ return true;
+ }
#ifdef HAVE_SDL2
if (engine == sdl->GetEngineName()) {
return true;
@@ -338,28 +254,10 @@ struct InputSubsystem::Impl {
std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
std::shared_ptr<Camera> camera;
std::shared_ptr<VirtualAmiibo> virtual_amiibo;
-
- std::shared_ptr<InputFactory> keyboard_factory;
- std::shared_ptr<InputFactory> mouse_factory;
- std::shared_ptr<InputFactory> gcadapter_input_factory;
- std::shared_ptr<InputFactory> touch_screen_factory;
- std::shared_ptr<InputFactory> udp_client_input_factory;
- std::shared_ptr<InputFactory> tas_input_factory;
- std::shared_ptr<InputFactory> camera_input_factory;
- std::shared_ptr<InputFactory> virtual_amiibo_input_factory;
-
- std::shared_ptr<OutputFactory> keyboard_output_factory;
- std::shared_ptr<OutputFactory> mouse_output_factory;
- std::shared_ptr<OutputFactory> gcadapter_output_factory;
- std::shared_ptr<OutputFactory> udp_client_output_factory;
- std::shared_ptr<OutputFactory> tas_output_factory;
- std::shared_ptr<OutputFactory> camera_output_factory;
- std::shared_ptr<OutputFactory> virtual_amiibo_output_factory;
+ std::shared_ptr<VirtualGamepad> virtual_gamepad;
#ifdef HAVE_SDL2
std::shared_ptr<SDLDriver> sdl;
- std::shared_ptr<InputFactory> sdl_input_factory;
- std::shared_ptr<OutputFactory> sdl_output_factory;
#endif
};
@@ -423,6 +321,14 @@ const VirtualAmiibo* InputSubsystem::GetVirtualAmiibo() const {
return impl->virtual_amiibo.get();
}
+VirtualGamepad* InputSubsystem::GetVirtualGamepad() {
+ return impl->virtual_gamepad.get();
+}
+
+const VirtualGamepad* InputSubsystem::GetVirtualGamepad() const {
+ return impl->virtual_gamepad.get();
+}
+
std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
return impl->GetInputDevices();
}
diff --git a/src/input_common/main.h b/src/input_common/main.h
index 6218c37f6..1207d786c 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -34,6 +34,7 @@ class Keyboard;
class Mouse;
class TouchScreen;
class VirtualAmiibo;
+class VirtualGamepad;
struct MappingData;
} // namespace InputCommon
@@ -108,6 +109,12 @@ public:
/// Retrieves the underlying virtual amiibo input device.
[[nodiscard]] const VirtualAmiibo* GetVirtualAmiibo() const;
+ /// Retrieves the underlying virtual gamepad input device.
+ [[nodiscard]] VirtualGamepad* GetVirtualGamepad();
+
+ /// Retrieves the underlying virtual gamepad input device.
+ [[nodiscard]] const VirtualGamepad* GetVirtualGamepad() 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 `engine` field
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-14 19:07:35 +0200