2021-09-20 12:56:55 -07:00
|
|
|
// Copyright 2017 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <functional>
|
|
|
|
#include <memory>
|
|
|
|
#include <string>
|
|
|
|
#include <unordered_map>
|
|
|
|
#include <utility>
|
|
|
|
#include "common/logging/log.h"
|
|
|
|
#include "common/param_package.h"
|
2021-11-02 21:50:30 -07:00
|
|
|
#include "common/uuid.h"
|
2021-09-20 12:56:55 -07:00
|
|
|
|
2021-10-30 20:23:10 -07:00
|
|
|
namespace Common::Input {
|
2021-09-20 12:56:55 -07:00
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Type of data that is expected to recieve or send
|
2021-09-20 12:56:55 -07:00
|
|
|
enum class InputType {
|
|
|
|
None,
|
|
|
|
Battery,
|
|
|
|
Button,
|
|
|
|
Stick,
|
|
|
|
Analog,
|
|
|
|
Trigger,
|
|
|
|
Motion,
|
|
|
|
Touch,
|
|
|
|
Color,
|
|
|
|
Vibration,
|
|
|
|
Nfc,
|
|
|
|
Ir,
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Internal battery charge level
|
2021-11-01 13:17:53 -07:00
|
|
|
enum class BatteryLevel : u32 {
|
2021-10-18 22:12:24 -07:00
|
|
|
None,
|
2021-09-20 12:56:55 -07:00
|
|
|
Empty,
|
|
|
|
Critical,
|
|
|
|
Low,
|
|
|
|
Medium,
|
|
|
|
Full,
|
|
|
|
Charging,
|
|
|
|
};
|
|
|
|
|
2021-10-10 22:43:11 -07:00
|
|
|
enum class PollingMode {
|
2021-11-03 21:35:45 -07:00
|
|
|
// Constant polling of buttons, analogs and motion data
|
2021-10-10 22:43:11 -07:00
|
|
|
Active,
|
2021-11-03 21:35:45 -07:00
|
|
|
// Only update on button change, digital analogs
|
2021-10-10 22:43:11 -07:00
|
|
|
Pasive,
|
2021-11-03 21:35:45 -07:00
|
|
|
// Enable near field communication polling
|
|
|
|
NFC,
|
|
|
|
// Enable infrared camera polling
|
2021-10-10 22:43:11 -07:00
|
|
|
IR,
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Vibration reply from the controller
|
2021-10-10 22:43:11 -07:00
|
|
|
enum class VibrationError {
|
|
|
|
None,
|
|
|
|
NotSupported,
|
|
|
|
Disabled,
|
|
|
|
Unknown,
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Polling mode reply from the controller
|
2021-10-10 22:43:11 -07:00
|
|
|
enum class PollingError {
|
|
|
|
None,
|
|
|
|
NotSupported,
|
|
|
|
Unknown,
|
|
|
|
};
|
|
|
|
|
2021-10-20 12:41:56 -07:00
|
|
|
// Hint for amplification curve to be used
|
|
|
|
enum class VibrationAmplificationType {
|
|
|
|
Linear,
|
|
|
|
Exponential,
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Analog properties for calibration
|
2021-09-20 12:56:55 -07:00
|
|
|
struct AnalogProperties {
|
2021-11-03 21:35:45 -07:00
|
|
|
// Anything below this value will be detected as zero
|
2021-09-20 12:56:55 -07:00
|
|
|
float deadzone{};
|
2021-11-03 21:35:45 -07:00
|
|
|
// Anyting above this values will be detected as one
|
2021-09-20 12:56:55 -07:00
|
|
|
float range{1.0f};
|
2021-11-03 21:35:45 -07:00
|
|
|
// Minimum value to be detected as active
|
2021-09-20 12:56:55 -07:00
|
|
|
float threshold{0.5f};
|
2021-11-03 21:35:45 -07:00
|
|
|
// Drift correction applied to the raw data
|
2021-09-20 12:56:55 -07:00
|
|
|
float offset{};
|
2021-11-03 21:35:45 -07:00
|
|
|
// Invert direction of the sensor data
|
2021-09-20 12:56:55 -07:00
|
|
|
bool inverted{};
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Single analog sensor data
|
2021-09-20 12:56:55 -07:00
|
|
|
struct AnalogStatus {
|
|
|
|
float value{};
|
|
|
|
float raw_value{};
|
|
|
|
AnalogProperties properties{};
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Button data
|
2021-09-20 12:56:55 -07:00
|
|
|
struct ButtonStatus {
|
2021-11-02 21:50:30 -07:00
|
|
|
Common::UUID uuid{};
|
2021-09-20 12:56:55 -07:00
|
|
|
bool value{};
|
|
|
|
bool inverted{};
|
|
|
|
bool toggle{};
|
|
|
|
bool locked{};
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Internal battery data
|
2021-09-20 12:56:55 -07:00
|
|
|
using BatteryStatus = BatteryLevel;
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Analog and digital joystick data
|
2021-09-20 12:56:55 -07:00
|
|
|
struct StickStatus {
|
2021-11-02 21:50:30 -07:00
|
|
|
Common::UUID uuid{};
|
2021-09-20 12:56:55 -07:00
|
|
|
AnalogStatus x{};
|
|
|
|
AnalogStatus y{};
|
|
|
|
bool left{};
|
|
|
|
bool right{};
|
|
|
|
bool up{};
|
|
|
|
bool down{};
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Analog and digital trigger data
|
2021-09-20 12:56:55 -07:00
|
|
|
struct TriggerStatus {
|
2021-11-02 21:50:30 -07:00
|
|
|
Common::UUID uuid{};
|
2021-09-20 12:56:55 -07:00
|
|
|
AnalogStatus analog{};
|
2021-10-31 08:41:44 -07:00
|
|
|
ButtonStatus pressed{};
|
2021-09-20 12:56:55 -07:00
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// 3D vector representing motion input
|
2021-09-20 12:56:55 -07:00
|
|
|
struct MotionSensor {
|
|
|
|
AnalogStatus x{};
|
|
|
|
AnalogStatus y{};
|
|
|
|
AnalogStatus z{};
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Motion data used to calculate controller orientation
|
2021-09-20 12:56:55 -07:00
|
|
|
struct MotionStatus {
|
2021-11-01 18:49:14 -07:00
|
|
|
// Gyroscope vector measurement in radians/s.
|
2021-09-20 12:56:55 -07:00
|
|
|
MotionSensor gyro{};
|
2021-11-01 18:49:14 -07:00
|
|
|
// Acceleration vector measurement in G force
|
2021-09-20 12:56:55 -07:00
|
|
|
MotionSensor accel{};
|
2021-11-01 18:49:14 -07:00
|
|
|
// Time since last measurement in microseconds
|
2021-09-20 12:56:55 -07:00
|
|
|
u64 delta_timestamp{};
|
2021-11-01 18:49:14 -07:00
|
|
|
// Request to update after reading the value
|
|
|
|
bool force_update{};
|
2021-09-20 12:56:55 -07:00
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Data of a single point on a touch screen
|
2021-09-20 12:56:55 -07:00
|
|
|
struct TouchStatus {
|
|
|
|
ButtonStatus pressed{};
|
|
|
|
AnalogStatus x{};
|
|
|
|
AnalogStatus y{};
|
2021-10-31 08:41:44 -07:00
|
|
|
int id{};
|
2021-09-20 12:56:55 -07:00
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Physical controller color in RGB format
|
2021-09-20 12:56:55 -07:00
|
|
|
struct BodyColorStatus {
|
|
|
|
u32 body{};
|
|
|
|
u32 buttons{};
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// HD rumble data
|
2021-09-20 12:56:55 -07:00
|
|
|
struct VibrationStatus {
|
|
|
|
f32 low_amplitude{};
|
|
|
|
f32 low_frequency{};
|
|
|
|
f32 high_amplitude{};
|
|
|
|
f32 high_frequency{};
|
2021-10-20 12:41:56 -07:00
|
|
|
VibrationAmplificationType type;
|
2021-09-20 12:56:55 -07:00
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Physical controller LED pattern
|
2021-09-20 12:56:55 -07:00
|
|
|
struct LedStatus {
|
|
|
|
bool led_1{};
|
|
|
|
bool led_2{};
|
|
|
|
bool led_3{};
|
|
|
|
bool led_4{};
|
|
|
|
};
|
|
|
|
|
2021-11-21 12:12:01 -08:00
|
|
|
// List of buttons to be passed to Qt that can be translated
|
|
|
|
enum class ButtonNames {
|
|
|
|
Undefined,
|
|
|
|
Invalid,
|
|
|
|
// This will display the engine name instead of the button name
|
|
|
|
Engine,
|
|
|
|
// This will display the button by value instead of the button name
|
|
|
|
Value,
|
|
|
|
ButtonLeft,
|
|
|
|
ButtonRight,
|
|
|
|
ButtonDown,
|
|
|
|
ButtonUp,
|
|
|
|
TriggerZ,
|
|
|
|
TriggerR,
|
|
|
|
TriggerL,
|
|
|
|
ButtonA,
|
|
|
|
ButtonB,
|
|
|
|
ButtonX,
|
|
|
|
ButtonY,
|
|
|
|
ButtonStart,
|
2021-11-26 13:45:37 -08:00
|
|
|
|
|
|
|
// DS4 button names
|
|
|
|
L1,
|
|
|
|
L2,
|
|
|
|
L3,
|
|
|
|
R1,
|
|
|
|
R2,
|
|
|
|
R3,
|
|
|
|
Circle,
|
|
|
|
Cross,
|
|
|
|
Square,
|
|
|
|
Triangle,
|
|
|
|
Share,
|
|
|
|
Options,
|
2021-11-21 12:12:01 -08:00
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Callback data consisting of an input type and the equivalent data status
|
2021-09-20 12:56:55 -07:00
|
|
|
struct CallbackStatus {
|
|
|
|
InputType type{InputType::None};
|
|
|
|
ButtonStatus button_status{};
|
|
|
|
StickStatus stick_status{};
|
|
|
|
AnalogStatus analog_status{};
|
|
|
|
TriggerStatus trigger_status{};
|
|
|
|
MotionStatus motion_status{};
|
|
|
|
TouchStatus touch_status{};
|
|
|
|
BodyColorStatus color_status{};
|
|
|
|
BatteryStatus battery_status{};
|
|
|
|
VibrationStatus vibration_status{};
|
|
|
|
};
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Triggered once every input change
|
2021-09-20 12:56:55 -07:00
|
|
|
struct InputCallback {
|
|
|
|
std::function<void(CallbackStatus)> on_change;
|
|
|
|
};
|
|
|
|
|
|
|
|
/// An abstract class template for an input device (a button, an analog input, etc.).
|
|
|
|
class InputDevice {
|
|
|
|
public:
|
|
|
|
virtual ~InputDevice() = default;
|
|
|
|
|
2021-10-24 18:28:54 -07:00
|
|
|
// Request input device to update if necessary
|
2021-12-13 17:43:09 -08:00
|
|
|
virtual void SoftUpdate() {}
|
2021-10-24 18:28:54 -07:00
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Force input device to update data regardless of the current state
|
2021-12-13 17:43:09 -08:00
|
|
|
virtual void ForceUpdate() {}
|
2021-10-24 18:28:54 -07:00
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Sets the function to be triggered when input changes
|
2021-09-20 12:56:55 -07:00
|
|
|
void SetCallback(InputCallback callback_) {
|
|
|
|
callback = std::move(callback_);
|
|
|
|
}
|
|
|
|
|
2021-11-03 21:35:45 -07:00
|
|
|
// Triggers the function set in the callback
|
2021-09-20 12:56:55 -07:00
|
|
|
void TriggerOnChange(CallbackStatus status) {
|
|
|
|
if (callback.on_change) {
|
|
|
|
callback.on_change(status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
InputCallback callback;
|
|
|
|
};
|
|
|
|
|
2021-10-10 22:43:11 -07:00
|
|
|
/// An abstract class template for an output device (rumble, LED pattern, polling mode).
|
|
|
|
class OutputDevice {
|
|
|
|
public:
|
|
|
|
virtual ~OutputDevice() = default;
|
|
|
|
|
2021-12-13 06:20:55 -08:00
|
|
|
virtual void SetLED([[maybe_unused]] const LedStatus& led_status) {}
|
2021-10-10 22:43:11 -07:00
|
|
|
|
2021-12-13 06:09:03 -08:00
|
|
|
virtual VibrationError SetVibration([[maybe_unused]] const VibrationStatus& vibration_status) {
|
2021-10-10 22:43:11 -07:00
|
|
|
return VibrationError::NotSupported;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
|
|
|
|
return PollingError::NotSupported;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2021-09-20 12:56:55 -07:00
|
|
|
/// An abstract class template for a factory that can create input devices.
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
class Factory {
|
|
|
|
public:
|
|
|
|
virtual ~Factory() = default;
|
|
|
|
virtual std::unique_ptr<InputDeviceType> Create(const Common::ParamPackage&) = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
namespace Impl {
|
|
|
|
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
using FactoryListType = std::unordered_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
|
|
|
|
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
struct FactoryList {
|
|
|
|
static FactoryListType<InputDeviceType> list;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
FactoryListType<InputDeviceType> FactoryList<InputDeviceType>::list;
|
|
|
|
|
|
|
|
} // namespace Impl
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers an input device factory.
|
|
|
|
* @tparam InputDeviceType the type of input devices the factory can create
|
|
|
|
* @param name the name of the factory. Will be used to match the "engine" parameter when creating
|
|
|
|
* a device
|
|
|
|
* @param factory the factory object to register
|
|
|
|
*/
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDeviceType>> factory) {
|
|
|
|
auto pair = std::make_pair(name, std::move(factory));
|
|
|
|
if (!Impl::FactoryList<InputDeviceType>::list.insert(std::move(pair)).second) {
|
|
|
|
LOG_ERROR(Input, "Factory '{}' already registered", name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unregisters an input device factory.
|
|
|
|
* @tparam InputDeviceType the type of input devices the factory can create
|
|
|
|
* @param name the name of the factory to unregister
|
|
|
|
*/
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
void UnregisterFactory(const std::string& name) {
|
|
|
|
if (Impl::FactoryList<InputDeviceType>::list.erase(name) == 0) {
|
|
|
|
LOG_ERROR(Input, "Factory '{}' not registered", name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create an input device from given paramters.
|
|
|
|
* @tparam InputDeviceType the type of input devices to create
|
|
|
|
* @param params a serialized ParamPackage string that contains all parameters for creating the
|
|
|
|
* device
|
|
|
|
*/
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
std::unique_ptr<InputDeviceType> CreateDeviceFromString(const std::string& params) {
|
|
|
|
const Common::ParamPackage package(params);
|
|
|
|
const std::string engine = package.Get("engine", "null");
|
|
|
|
const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
|
|
|
|
const auto pair = factory_list.find(engine);
|
|
|
|
if (pair == factory_list.end()) {
|
|
|
|
if (engine != "null") {
|
|
|
|
LOG_ERROR(Input, "Unknown engine name: {}", engine);
|
|
|
|
}
|
|
|
|
return std::make_unique<InputDeviceType>();
|
|
|
|
}
|
|
|
|
return pair->second->Create(package);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create an input device from given paramters.
|
|
|
|
* @tparam InputDeviceType the type of input devices to create
|
|
|
|
* @param A ParamPackage that contains all parameters for creating the device
|
|
|
|
*/
|
|
|
|
template <typename InputDeviceType>
|
|
|
|
std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package) {
|
|
|
|
const std::string engine = package.Get("engine", "null");
|
|
|
|
const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
|
|
|
|
const auto pair = factory_list.find(engine);
|
|
|
|
if (pair == factory_list.end()) {
|
|
|
|
if (engine != "null") {
|
|
|
|
LOG_ERROR(Input, "Unknown engine name: {}", engine);
|
|
|
|
}
|
|
|
|
return std::make_unique<InputDeviceType>();
|
|
|
|
}
|
|
|
|
return pair->second->Create(package);
|
|
|
|
}
|
|
|
|
|
2021-10-30 20:23:10 -07:00
|
|
|
} // namespace Common::Input
|