kraken: Address comments from review
start lion review
This commit is contained in:
german77
Narr the Reg
parent
61d9eb9f69
commit
2b1b0c2a30
31 changed files with 534 additions and 466 deletions
|
|
@ -248,7 +248,7 @@ bool GCAdapter::Setup() {
|
|||
std::size_t port = 0;
|
||||
for (GCController& pad : pads) {
|
||||
pad.identifier = {
|
||||
.guid = Common::UUID{""},
|
||||
.guid = Common::UUID{Common::INVALID_UUID},
|
||||
.port = port++,
|
||||
.pad = 0,
|
||||
};
|
||||
|
|
@ -325,8 +325,8 @@ bool GCAdapter::GetGCEndpoint(libusb_device* device) {
|
|||
return true;
|
||||
}
|
||||
|
||||
Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
|
||||
const Input::VibrationStatus vibration) {
|
||||
Common::Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
|
||||
const Common::Input::VibrationStatus vibration) {
|
||||
const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f;
|
||||
const auto processed_amplitude =
|
||||
static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);
|
||||
|
|
@ -334,9 +334,9 @@ Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
|
|||
pads[identifier.port].rumble_amplitude = processed_amplitude;
|
||||
|
||||
if (!rumble_enabled) {
|
||||
return Input::VibrationError::Disabled;
|
||||
return Common::Input::VibrationError::Disabled;
|
||||
}
|
||||
return Input::VibrationError::None;
|
||||
return Common::Input::VibrationError::None;
|
||||
}
|
||||
|
||||
void GCAdapter::UpdateVibrations() {
|
||||
|
|
|
|||
|
|
@ -4,8 +4,11 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <stop_token>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
|
||||
#include "input_common/input_engine.h"
|
||||
|
|
@ -24,8 +27,8 @@ public:
|
|||
explicit GCAdapter(const std::string input_engine_);
|
||||
~GCAdapter();
|
||||
|
||||
Input::VibrationError SetRumble(const PadIdentifier& identifier,
|
||||
const Input::VibrationStatus vibration) override;
|
||||
Common::Input::VibrationError SetRumble(
|
||||
const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
|
||||
|
||||
/// Used for automapping features
|
||||
std::vector<Common::ParamPackage> GetInputDevices() const override;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ public:
|
|||
|
||||
private:
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{""},
|
||||
.guid = Common::UUID{Common::INVALID_UUID},
|
||||
.port = 0,
|
||||
.pad = 0,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ private:
|
|||
void StopPanning();
|
||||
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{""},
|
||||
.guid = Common::UUID{Common::INVALID_UUID},
|
||||
.port = 0,
|
||||
.pad = 0,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ public:
|
|||
return motion;
|
||||
}
|
||||
|
||||
bool RumblePlay(const Input::VibrationStatus vibration) {
|
||||
bool RumblePlay(const Common::Input::VibrationStatus vibration) {
|
||||
constexpr u32 rumble_max_duration_ms = 1000;
|
||||
if (sdl_controller) {
|
||||
return SDL_GameControllerRumble(
|
||||
|
|
@ -515,8 +515,8 @@ std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
|
|||
}
|
||||
return devices;
|
||||
}
|
||||
Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
|
||||
const Input::VibrationStatus vibration) {
|
||||
Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
|
||||
const Common::Input::VibrationStatus vibration) {
|
||||
const auto joystick =
|
||||
GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port));
|
||||
const auto process_amplitude_exp = [](f32 amplitude, f32 factor) {
|
||||
|
|
@ -527,7 +527,7 @@ Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
|
|||
f32 factor = 0.35f;
|
||||
|
||||
// If vibration is set as a linear output use a flatter value
|
||||
if (vibration.type == Input::VibrationAmplificationType::Linear) {
|
||||
if (vibration.type == Common::Input::VibrationAmplificationType::Linear) {
|
||||
factor = 0.5f;
|
||||
}
|
||||
|
||||
|
|
@ -536,19 +536,19 @@ Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
|
|||
factor = 1.0f;
|
||||
}
|
||||
|
||||
const Input::VibrationStatus new_vibration{
|
||||
const Common::Input::VibrationStatus new_vibration{
|
||||
.low_amplitude = process_amplitude_exp(vibration.low_amplitude, factor),
|
||||
.low_frequency = vibration.low_frequency,
|
||||
.high_amplitude = process_amplitude_exp(vibration.high_amplitude, factor),
|
||||
.high_frequency = vibration.high_frequency,
|
||||
.type = Input::VibrationAmplificationType::Exponential,
|
||||
.type = Common::Input::VibrationAmplificationType::Exponential,
|
||||
};
|
||||
|
||||
if (!joystick->RumblePlay(new_vibration)) {
|
||||
return Input::VibrationError::Unknown;
|
||||
return Common::Input::VibrationError::Unknown;
|
||||
}
|
||||
|
||||
return Input::VibrationError::None;
|
||||
return Common::Input::VibrationError::None;
|
||||
}
|
||||
Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid,
|
||||
s32 axis, float value) const {
|
||||
|
|
|
|||
|
|
@ -58,8 +58,8 @@ public:
|
|||
std::string GetHatButtonName(u8 direction_value) const override;
|
||||
u8 GetHatButtonId(const std::string direction_name) const override;
|
||||
|
||||
Input::VibrationError SetRumble(const PadIdentifier& identifier,
|
||||
const Input::VibrationStatus vibration) override;
|
||||
Common::Input::VibrationError SetRumble(
|
||||
const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
|
||||
|
||||
private:
|
||||
void InitJoystick(int joystick_index);
|
||||
|
|
@ -105,9 +105,6 @@ private:
|
|||
/// Returns true if the button is on the left joycon
|
||||
bool IsButtonOnLeftSide(Settings::NativeButton::Values button) const;
|
||||
|
||||
// Set to true if SDL supports game controller subsystem
|
||||
bool has_gamecontroller = false;
|
||||
|
||||
/// Map of GUID of a list of corresponding virtual Joysticks
|
||||
std::unordered_map<std::string, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
|
||||
std::mutex joystick_map_mutex;
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ public:
|
|||
|
||||
private:
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{""},
|
||||
.guid = Common::UUID{Common::INVALID_UUID},
|
||||
.port = 0,
|
||||
.pad = 0,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -10,25 +10,27 @@
|
|||
|
||||
namespace InputCommon {
|
||||
|
||||
class Stick final : public Input::InputDevice {
|
||||
class Stick final : public Common::Input::InputDevice {
|
||||
public:
|
||||
using Button = std::unique_ptr<Input::InputDevice>;
|
||||
using Button = std::unique_ptr<Common::Input::InputDevice>;
|
||||
|
||||
Stick(Button up_, Button down_, Button left_, Button right_, Button modifier_,
|
||||
float modifier_scale_, float modifier_angle_)
|
||||
: up(std::move(up_)), down(std::move(down_)), left(std::move(left_)),
|
||||
right(std::move(right_)), modifier(std::move(modifier_)), modifier_scale(modifier_scale_),
|
||||
modifier_angle(modifier_angle_) {
|
||||
Input::InputCallback button_up_callback{
|
||||
[this](Input::CallbackStatus callback_) { UpdateUpButtonStatus(callback_); }};
|
||||
Input::InputCallback button_down_callback{
|
||||
[this](Input::CallbackStatus callback_) { UpdateDownButtonStatus(callback_); }};
|
||||
Input::InputCallback button_left_callback{
|
||||
[this](Input::CallbackStatus callback_) { UpdateLeftButtonStatus(callback_); }};
|
||||
Input::InputCallback button_right_callback{
|
||||
[this](Input::CallbackStatus callback_) { UpdateRightButtonStatus(callback_); }};
|
||||
Input::InputCallback button_modifier_callback{
|
||||
[this](Input::CallbackStatus callback_) { UpdateModButtonStatus(callback_); }};
|
||||
Common::Input::InputCallback button_up_callback{
|
||||
[this](Common::Input::CallbackStatus callback_) { UpdateUpButtonStatus(callback_); }};
|
||||
Common::Input::InputCallback button_down_callback{
|
||||
[this](Common::Input::CallbackStatus callback_) { UpdateDownButtonStatus(callback_); }};
|
||||
Common::Input::InputCallback button_left_callback{
|
||||
[this](Common::Input::CallbackStatus callback_) { UpdateLeftButtonStatus(callback_); }};
|
||||
Common::Input::InputCallback button_right_callback{
|
||||
[this](Common::Input::CallbackStatus callback_) {
|
||||
UpdateRightButtonStatus(callback_);
|
||||
}};
|
||||
Common::Input::InputCallback button_modifier_callback{
|
||||
[this](Common::Input::CallbackStatus callback_) { UpdateModButtonStatus(callback_); }};
|
||||
up->SetCallback(button_up_callback);
|
||||
down->SetCallback(button_down_callback);
|
||||
left->SetCallback(button_left_callback);
|
||||
|
|
@ -129,27 +131,27 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
void UpdateUpButtonStatus(Input::CallbackStatus button_callback) {
|
||||
void UpdateUpButtonStatus(Common::Input::CallbackStatus button_callback) {
|
||||
up_status = button_callback.button_status.value;
|
||||
UpdateStatus();
|
||||
}
|
||||
|
||||
void UpdateDownButtonStatus(Input::CallbackStatus button_callback) {
|
||||
void UpdateDownButtonStatus(Common::Input::CallbackStatus button_callback) {
|
||||
down_status = button_callback.button_status.value;
|
||||
UpdateStatus();
|
||||
}
|
||||
|
||||
void UpdateLeftButtonStatus(Input::CallbackStatus button_callback) {
|
||||
void UpdateLeftButtonStatus(Common::Input::CallbackStatus button_callback) {
|
||||
left_status = button_callback.button_status.value;
|
||||
UpdateStatus();
|
||||
}
|
||||
|
||||
void UpdateRightButtonStatus(Input::CallbackStatus button_callback) {
|
||||
void UpdateRightButtonStatus(Common::Input::CallbackStatus button_callback) {
|
||||
right_status = button_callback.button_status.value;
|
||||
UpdateStatus();
|
||||
}
|
||||
|
||||
void UpdateModButtonStatus(Input::CallbackStatus button_callback) {
|
||||
void UpdateModButtonStatus(Common::Input::CallbackStatus button_callback) {
|
||||
modifier_status = button_callback.button_status.value;
|
||||
UpdateStatus();
|
||||
}
|
||||
|
|
@ -193,8 +195,8 @@ public:
|
|||
}
|
||||
|
||||
last_update = now;
|
||||
Input::CallbackStatus status{
|
||||
.type = Input::InputType::Stick,
|
||||
Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Stick,
|
||||
.stick_status = GetStatus(),
|
||||
};
|
||||
TriggerOnChange(status);
|
||||
|
|
@ -209,15 +211,15 @@ public:
|
|||
}
|
||||
|
||||
void SoftUpdate() override {
|
||||
Input::CallbackStatus status{
|
||||
.type = Input::InputType::Stick,
|
||||
Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Stick,
|
||||
.stick_status = GetStatus(),
|
||||
};
|
||||
TriggerOnChange(status);
|
||||
}
|
||||
|
||||
Input::StickStatus GetStatus() const {
|
||||
Input::StickStatus status{};
|
||||
Common::Input::StickStatus GetStatus() const {
|
||||
Common::Input::StickStatus status{};
|
||||
status.x.properties = properties;
|
||||
status.y.properties = properties;
|
||||
if (Settings::values.emulate_analog_keyboard) {
|
||||
|
|
@ -263,19 +265,23 @@ private:
|
|||
bool left_status;
|
||||
bool right_status;
|
||||
bool modifier_status;
|
||||
const Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
|
||||
const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
|
||||
std::chrono::time_point<std::chrono::steady_clock> last_update;
|
||||
};
|
||||
|
||||
std::unique_ptr<Input::InputDevice> StickFromButton::Create(const Common::ParamPackage& params) {
|
||||
std::unique_ptr<Common::Input::InputDevice> StickFromButton::Create(
|
||||
const Common::ParamPackage& params) {
|
||||
const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
|
||||
auto up = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("up", null_engine));
|
||||
auto down = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("down", null_engine));
|
||||
auto left = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("left", null_engine));
|
||||
auto right =
|
||||
Input::CreateDeviceFromString<Input::InputDevice>(params.Get("right", null_engine));
|
||||
auto modifier =
|
||||
Input::CreateDeviceFromString<Input::InputDevice>(params.Get("modifier", null_engine));
|
||||
auto up = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
|
||||
params.Get("up", null_engine));
|
||||
auto down = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
|
||||
params.Get("down", null_engine));
|
||||
auto left = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
|
||||
params.Get("left", null_engine));
|
||||
auto right = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
|
||||
params.Get("right", null_engine));
|
||||
auto modifier = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
|
||||
params.Get("modifier", null_engine));
|
||||
auto modifier_scale = params.Get("modifier_scale", 0.5f);
|
||||
auto modifier_angle = params.Get("modifier_angle", 5.5f);
|
||||
return std::make_unique<Stick>(std::move(up), std::move(down), std::move(left),
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ namespace InputCommon {
|
|||
* An analog device factory that takes direction button devices and combines them into a analog
|
||||
* device.
|
||||
*/
|
||||
class StickFromButton final : public Input::Factory<Input::InputDevice> {
|
||||
class StickFromButton final : public Common::Input::Factory<Common::Input::InputDevice> {
|
||||
public:
|
||||
/**
|
||||
* Creates an analog device from direction button devices
|
||||
|
|
@ -24,7 +24,7 @@ public:
|
|||
* - "modifier": a serialized ParamPackage for creating a button device as the modifier
|
||||
* - "modifier_scale": a float for the multiplier the modifier gives to the position
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
|
||||
std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
|
||||
};
|
||||
|
||||
} // namespace InputCommon
|
||||
|
|
|
|||
|
|
@ -9,22 +9,22 @@
|
|||
|
||||
namespace InputCommon {
|
||||
|
||||
class TouchFromButtonDevice final : public Input::InputDevice {
|
||||
class TouchFromButtonDevice final : public Common::Input::InputDevice {
|
||||
public:
|
||||
using Button = std::unique_ptr<Input::InputDevice>;
|
||||
using Button = std::unique_ptr<Common::Input::InputDevice>;
|
||||
TouchFromButtonDevice(Button button_, u32 touch_id_, float x_, float y_)
|
||||
: button(std::move(button_)), touch_id(touch_id_), x(x_), y(y_) {
|
||||
Input::InputCallback button_up_callback{
|
||||
[this](Input::CallbackStatus callback_) { UpdateButtonStatus(callback_); }};
|
||||
Common::Input::InputCallback button_up_callback{
|
||||
[this](Common::Input::CallbackStatus callback_) { UpdateButtonStatus(callback_); }};
|
||||
button->SetCallback(button_up_callback);
|
||||
button->ForceUpdate();
|
||||
}
|
||||
|
||||
Input::TouchStatus GetStatus(bool pressed) const {
|
||||
const Input::ButtonStatus button_status{
|
||||
Common::Input::TouchStatus GetStatus(bool pressed) const {
|
||||
const Common::Input::ButtonStatus button_status{
|
||||
.value = pressed,
|
||||
};
|
||||
Input::TouchStatus status{
|
||||
Common::Input::TouchStatus status{
|
||||
.pressed = button_status,
|
||||
.x = {},
|
||||
.y = {},
|
||||
|
|
@ -42,9 +42,9 @@ public:
|
|||
return status;
|
||||
}
|
||||
|
||||
void UpdateButtonStatus(Input::CallbackStatus button_callback) {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Touch,
|
||||
void UpdateButtonStatus(Common::Input::CallbackStatus button_callback) {
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Touch,
|
||||
.touch_status = GetStatus(button_callback.button_status.value),
|
||||
};
|
||||
TriggerOnChange(status);
|
||||
|
|
@ -55,13 +55,14 @@ private:
|
|||
const u32 touch_id;
|
||||
const float x;
|
||||
const float y;
|
||||
const Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
|
||||
const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
|
||||
};
|
||||
|
||||
std::unique_ptr<Input::InputDevice> TouchFromButton::Create(const Common::ParamPackage& params) {
|
||||
std::unique_ptr<Common::Input::InputDevice> TouchFromButton::Create(
|
||||
const Common::ParamPackage& params) {
|
||||
const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
|
||||
auto button =
|
||||
Input::CreateDeviceFromString<Input::InputDevice>(params.Get("button", null_engine));
|
||||
auto button = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
|
||||
params.Get("button", null_engine));
|
||||
const auto touch_id = params.Get("touch_id", 0);
|
||||
const float x = params.Get("x", 0.0f) / 1280.0f;
|
||||
const float y = params.Get("y", 0.0f) / 720.0f;
|
||||
|
|
|
|||
|
|
@ -11,12 +11,12 @@ namespace InputCommon {
|
|||
/**
|
||||
* A touch device factory that takes a list of button devices and combines them into a touch device.
|
||||
*/
|
||||
class TouchFromButton final : public Input::Factory<Input::InputDevice> {
|
||||
class TouchFromButton final : public Common::Input::Factory<Common::Input::InputDevice> {
|
||||
public:
|
||||
/**
|
||||
* Creates a touch device from a list of button devices
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
|
||||
std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
|
||||
};
|
||||
|
||||
} // namespace InputCommon
|
||||
|
|
|
|||
|
|
@ -116,22 +116,22 @@ public:
|
|||
|
||||
// Sets a led pattern for a controller
|
||||
virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier,
|
||||
[[maybe_unused]] const Input::LedStatus led_status) {
|
||||
[[maybe_unused]] const Common::Input::LedStatus led_status) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Sets rumble to a controller
|
||||
virtual Input::VibrationError SetRumble(
|
||||
virtual Common::Input::VibrationError SetRumble(
|
||||
[[maybe_unused]] const PadIdentifier& identifier,
|
||||
[[maybe_unused]] const Input::VibrationStatus vibration) {
|
||||
return Input::VibrationError::NotSupported;
|
||||
[[maybe_unused]] const Common::Input::VibrationStatus vibration) {
|
||||
return Common::Input::VibrationError::NotSupported;
|
||||
}
|
||||
|
||||
// Sets polling mode to a controller
|
||||
virtual Input::PollingError SetPollingMode(
|
||||
virtual Common::Input::PollingError SetPollingMode(
|
||||
[[maybe_unused]] const PadIdentifier& identifier,
|
||||
[[maybe_unused]] const Input::PollingMode vibration) {
|
||||
return Input::PollingError::NotSupported;
|
||||
[[maybe_unused]] const Common::Input::PollingMode vibration) {
|
||||
return Common::Input::PollingError::NotSupported;
|
||||
}
|
||||
|
||||
// Returns the engine name
|
||||
|
|
|
|||
|
|
@ -10,13 +10,13 @@
|
|||
|
||||
namespace InputCommon {
|
||||
|
||||
class DummyInput final : public Input::InputDevice {
|
||||
class DummyInput final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit DummyInput() {}
|
||||
~DummyInput() {}
|
||||
};
|
||||
|
||||
class InputFromButton final : public Input::InputDevice {
|
||||
class InputFromButton final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromButton(PadIdentifier identifier_, u32 button_, bool toggle_, bool inverted_,
|
||||
InputEngine* input_engine_)
|
||||
|
|
@ -37,7 +37,7 @@ public:
|
|||
input_engine->DeleteCallback(callback_key);
|
||||
}
|
||||
|
||||
Input::ButtonStatus GetStatus() const {
|
||||
Common::Input::ButtonStatus GetStatus() const {
|
||||
return {
|
||||
.value = input_engine->GetButton(identifier, button),
|
||||
.inverted = inverted,
|
||||
|
|
@ -46,8 +46,8 @@ public:
|
|||
}
|
||||
|
||||
void ForceUpdate() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Button,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Button,
|
||||
.button_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -56,8 +56,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Button,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Button,
|
||||
.button_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -77,7 +77,7 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromHatButton final : public Input::InputDevice {
|
||||
class InputFromHatButton final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromHatButton(PadIdentifier identifier_, u32 button_, u8 direction_, bool toggle_,
|
||||
bool inverted_, InputEngine* input_engine_)
|
||||
|
|
@ -98,7 +98,7 @@ public:
|
|||
input_engine->DeleteCallback(callback_key);
|
||||
}
|
||||
|
||||
Input::ButtonStatus GetStatus() const {
|
||||
Common::Input::ButtonStatus GetStatus() const {
|
||||
return {
|
||||
.value = input_engine->GetHatButton(identifier, button, direction),
|
||||
.inverted = inverted,
|
||||
|
|
@ -107,8 +107,8 @@ public:
|
|||
}
|
||||
|
||||
void ForceUpdate() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Button,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Button,
|
||||
.button_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -117,8 +117,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Button,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Button,
|
||||
.button_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -139,11 +139,12 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromStick final : public Input::InputDevice {
|
||||
class InputFromStick final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromStick(PadIdentifier identifier_, u32 axis_x_, u32 axis_y_,
|
||||
Input::AnalogProperties properties_x_,
|
||||
Input::AnalogProperties properties_y_, InputEngine* input_engine_)
|
||||
Common::Input::AnalogProperties properties_x_,
|
||||
Common::Input::AnalogProperties properties_y_,
|
||||
InputEngine* input_engine_)
|
||||
: identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
|
||||
properties_y(properties_y_), input_engine(input_engine_) {
|
||||
UpdateCallback engine_callback{[this]() { OnChange(); }};
|
||||
|
|
@ -170,8 +171,8 @@ public:
|
|||
input_engine->DeleteCallback(callback_key_y);
|
||||
}
|
||||
|
||||
Input::StickStatus GetStatus() const {
|
||||
Input::StickStatus status;
|
||||
Common::Input::StickStatus GetStatus() const {
|
||||
Common::Input::StickStatus status;
|
||||
status.x = {
|
||||
.raw_value = input_engine->GetAxis(identifier, axis_x),
|
||||
.properties = properties_x,
|
||||
|
|
@ -184,8 +185,8 @@ public:
|
|||
}
|
||||
|
||||
void ForceUpdate() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Stick,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Stick,
|
||||
.stick_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -195,8 +196,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Stick,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Stick,
|
||||
.stick_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -212,8 +213,8 @@ private:
|
|||
const PadIdentifier identifier;
|
||||
const u32 axis_x;
|
||||
const u32 axis_y;
|
||||
const Input::AnalogProperties properties_x;
|
||||
const Input::AnalogProperties properties_y;
|
||||
const Common::Input::AnalogProperties properties_x;
|
||||
const Common::Input::AnalogProperties properties_y;
|
||||
int callback_key_x;
|
||||
int callback_key_y;
|
||||
float last_axis_x_value;
|
||||
|
|
@ -221,12 +222,13 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromTouch final : public Input::InputDevice {
|
||||
class InputFromTouch final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromTouch(PadIdentifier identifier_, u32 touch_id_, u32 button_, bool toggle_,
|
||||
bool inverted_, u32 axis_x_, u32 axis_y_,
|
||||
Input::AnalogProperties properties_x_,
|
||||
Input::AnalogProperties properties_y_, InputEngine* input_engine_)
|
||||
Common::Input::AnalogProperties properties_x_,
|
||||
Common::Input::AnalogProperties properties_y_,
|
||||
InputEngine* input_engine_)
|
||||
: identifier(identifier_), touch_id(touch_id_), button(button_), toggle(toggle_),
|
||||
inverted(inverted_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
|
||||
properties_y(properties_y_), input_engine(input_engine_) {
|
||||
|
|
@ -263,8 +265,8 @@ public:
|
|||
input_engine->DeleteCallback(callback_key_y);
|
||||
}
|
||||
|
||||
Input::TouchStatus GetStatus() const {
|
||||
Input::TouchStatus status;
|
||||
Common::Input::TouchStatus GetStatus() const {
|
||||
Common::Input::TouchStatus status;
|
||||
status.id = touch_id;
|
||||
status.pressed = {
|
||||
.value = input_engine->GetButton(identifier, button),
|
||||
|
|
@ -283,8 +285,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Touch,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Touch,
|
||||
.touch_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -306,8 +308,8 @@ private:
|
|||
const bool inverted;
|
||||
const u32 axis_x;
|
||||
const u32 axis_y;
|
||||
const Input::AnalogProperties properties_x;
|
||||
const Input::AnalogProperties properties_y;
|
||||
const Common::Input::AnalogProperties properties_x;
|
||||
const Common::Input::AnalogProperties properties_y;
|
||||
int callback_key_button;
|
||||
int callback_key_x;
|
||||
int callback_key_y;
|
||||
|
|
@ -317,10 +319,10 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromTrigger final : public Input::InputDevice {
|
||||
class InputFromTrigger final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromTrigger(PadIdentifier identifier_, u32 button_, bool toggle_, bool inverted_,
|
||||
u32 axis_, Input::AnalogProperties properties_,
|
||||
u32 axis_, Common::Input::AnalogProperties properties_,
|
||||
InputEngine* input_engine_)
|
||||
: identifier(identifier_), button(button_), toggle(toggle_), inverted(inverted_),
|
||||
axis(axis_), properties(properties_), input_engine(input_engine_) {
|
||||
|
|
@ -348,8 +350,8 @@ public:
|
|||
input_engine->DeleteCallback(axis_callback_key);
|
||||
}
|
||||
|
||||
Input::TriggerStatus GetStatus() const {
|
||||
const Input::AnalogStatus analog_status{
|
||||
Common::Input::TriggerStatus GetStatus() const {
|
||||
const Common::Input::AnalogStatus analog_status{
|
||||
.raw_value = input_engine->GetAxis(identifier, axis),
|
||||
.properties = properties,
|
||||
};
|
||||
|
|
@ -360,8 +362,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Trigger,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Trigger,
|
||||
.trigger_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -379,7 +381,7 @@ private:
|
|||
const bool toggle;
|
||||
const bool inverted;
|
||||
const u32 axis;
|
||||
const Input::AnalogProperties properties;
|
||||
const Common::Input::AnalogProperties properties;
|
||||
int callback_key_button;
|
||||
int axis_callback_key;
|
||||
bool last_button_value;
|
||||
|
|
@ -387,10 +389,11 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromAnalog final : public Input::InputDevice {
|
||||
class InputFromAnalog final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromAnalog(PadIdentifier identifier_, u32 axis_,
|
||||
Input::AnalogProperties properties_, InputEngine* input_engine_)
|
||||
Common::Input::AnalogProperties properties_,
|
||||
InputEngine* input_engine_)
|
||||
: identifier(identifier_), axis(axis_), properties(properties_),
|
||||
input_engine(input_engine_) {
|
||||
UpdateCallback engine_callback{[this]() { OnChange(); }};
|
||||
|
|
@ -408,7 +411,7 @@ public:
|
|||
input_engine->DeleteCallback(callback_key);
|
||||
}
|
||||
|
||||
Input::AnalogStatus GetStatus() const {
|
||||
Common::Input::AnalogStatus GetStatus() const {
|
||||
return {
|
||||
.raw_value = input_engine->GetAxis(identifier, axis),
|
||||
.properties = properties,
|
||||
|
|
@ -416,8 +419,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Analog,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Analog,
|
||||
.analog_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -430,13 +433,13 @@ public:
|
|||
private:
|
||||
const PadIdentifier identifier;
|
||||
const u32 axis;
|
||||
const Input::AnalogProperties properties;
|
||||
const Common::Input::AnalogProperties properties;
|
||||
int callback_key;
|
||||
float last_axis_value;
|
||||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromBattery final : public Input::InputDevice {
|
||||
class InputFromBattery final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromBattery(PadIdentifier identifier_, InputEngine* input_engine_)
|
||||
: identifier(identifier_), input_engine(input_engine_) {
|
||||
|
|
@ -447,7 +450,7 @@ public:
|
|||
.index = 0,
|
||||
.callback = engine_callback,
|
||||
};
|
||||
last_battery_value = Input::BatteryStatus::Charging;
|
||||
last_battery_value = Common::Input::BatteryStatus::Charging;
|
||||
callback_key = input_engine->SetCallback(input_identifier);
|
||||
}
|
||||
|
||||
|
|
@ -455,13 +458,13 @@ public:
|
|||
input_engine->DeleteCallback(callback_key);
|
||||
}
|
||||
|
||||
Input::BatteryStatus GetStatus() const {
|
||||
return static_cast<Input::BatteryLevel>(input_engine->GetBattery(identifier));
|
||||
Common::Input::BatteryStatus GetStatus() const {
|
||||
return static_cast<Common::Input::BatteryLevel>(input_engine->GetBattery(identifier));
|
||||
}
|
||||
|
||||
void ForceUpdate() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Battery,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Battery,
|
||||
.battery_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -470,8 +473,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Battery,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Battery,
|
||||
.battery_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -484,11 +487,11 @@ public:
|
|||
private:
|
||||
const PadIdentifier identifier;
|
||||
int callback_key;
|
||||
Input::BatteryStatus last_battery_value;
|
||||
Common::Input::BatteryStatus last_battery_value;
|
||||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromMotion final : public Input::InputDevice {
|
||||
class InputFromMotion final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromMotion(PadIdentifier identifier_, u32 motion_sensor_,
|
||||
InputEngine* input_engine_)
|
||||
|
|
@ -507,10 +510,10 @@ public:
|
|||
input_engine->DeleteCallback(callback_key);
|
||||
}
|
||||
|
||||
Input::MotionStatus GetStatus() const {
|
||||
Common::Input::MotionStatus GetStatus() const {
|
||||
const auto basic_motion = input_engine->GetMotion(identifier, motion_sensor);
|
||||
Input::MotionStatus status{};
|
||||
const Input::AnalogProperties properties = {
|
||||
Common::Input::MotionStatus status{};
|
||||
const Common::Input::AnalogProperties properties = {
|
||||
.deadzone = 0.001f,
|
||||
.range = 1.0f,
|
||||
.offset = 0.0f,
|
||||
|
|
@ -526,8 +529,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Motion,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Motion,
|
||||
.motion_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -541,12 +544,13 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class InputFromAxisMotion final : public Input::InputDevice {
|
||||
class InputFromAxisMotion final : public Common::Input::InputDevice {
|
||||
public:
|
||||
explicit InputFromAxisMotion(PadIdentifier identifier_, u32 axis_x_, u32 axis_y_, u32 axis_z_,
|
||||
Input::AnalogProperties properties_x_,
|
||||
Input::AnalogProperties properties_y_,
|
||||
Input::AnalogProperties properties_z_, InputEngine* input_engine_)
|
||||
Common::Input::AnalogProperties properties_x_,
|
||||
Common::Input::AnalogProperties properties_y_,
|
||||
Common::Input::AnalogProperties properties_z_,
|
||||
InputEngine* input_engine_)
|
||||
: identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), axis_z(axis_z_),
|
||||
properties_x(properties_x_), properties_y(properties_y_), properties_z(properties_z_),
|
||||
input_engine(input_engine_) {
|
||||
|
|
@ -583,8 +587,8 @@ public:
|
|||
input_engine->DeleteCallback(callback_key_z);
|
||||
}
|
||||
|
||||
Input::MotionStatus GetStatus() const {
|
||||
Input::MotionStatus status{};
|
||||
Common::Input::MotionStatus GetStatus() const {
|
||||
Common::Input::MotionStatus status{};
|
||||
status.gyro.x = {
|
||||
.raw_value = input_engine->GetAxis(identifier, axis_x),
|
||||
.properties = properties_x,
|
||||
|
|
@ -601,8 +605,8 @@ public:
|
|||
}
|
||||
|
||||
void ForceUpdate() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Motion,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Motion,
|
||||
.motion_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -613,8 +617,8 @@ public:
|
|||
}
|
||||
|
||||
void OnChange() {
|
||||
const Input::CallbackStatus status{
|
||||
.type = Input::InputType::Motion,
|
||||
const Common::Input::CallbackStatus status{
|
||||
.type = Common::Input::InputType::Motion,
|
||||
.motion_status = GetStatus(),
|
||||
};
|
||||
|
||||
|
|
@ -633,9 +637,9 @@ private:
|
|||
const u32 axis_x;
|
||||
const u32 axis_y;
|
||||
const u32 axis_z;
|
||||
const Input::AnalogProperties properties_x;
|
||||
const Input::AnalogProperties properties_y;
|
||||
const Input::AnalogProperties properties_z;
|
||||
const Common::Input::AnalogProperties properties_x;
|
||||
const Common::Input::AnalogProperties properties_y;
|
||||
const Common::Input::AnalogProperties properties_z;
|
||||
int callback_key_x;
|
||||
int callback_key_y;
|
||||
int callback_key_z;
|
||||
|
|
@ -645,20 +649,21 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
class OutputFromIdentifier final : public Input::OutputDevice {
|
||||
class OutputFromIdentifier final : public Common::Input::OutputDevice {
|
||||
public:
|
||||
explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
|
||||
: identifier(identifier_), input_engine(input_engine_) {}
|
||||
|
||||
virtual void SetLED(Input::LedStatus led_status) {
|
||||
virtual void SetLED(Common::Input::LedStatus led_status) {
|
||||
input_engine->SetLeds(identifier, led_status);
|
||||
}
|
||||
|
||||
virtual Input::VibrationError SetVibration(Input::VibrationStatus vibration_status) {
|
||||
virtual Common::Input::VibrationError SetVibration(
|
||||
Common::Input::VibrationStatus vibration_status) {
|
||||
return input_engine->SetRumble(identifier, vibration_status);
|
||||
}
|
||||
|
||||
virtual Input::PollingError SetPollingMode(Input::PollingMode polling_mode) {
|
||||
virtual Common::Input::PollingError SetPollingMode(Common::Input::PollingMode polling_mode) {
|
||||
return input_engine->SetPollingMode(identifier, polling_mode);
|
||||
}
|
||||
|
||||
|
|
@ -667,7 +672,7 @@ private:
|
|||
InputEngine* input_engine;
|
||||
};
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateButtonDevice(
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateButtonDevice(
|
||||
const Common::ParamPackage& params) {
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{params.Get("guid", "")},
|
||||
|
|
@ -690,7 +695,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateButtonDevice(
|
|||
input_engine.get());
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateHatButtonDevice(
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateHatButtonDevice(
|
||||
const Common::ParamPackage& params) {
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{params.Get("guid", "")},
|
||||
|
|
@ -709,7 +714,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateHatButtonDevice(
|
|||
input_engine.get());
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateStickDevice(
|
||||
const Common::ParamPackage& params) {
|
||||
const auto deadzone = std::clamp(params.Get("deadzone", 0.15f), 0.0f, 1.0f);
|
||||
const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
|
||||
|
|
@ -721,7 +726,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
|
|||
};
|
||||
|
||||
const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
|
||||
const Input::AnalogProperties properties_x = {
|
||||
const Common::Input::AnalogProperties properties_x = {
|
||||
.deadzone = deadzone,
|
||||
.range = range,
|
||||
.threshold = threshold,
|
||||
|
|
@ -730,7 +735,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
|
|||
};
|
||||
|
||||
const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
|
||||
const Input::AnalogProperties properties_y = {
|
||||
const Common::Input::AnalogProperties properties_y = {
|
||||
.deadzone = deadzone,
|
||||
.range = range,
|
||||
.threshold = threshold,
|
||||
|
|
@ -744,7 +749,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
|
|||
input_engine.get());
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateAnalogDevice(
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateAnalogDevice(
|
||||
const Common::ParamPackage& params) {
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{params.Get("guid", "")},
|
||||
|
|
@ -753,7 +758,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateAnalogDevice(
|
|||
};
|
||||
|
||||
const auto axis = static_cast<u32>(params.Get("axis", 0));
|
||||
const Input::AnalogProperties properties = {
|
||||
const Common::Input::AnalogProperties properties = {
|
||||
.deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f),
|
||||
.range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f),
|
||||
.threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f),
|
||||
|
|
@ -765,7 +770,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateAnalogDevice(
|
|||
return std::make_unique<InputFromAnalog>(identifier, axis, properties, input_engine.get());
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateTriggerDevice(
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTriggerDevice(
|
||||
const Common::ParamPackage& params) {
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{params.Get("guid", "")},
|
||||
|
|
@ -778,7 +783,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTriggerDevice(
|
|||
const auto inverted = params.Get("inverted", false);
|
||||
|
||||
const auto axis = static_cast<u32>(params.Get("axis", 0));
|
||||
const Input::AnalogProperties properties = {
|
||||
const Common::Input::AnalogProperties properties = {
|
||||
.deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f),
|
||||
.range = std::clamp(params.Get("range", 1.0f), 0.25f, 2.50f),
|
||||
.threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f),
|
||||
|
|
@ -792,7 +797,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTriggerDevice(
|
|||
properties, input_engine.get());
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
|
||||
const Common::ParamPackage& params) {
|
||||
const auto touch_id = params.Get("touch_id", 0);
|
||||
const auto deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f);
|
||||
|
|
@ -809,7 +814,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
|
|||
const auto inverted = params.Get("inverted", false);
|
||||
|
||||
const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
|
||||
const Input::AnalogProperties properties_x = {
|
||||
const Common::Input::AnalogProperties properties_x = {
|
||||
.deadzone = deadzone,
|
||||
.range = range,
|
||||
.threshold = threshold,
|
||||
|
|
@ -818,7 +823,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
|
|||
};
|
||||
|
||||
const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
|
||||
const Input::AnalogProperties properties_y = {
|
||||
const Common::Input::AnalogProperties properties_y = {
|
||||
.deadzone = deadzone,
|
||||
.range = range,
|
||||
.threshold = threshold,
|
||||
|
|
@ -833,7 +838,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
|
|||
axis_y, properties_x, properties_y, input_engine.get());
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateBatteryDevice(
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateBatteryDevice(
|
||||
const Common::ParamPackage& params) {
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{params.Get("guid", "")},
|
||||
|
|
@ -845,7 +850,8 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateBatteryDevice(
|
|||
return std::make_unique<InputFromBattery>(identifier, input_engine.get());
|
||||
}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::ParamPackage params) {
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
|
||||
Common::ParamPackage params) {
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{params.Get("guid", "")},
|
||||
.port = static_cast<std::size_t>(params.Get("port", 0)),
|
||||
|
|
@ -864,7 +870,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
|
|||
const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
|
||||
|
||||
const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
|
||||
const Input::AnalogProperties properties_x = {
|
||||
const Common::Input::AnalogProperties properties_x = {
|
||||
.deadzone = deadzone,
|
||||
.range = range,
|
||||
.threshold = threshold,
|
||||
|
|
@ -873,7 +879,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
|
|||
};
|
||||
|
||||
const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
|
||||
const Input::AnalogProperties properties_y = {
|
||||
const Common::Input::AnalogProperties properties_y = {
|
||||
.deadzone = deadzone,
|
||||
.range = range,
|
||||
.threshold = threshold,
|
||||
|
|
@ -882,7 +888,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
|
|||
};
|
||||
|
||||
const auto axis_z = static_cast<u32>(params.Get("axis_z", 1));
|
||||
const Input::AnalogProperties properties_z = {
|
||||
const Common::Input::AnalogProperties properties_z = {
|
||||
.deadzone = deadzone,
|
||||
.range = range,
|
||||
.threshold = threshold,
|
||||
|
|
@ -900,7 +906,8 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
|
|||
InputFactory::InputFactory(std::shared_ptr<InputEngine> input_engine_)
|
||||
: input_engine(std::move(input_engine_)) {}
|
||||
|
||||
std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPackage& params) {
|
||||
std::unique_ptr<Common::Input::InputDevice> InputFactory::Create(
|
||||
const Common::ParamPackage& params) {
|
||||
if (params.Has("battery")) {
|
||||
return CreateBatteryDevice(params);
|
||||
}
|
||||
|
|
@ -935,7 +942,8 @@ std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPack
|
|||
OutputFactory::OutputFactory(std::shared_ptr<InputEngine> input_engine_)
|
||||
: input_engine(std::move(input_engine_)) {}
|
||||
|
||||
std::unique_ptr<Input::OutputDevice> OutputFactory::Create(const Common::ParamPackage& params) {
|
||||
std::unique_ptr<Common::Input::OutputDevice> OutputFactory::Create(
|
||||
const Common::ParamPackage& params) {
|
||||
const PadIdentifier identifier = {
|
||||
.guid = Common::UUID{params.Get("guid", "")},
|
||||
.port = static_cast<std::size_t>(params.Get("port", 0)),
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ class InputEngine;
|
|||
* An Input factory. It receives input events and forward them to all input devices it created.
|
||||
*/
|
||||
|
||||
class OutputFactory final : public Input::Factory<Input::OutputDevice> {
|
||||
class OutputFactory final : public Common::Input::Factory<Common::Input::OutputDevice> {
|
||||
public:
|
||||
explicit OutputFactory(std::shared_ptr<InputEngine> input_engine_);
|
||||
|
||||
|
|
@ -29,13 +29,14 @@ public:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique ouput device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::OutputDevice> Create(const Common::ParamPackage& params) override;
|
||||
std::unique_ptr<Common::Input::OutputDevice> Create(
|
||||
const Common::ParamPackage& params) override;
|
||||
|
||||
private:
|
||||
std::shared_ptr<InputEngine> input_engine;
|
||||
};
|
||||
|
||||
class InputFactory final : public Input::Factory<Input::InputDevice> {
|
||||
class InputFactory final : public Common::Input::Factory<Common::Input::InputDevice> {
|
||||
public:
|
||||
explicit InputFactory(std::shared_ptr<InputEngine> input_engine_);
|
||||
|
||||
|
|
@ -64,7 +65,7 @@ public:
|
|||
* @param - "battery": Only used as a placeholder to set the input type
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
|
||||
std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
|
||||
|
||||
private:
|
||||
/**
|
||||
|
|
@ -79,7 +80,8 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateButtonDevice(const Common::ParamPackage& params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateButtonDevice(
|
||||
const Common::ParamPackage& params);
|
||||
|
||||
/**
|
||||
* Creates a hat button device from the parameters given.
|
||||
|
|
@ -93,7 +95,8 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateHatButtonDevice(const Common::ParamPackage& params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateHatButtonDevice(
|
||||
const Common::ParamPackage& params);
|
||||
|
||||
/**
|
||||
* Creates a stick device from the parameters given.
|
||||
|
|
@ -112,7 +115,8 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateStickDevice(const Common::ParamPackage& params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateStickDevice(
|
||||
const Common::ParamPackage& params);
|
||||
|
||||
/**
|
||||
* Creates an analog device from the parameters given.
|
||||
|
|
@ -128,7 +132,8 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateAnalogDevice(const Common::ParamPackage& params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateAnalogDevice(
|
||||
const Common::ParamPackage& params);
|
||||
|
||||
/**
|
||||
* Creates a trigger device from the parameters given.
|
||||
|
|
@ -148,7 +153,8 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateTriggerDevice(const Common::ParamPackage& params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateTriggerDevice(
|
||||
const Common::ParamPackage& params);
|
||||
|
||||
/**
|
||||
* Creates a touch device from the parameters given.
|
||||
|
|
@ -171,7 +177,8 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateTouchDevice(const Common::ParamPackage& params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateTouchDevice(
|
||||
const Common::ParamPackage& params);
|
||||
|
||||
/**
|
||||
* Creates a battery device from the parameters given.
|
||||
|
|
@ -181,7 +188,8 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateBatteryDevice(const Common::ParamPackage& params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateBatteryDevice(
|
||||
const Common::ParamPackage& params);
|
||||
|
||||
/**
|
||||
* Creates a motion device from the parameters given.
|
||||
|
|
@ -202,7 +210,7 @@ private:
|
|||
* @param - "pad": slot of the connected controller
|
||||
* @return an unique input device with the parameters specified
|
||||
*/
|
||||
std::unique_ptr<Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
|
||||
std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
|
||||
|
||||
std::shared_ptr<InputEngine> input_engine;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -33,89 +33,97 @@ struct InputSubsystem::Impl {
|
|||
keyboard->SetMappingCallback(mapping_callback);
|
||||
keyboard_factory = std::make_shared<InputFactory>(keyboard);
|
||||
keyboard_output_factory = std::make_shared<OutputFactory>(keyboard);
|
||||
Input::RegisterFactory<Input::InputDevice>(keyboard->GetEngineName(), keyboard_factory);
|
||||
Input::RegisterFactory<Input::OutputDevice>(keyboard->GetEngineName(),
|
||||
keyboard_output_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(keyboard->GetEngineName(),
|
||||
keyboard_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::OutputDevice>(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);
|
||||
Input::RegisterFactory<Input::InputDevice>(mouse->GetEngineName(), mouse_factory);
|
||||
Input::RegisterFactory<Input::OutputDevice>(mouse->GetEngineName(), mouse_output_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(mouse->GetEngineName(),
|
||||
mouse_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::OutputDevice>(mouse->GetEngineName(),
|
||||
mouse_output_factory);
|
||||
|
||||
touch_screen = std::make_shared<TouchScreen>("touch");
|
||||
touch_screen_factory = std::make_shared<InputFactory>(touch_screen);
|
||||
Input::RegisterFactory<Input::InputDevice>(touch_screen->GetEngineName(),
|
||||
touch_screen_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(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);
|
||||
Input::RegisterFactory<Input::InputDevice>(gcadapter->GetEngineName(),
|
||||
gcadapter_input_factory);
|
||||
Input::RegisterFactory<Input::OutputDevice>(gcadapter->GetEngineName(),
|
||||
gcadapter_output_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(gcadapter->GetEngineName(),
|
||||
gcadapter_input_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::OutputDevice>(gcadapter->GetEngineName(),
|
||||
gcadapter_output_factory);
|
||||
|
||||
udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
|
||||
udp_client->SetMappingCallback(mapping_callback);
|
||||
udp_client_factory = std::make_shared<InputFactory>(udp_client);
|
||||
Input::RegisterFactory<Input::InputDevice>(udp_client->GetEngineName(), udp_client_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName(),
|
||||
udp_client_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);
|
||||
Input::RegisterFactory<Input::InputDevice>(tas_input->GetEngineName(), tas_input_factory);
|
||||
Input::RegisterFactory<Input::OutputDevice>(tas_input->GetEngineName(), tas_output_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(tas_input->GetEngineName(),
|
||||
tas_input_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::OutputDevice>(tas_input->GetEngineName(),
|
||||
tas_output_factory);
|
||||
|
||||
#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);
|
||||
Input::RegisterFactory<Input::InputDevice>(sdl->GetEngineName(), sdl_input_factory);
|
||||
Input::RegisterFactory<Input::OutputDevice>(sdl->GetEngineName(), sdl_output_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(sdl->GetEngineName(),
|
||||
sdl_input_factory);
|
||||
Common::Input::RegisterFactory<Common::Input::OutputDevice>(sdl->GetEngineName(),
|
||||
sdl_output_factory);
|
||||
#endif
|
||||
|
||||
Input::RegisterFactory<Input::InputDevice>("touch_from_button",
|
||||
std::make_shared<TouchFromButton>());
|
||||
Input::RegisterFactory<Input::InputDevice>("analog_from_button",
|
||||
std::make_shared<StickFromButton>());
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(
|
||||
"touch_from_button", std::make_shared<TouchFromButton>());
|
||||
Common::Input::RegisterFactory<Common::Input::InputDevice>(
|
||||
"analog_from_button", std::make_shared<StickFromButton>());
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
Input::UnregisterFactory<Input::InputDevice>(keyboard->GetEngineName());
|
||||
Input::UnregisterFactory<Input::OutputDevice>(keyboard->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>(keyboard->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::OutputDevice>(keyboard->GetEngineName());
|
||||
keyboard.reset();
|
||||
|
||||
Input::UnregisterFactory<Input::InputDevice>(mouse->GetEngineName());
|
||||
Input::UnregisterFactory<Input::OutputDevice>(mouse->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>(mouse->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::OutputDevice>(mouse->GetEngineName());
|
||||
mouse.reset();
|
||||
|
||||
Input::UnregisterFactory<Input::InputDevice>(touch_screen->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>(touch_screen->GetEngineName());
|
||||
touch_screen.reset();
|
||||
|
||||
Input::UnregisterFactory<Input::InputDevice>(gcadapter->GetEngineName());
|
||||
Input::UnregisterFactory<Input::OutputDevice>(gcadapter->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>(gcadapter->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::OutputDevice>(gcadapter->GetEngineName());
|
||||
gcadapter.reset();
|
||||
|
||||
Input::UnregisterFactory<Input::InputDevice>(udp_client->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName());
|
||||
udp_client.reset();
|
||||
|
||||
Input::UnregisterFactory<Input::InputDevice>(tas_input->GetEngineName());
|
||||
Input::UnregisterFactory<Input::OutputDevice>(tas_input->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>(tas_input->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::OutputDevice>(tas_input->GetEngineName());
|
||||
tas_input.reset();
|
||||
|
||||
#ifdef HAVE_SDL2
|
||||
Input::UnregisterFactory<Input::InputDevice>(sdl->GetEngineName());
|
||||
Input::UnregisterFactory<Input::OutputDevice>(sdl->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>(sdl->GetEngineName());
|
||||
Common::Input::UnregisterFactory<Common::Input::OutputDevice>(sdl->GetEngineName());
|
||||
sdl.reset();
|
||||
#endif
|
||||
|
||||
Input::UnregisterFactory<Input::InputDevice>("touch_from_button");
|
||||
Input::UnregisterFactory<Input::InputDevice>("analog_from_button");
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>("touch_from_button");
|
||||
Common::Input::UnregisterFactory<Common::Input::InputDevice>("analog_from_button");
|
||||
}
|
||||
|
||||
[[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue