1
0
Fork 0
forked from suyu/suyu
suyu/src/common/input.h

474 lines
12 KiB
C++
Raw Normal View History

chore: make yuzu REUSE compliant [REUSE] is a specification that aims at making file copyright information consistent, so that it can be both human and machine readable. It basically requires that all files have a header containing copyright and licensing information. When this isn't possible, like when dealing with binary assets, generated files or embedded third-party dependencies, it is permitted to insert copyright information in the `.reuse/dep5` file. Oh, and it also requires that all the licenses used in the project are present in the `LICENSES` folder, that's why the diff is so huge. This can be done automatically with `reuse download --all`. The `reuse` tool also contains a handy subcommand that analyzes the project and tells whether or not the project is (still) compliant, `reuse lint`. Following REUSE has a few advantages over the current approach: - Copyright information is easy to access for users / downstream - Files like `dist/license.md` do not need to exist anymore, as `.reuse/dep5` is used instead - `reuse lint` makes it easy to ensure that copyright information of files like binary assets / images is always accurate and up to date To add copyright information of files that didn't have it I looked up who committed what and when, for each file. As yuzu contributors do not have to sign a CLA or similar I couldn't assume that copyright ownership was of the "yuzu Emulator Project", so I used the name and/or email of the commit author instead. [REUSE]: https://reuse.software Follow-up to 01cf05bc75b1e47beb08937439f3ed9339e7b254
2022-05-15 02:06:02 +02:00
// SPDX-FileCopyrightText: 2017 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
2022-11-21 17:31:18 +01:00
#include <vector>
#include "common/logging/log.h"
#include "common/param_package.h"
#include "common/uuid.h"
namespace Common::Input {
2021-11-04 05:35:45 +01:00
// Type of data that is expected to recieve or send
enum class InputType {
None,
Battery,
Button,
Stick,
Analog,
Trigger,
Motion,
Touch,
Color,
Vibration,
Nfc,
2022-06-19 06:32:07 +02:00
IrSensor,
};
2021-11-04 05:35:45 +01:00
// Internal battery charge level
2021-11-01 21:17:53 +01:00
enum class BatteryLevel : u32 {
2021-10-19 07:12:24 +02:00
None,
Empty,
Critical,
Low,
Medium,
Full,
Charging,
};
2021-10-11 07:43:11 +02:00
enum class PollingMode {
2021-11-04 05:35:45 +01:00
// Constant polling of buttons, analogs and motion data
2021-10-11 07:43:11 +02:00
Active,
2021-11-04 05:35:45 +01:00
// Only update on button change, digital analogs
2021-10-11 07:43:11 +02:00
Pasive,
2021-11-04 05:35:45 +01:00
// Enable near field communication polling
NFC,
// Enable infrared camera polling
2021-10-11 07:43:11 +02:00
IR,
};
2022-06-19 06:32:07 +02:00
enum class CameraFormat {
Size320x240,
Size160x120,
Size80x60,
Size40x30,
Size20x15,
None,
};
2021-11-04 05:35:45 +01:00
// Vibration reply from the controller
2021-10-11 07:43:11 +02:00
enum class VibrationError {
None,
NotSupported,
Disabled,
Unknown,
};
2021-11-04 05:35:45 +01:00
// Polling mode reply from the controller
2021-10-11 07:43:11 +02:00
enum class PollingError {
None,
NotSupported,
Unknown,
};
// Nfc reply from the controller
enum class NfcState {
Success,
NewAmiibo,
WaitingForAmiibo,
AmiiboRemoved,
NotAnAmiibo,
NotSupported,
WrongDeviceState,
WriteFailed,
Unknown,
};
2022-06-19 06:32:07 +02:00
// Ir camera reply from the controller
enum class CameraError {
None,
NotSupported,
Unknown,
};
2021-10-20 21:41:56 +02:00
// Hint for amplification curve to be used
enum class VibrationAmplificationType {
Linear,
Exponential,
};
2021-11-04 05:35:45 +01:00
// Analog properties for calibration
struct AnalogProperties {
2021-11-04 05:35:45 +01:00
// Anything below this value will be detected as zero
float deadzone{};
2021-11-04 05:35:45 +01:00
// Anyting above this values will be detected as one
float range{1.0f};
2021-11-04 05:35:45 +01:00
// Minimum value to be detected as active
float threshold{0.5f};
2021-11-04 05:35:45 +01:00
// Drift correction applied to the raw data
float offset{};
2021-11-04 05:35:45 +01:00
// Invert direction of the sensor data
bool inverted{};
// Press once to activate, press again to release
bool toggle{};
};
2021-11-04 05:35:45 +01:00
// Single analog sensor data
struct AnalogStatus {
float value{};
float raw_value{};
AnalogProperties properties{};
};
2021-11-04 05:35:45 +01:00
// Button data
struct ButtonStatus {
Common::UUID uuid{};
bool value{};
// Invert value of the button
bool inverted{};
// Press once to activate, press again to release
bool toggle{};
// Internal lock for the toggle status
bool locked{};
};
2021-11-04 05:35:45 +01:00
// Internal battery data
using BatteryStatus = BatteryLevel;
2021-11-04 05:35:45 +01:00
// Analog and digital joystick data
struct StickStatus {
Common::UUID uuid{};
AnalogStatus x{};
AnalogStatus y{};
bool left{};
bool right{};
bool up{};
bool down{};
};
2021-11-04 05:35:45 +01:00
// Analog and digital trigger data
struct TriggerStatus {
Common::UUID uuid{};
AnalogStatus analog{};
ButtonStatus pressed{};
};
2021-11-04 05:35:45 +01:00
// 3D vector representing motion input
struct MotionSensor {
AnalogStatus x{};
AnalogStatus y{};
AnalogStatus z{};
};
2021-11-04 05:35:45 +01:00
// Motion data used to calculate controller orientation
struct MotionStatus {
// Gyroscope vector measurement in radians/s.
MotionSensor gyro{};
// Acceleration vector measurement in G force
MotionSensor accel{};
// Time since last measurement in microseconds
u64 delta_timestamp{};
// Request to update after reading the value
bool force_update{};
};
2021-11-04 05:35:45 +01:00
// Data of a single point on a touch screen
struct TouchStatus {
ButtonStatus pressed{};
AnalogStatus x{};
AnalogStatus y{};
int id{};
};
2021-11-04 05:35:45 +01:00
// Physical controller color in RGB format
struct BodyColorStatus {
u32 body{};
u32 buttons{};
};
2021-11-04 05:35:45 +01:00
// HD rumble data
struct VibrationStatus {
f32 low_amplitude{};
f32 low_frequency{};
f32 high_amplitude{};
f32 high_frequency{};
2021-10-20 21:41:56 +02:00
VibrationAmplificationType type;
};
2021-11-04 05:35:45 +01:00
// Physical controller LED pattern
struct LedStatus {
bool led_1{};
bool led_2{};
bool led_3{};
bool led_4{};
};
2022-06-19 06:32:07 +02:00
// Raw data fom camera
struct CameraStatus {
CameraFormat format{CameraFormat::None};
std::vector<u8> data{};
};
struct NfcStatus {
NfcState state{};
std::vector<u8> data{};
};
// 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,
// DS4 button names
L1,
L2,
L3,
R1,
R2,
R3,
Circle,
Cross,
Square,
Triangle,
Share,
Options,
Home,
Touch,
// Mouse buttons
ButtonMouseWheel,
ButtonBackward,
ButtonForward,
ButtonTask,
ButtonExtra,
};
2021-11-04 05:35:45 +01:00
// Callback data consisting of an input type and the equivalent data status
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{};
CameraFormat camera_status{CameraFormat::None};
NfcState nfc_status{NfcState::Unknown};
std::vector<u8> raw_data{};
};
2021-11-04 05:35:45 +01:00
// Triggered once every input change
struct InputCallback {
std::function<void(const CallbackStatus&)> on_change;
};
/// An abstract class template for an input device (a button, an analog input, etc.).
class InputDevice {
public:
virtual ~InputDevice() = default;
// Request input device to update if necessary
virtual void SoftUpdate() {}
2021-11-04 05:35:45 +01:00
// Force input device to update data regardless of the current state
virtual void ForceUpdate() {}
2021-11-04 05:35:45 +01:00
// Sets the function to be triggered when input changes
void SetCallback(InputCallback callback_) {
callback = std::move(callback_);
}
2021-11-04 05:35:45 +01:00
// Triggers the function set in the callback
void TriggerOnChange(const CallbackStatus& status) {
if (callback.on_change) {
callback.on_change(status);
}
}
private:
InputCallback callback;
};
2021-10-11 07:43:11 +02:00
/// An abstract class template for an output device (rumble, LED pattern, polling mode).
class OutputDevice {
public:
virtual ~OutputDevice() = default;
virtual void SetLED([[maybe_unused]] const LedStatus& led_status) {}
2021-10-11 07:43:11 +02:00
virtual VibrationError SetVibration([[maybe_unused]] const VibrationStatus& vibration_status) {
2021-10-11 07:43:11 +02:00
return VibrationError::NotSupported;
}
2022-10-21 07:23:12 +02:00
virtual bool IsVibrationEnabled() {
return false;
}
2021-10-11 07:43:11 +02:00
virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
return PollingError::NotSupported;
}
2022-06-19 06:32:07 +02:00
virtual CameraError SetCameraFormat([[maybe_unused]] CameraFormat camera_format) {
return CameraError::NotSupported;
}
2022-09-25 05:52:33 +02:00
virtual NfcState SupportsNfc() const {
return NfcState::NotSupported;
}
virtual NfcState WriteNfcData([[maybe_unused]] const std::vector<u8>& data) {
return NfcState::NotSupported;
}
2021-10-11 07:43:11 +02: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);
}
}
inline void RegisterInputFactory(const std::string& name,
std::shared_ptr<Factory<InputDevice>> factory) {
RegisterFactory<InputDevice>(name, std::move(factory));
}
inline void RegisterOutputFactory(const std::string& name,
std::shared_ptr<Factory<OutputDevice>> factory) {
RegisterFactory<OutputDevice>(name, std::move(factory));
}
/**
* 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);
}
}
inline void UnregisterInputFactory(const std::string& name) {
UnregisterFactory<InputDevice>(name);
}
inline void UnregisterOutputFactory(const std::string& name) {
UnregisterFactory<OutputDevice>(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);
}
inline std::unique_ptr<InputDevice> CreateInputDeviceFromString(const std::string& params) {
return CreateDeviceFromString<InputDevice>(params);
}
inline std::unique_ptr<OutputDevice> CreateOutputDeviceFromString(const std::string& params) {
return CreateDeviceFromString<OutputDevice>(params);
}
/**
* Create an input device from given parameters.
* @tparam InputDeviceType the type of input devices to create
* @param package A ParamPackage that contains all parameters for creating the device
*/
template <typename InputDeviceType>
std::unique_ptr<InputDeviceType> CreateDevice(const 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);
}
inline std::unique_ptr<InputDevice> CreateInputDevice(const ParamPackage& package) {
return CreateDevice<InputDevice>(package);
}
inline std::unique_ptr<OutputDevice> CreateOutputDevice(const ParamPackage& package) {
return CreateDevice<OutputDevice>(package);
}
} // namespace Common::Input