2018-10-05 16:23:21 +02:00
|
|
|
// Copyright 2018 yuzu emulator team
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
2018-10-06 05:14:42 +02:00
|
|
|
|
2018-10-05 16:23:21 +02:00
|
|
|
#include <array>
|
2018-11-03 17:55:39 +01:00
|
|
|
#include "common/bit_field.h"
|
2018-10-05 16:23:21 +02:00
|
|
|
#include "common/common_types.h"
|
2018-10-06 05:27:06 +02:00
|
|
|
#include "core/frontend/input.h"
|
2018-11-27 00:34:07 +01:00
|
|
|
#include "core/hle/kernel/object.h"
|
2018-11-27 15:18:29 +01:00
|
|
|
#include "core/hle/kernel/writable_event.h"
|
2018-10-05 16:23:21 +02:00
|
|
|
#include "core/hle/service/hid/controllers/controller_base.h"
|
|
|
|
#include "core/settings.h"
|
|
|
|
|
|
|
|
namespace Service::HID {
|
|
|
|
|
2018-11-03 17:55:39 +01:00
|
|
|
constexpr u32 NPAD_HANDHELD = 32;
|
|
|
|
constexpr u32 NPAD_UNKNOWN = 16; // TODO(ogniK): What is this?
|
|
|
|
|
2018-10-05 16:23:21 +02:00
|
|
|
class Controller_NPad final : public ControllerBase {
|
|
|
|
public:
|
2019-09-21 14:13:27 +02:00
|
|
|
explicit Controller_NPad(Core::System& system);
|
2018-10-18 02:34:25 +02:00
|
|
|
~Controller_NPad() override;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
// Called when the controller is initialized
|
2019-09-22 08:41:34 +02:00
|
|
|
void OnInit() override;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
// When the controller is released
|
|
|
|
void OnRelease() override;
|
|
|
|
|
|
|
|
// When the controller is requesting an update for the shared memory
|
2019-02-14 18:42:58 +01:00
|
|
|
void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data, std::size_t size) override;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2020-09-24 00:51:09 +02:00
|
|
|
// When the controller is requesting a motion update for the shared memory
|
|
|
|
void OnMotionUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
|
|
|
|
std::size_t size) override;
|
|
|
|
|
2018-10-05 16:23:21 +02:00
|
|
|
// Called when input devices should be loaded
|
|
|
|
void OnLoadInputDevices() override;
|
|
|
|
|
2020-10-06 10:35:07 +02:00
|
|
|
enum class NPadControllerType {
|
|
|
|
None,
|
|
|
|
ProController,
|
|
|
|
Handheld,
|
|
|
|
JoyDual,
|
|
|
|
JoyLeft,
|
|
|
|
JoyRight,
|
|
|
|
Pokeball,
|
|
|
|
};
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2020-10-06 10:35:07 +02:00
|
|
|
enum class NpadType : u8 {
|
|
|
|
ProController = 3,
|
|
|
|
Handheld = 4,
|
|
|
|
JoyconDual = 5,
|
|
|
|
JoyconLeft = 6,
|
|
|
|
JoyconRight = 7,
|
|
|
|
Pokeball = 9,
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
|
|
|
|
2020-10-06 10:35:07 +02:00
|
|
|
enum class DeviceIndex : u8 {
|
|
|
|
Left = 0,
|
|
|
|
Right = 1,
|
|
|
|
None = 2,
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
|
|
|
|
2020-06-21 21:48:02 +02:00
|
|
|
enum class GyroscopeZeroDriftMode : u32 {
|
|
|
|
Loose = 0,
|
|
|
|
Standard = 1,
|
|
|
|
Tight = 2,
|
|
|
|
};
|
|
|
|
|
2018-10-05 16:23:21 +02:00
|
|
|
enum class NpadHoldType : u64 {
|
|
|
|
Vertical = 0,
|
|
|
|
Horizontal = 1,
|
|
|
|
};
|
|
|
|
|
2020-10-06 13:00:18 +02:00
|
|
|
enum class NpadAssignments : u32 {
|
2018-10-05 16:23:21 +02:00
|
|
|
Dual = 0,
|
|
|
|
Single = 1,
|
|
|
|
};
|
|
|
|
|
2020-09-18 16:10:30 +02:00
|
|
|
enum class NpadHandheldActivationMode : u64 {
|
|
|
|
Dual = 0,
|
|
|
|
Single = 1,
|
|
|
|
None = 2,
|
|
|
|
};
|
|
|
|
|
2020-10-06 10:35:07 +02:00
|
|
|
struct DeviceHandle {
|
|
|
|
NpadType npad_type{};
|
|
|
|
u8 npad_id{};
|
|
|
|
DeviceIndex device_index{};
|
|
|
|
INSERT_PADDING_BYTES(1);
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
2020-10-06 10:35:07 +02:00
|
|
|
static_assert(sizeof(DeviceHandle) == 4, "DeviceHandle is an invalid size");
|
|
|
|
|
2020-10-08 07:08:37 +02:00
|
|
|
struct NpadStyleSet {
|
2020-10-06 10:35:07 +02:00
|
|
|
union {
|
|
|
|
u32_le raw{};
|
|
|
|
|
|
|
|
BitField<0, 1, u32> pro_controller;
|
|
|
|
BitField<1, 1, u32> handheld;
|
|
|
|
BitField<2, 1, u32> joycon_dual;
|
|
|
|
BitField<3, 1, u32> joycon_left;
|
|
|
|
BitField<4, 1, u32> joycon_right;
|
|
|
|
|
|
|
|
BitField<6, 1, u32> pokeball; // TODO(ogniK): Confirm when possible
|
|
|
|
};
|
|
|
|
};
|
2020-10-08 07:08:37 +02:00
|
|
|
static_assert(sizeof(NpadStyleSet) == 4, "NpadStyleSet is an invalid size");
|
2020-10-06 10:35:07 +02:00
|
|
|
|
2020-10-07 20:22:47 +02:00
|
|
|
struct VibrationValue {
|
2020-10-11 17:25:17 +02:00
|
|
|
f32 amp_low{0.0f};
|
|
|
|
f32 freq_low{160.0f};
|
|
|
|
f32 amp_high{0.0f};
|
|
|
|
f32 freq_high{320.0f};
|
2020-10-06 10:35:07 +02:00
|
|
|
};
|
2020-10-07 20:22:47 +02:00
|
|
|
static_assert(sizeof(VibrationValue) == 0x10, "Vibration is an invalid size");
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2018-10-10 12:38:43 +02:00
|
|
|
struct LedPattern {
|
|
|
|
explicit LedPattern(u64 light1, u64 light2, u64 light3, u64 light4) {
|
|
|
|
position1.Assign(light1);
|
2018-11-27 23:23:44 +01:00
|
|
|
position2.Assign(light2);
|
|
|
|
position3.Assign(light3);
|
|
|
|
position4.Assign(light4);
|
2018-10-18 02:44:11 +02:00
|
|
|
}
|
2018-10-10 12:38:43 +02:00
|
|
|
union {
|
|
|
|
u64 raw{};
|
|
|
|
BitField<0, 1, u64> position1;
|
|
|
|
BitField<1, 1, u64> position2;
|
|
|
|
BitField<2, 1, u64> position3;
|
|
|
|
BitField<3, 1, u64> position4;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2020-10-08 07:08:37 +02:00
|
|
|
void SetSupportedStyleSet(NpadStyleSet style_set);
|
|
|
|
NpadStyleSet GetSupportedStyleSet() const;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2020-10-06 13:00:18 +02:00
|
|
|
void SetSupportedNpadIdTypes(u8* data, std::size_t length);
|
2018-10-18 02:37:45 +02:00
|
|
|
void GetSupportedNpadIdTypes(u32* data, std::size_t max_length);
|
2020-10-06 13:00:18 +02:00
|
|
|
std::size_t GetSupportedNpadIdTypesSize() const;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
void SetHoldType(NpadHoldType joy_hold_type);
|
|
|
|
NpadHoldType GetHoldType() const;
|
|
|
|
|
2020-09-18 16:10:30 +02:00
|
|
|
void SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_mode);
|
|
|
|
NpadHandheldActivationMode GetNpadHandheldActivationMode() const;
|
|
|
|
|
2020-10-06 13:00:18 +02:00
|
|
|
void SetNpadMode(u32 npad_id, NpadAssignments assignment_mode);
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2020-10-20 19:55:25 +02:00
|
|
|
bool VibrateControllerAtIndex(std::size_t npad_index, std::size_t device_index,
|
2020-10-27 18:33:25 +01:00
|
|
|
const VibrationValue& vibration_value);
|
2020-10-11 17:25:17 +02:00
|
|
|
|
2020-10-25 12:30:23 +01:00
|
|
|
void VibrateController(const DeviceHandle& vibration_device_handle,
|
|
|
|
const VibrationValue& vibration_value);
|
|
|
|
|
2020-10-11 17:25:17 +02:00
|
|
|
void VibrateControllers(const std::vector<DeviceHandle>& vibration_device_handles,
|
|
|
|
const std::vector<VibrationValue>& vibration_values);
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2020-10-07 20:22:47 +02:00
|
|
|
VibrationValue GetLastVibration(const DeviceHandle& vibration_device_handle) const;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2020-10-22 12:55:23 +02:00
|
|
|
void InitializeVibrationDevice(const DeviceHandle& vibration_device_handle);
|
|
|
|
|
|
|
|
void InitializeVibrationDeviceAtIndex(std::size_t npad_index, std::size_t device_index);
|
|
|
|
|
2020-11-10 18:09:44 +01:00
|
|
|
void SetPermitVibrationSession(bool permit_vibration_session);
|
|
|
|
|
2020-10-22 12:55:23 +02:00
|
|
|
bool IsVibrationDeviceMounted(const DeviceHandle& vibration_device_handle) const;
|
|
|
|
|
2020-08-21 13:39:24 +02:00
|
|
|
std::shared_ptr<Kernel::ReadableEvent> GetStyleSetChangedEvent(u32 npad_id) const;
|
|
|
|
void SignalStyleSetChangedEvent(u32 npad_id) const;
|
|
|
|
|
2020-07-22 16:39:53 +02:00
|
|
|
// Adds a new controller at an index.
|
|
|
|
void AddNewControllerAt(NPadControllerType controller, std::size_t npad_index);
|
|
|
|
// Adds a new controller at an index with connection status.
|
|
|
|
void UpdateControllerAt(NPadControllerType controller, std::size_t npad_index, bool connected);
|
2018-10-05 16:23:21 +02:00
|
|
|
|
2020-10-06 13:00:18 +02:00
|
|
|
void DisconnectNpad(u32 npad_id);
|
|
|
|
void DisconnectNpadAtIndex(std::size_t index);
|
2020-08-21 13:39:24 +02:00
|
|
|
|
2020-06-21 21:48:02 +02:00
|
|
|
void SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode drift_mode);
|
|
|
|
GyroscopeZeroDriftMode GetGyroscopeZeroDriftMode() const;
|
2020-09-05 04:48:03 +02:00
|
|
|
bool IsSixAxisSensorAtRest() const;
|
|
|
|
void SetSixAxisEnabled(bool six_axis_status);
|
2018-10-10 12:38:43 +02:00
|
|
|
LedPattern GetLedPattern(u32 npad_id);
|
2020-09-30 12:34:08 +02:00
|
|
|
bool IsUnintendedHomeButtonInputProtectionEnabled(u32 npad_id) const;
|
|
|
|
void SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled, u32 npad_id);
|
2018-10-18 12:45:10 +02:00
|
|
|
void ClearAllConnectedControllers();
|
|
|
|
void DisconnectAllConnectedControllers();
|
|
|
|
void ConnectAllDisconnectedControllers();
|
|
|
|
void ClearAllControllers();
|
2018-10-07 11:17:04 +02:00
|
|
|
|
2020-08-27 19:27:03 +02:00
|
|
|
void MergeSingleJoyAsDualJoy(u32 npad_id_1, u32 npad_id_2);
|
2019-07-01 07:12:57 +02:00
|
|
|
void StartLRAssignmentMode();
|
|
|
|
void StopLRAssignmentMode();
|
|
|
|
bool SwapNpadAssignment(u32 npad_id_1, u32 npad_id_2);
|
|
|
|
|
2018-12-24 22:19:16 +01:00
|
|
|
// Logical OR for all buttons presses on all controllers
|
|
|
|
// Specifically for cheat engine and other features.
|
2018-12-29 00:20:29 +01:00
|
|
|
u32 GetAndResetPressState();
|
2018-12-24 22:19:16 +01:00
|
|
|
|
2020-07-22 16:39:53 +02:00
|
|
|
static Controller_NPad::NPadControllerType MapSettingsTypeToNPad(Settings::ControllerType type);
|
|
|
|
static Settings::ControllerType MapNPadToSettingsType(Controller_NPad::NPadControllerType type);
|
2018-11-03 17:55:39 +01:00
|
|
|
static std::size_t NPadIdToIndex(u32 npad_id);
|
|
|
|
static u32 IndexToNPad(std::size_t index);
|
|
|
|
|
2018-10-05 16:23:21 +02:00
|
|
|
private:
|
|
|
|
struct CommonHeader {
|
|
|
|
s64_le timestamp;
|
|
|
|
s64_le total_entry_count;
|
|
|
|
s64_le last_entry_index;
|
|
|
|
s64_le entry_count;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");
|
|
|
|
|
|
|
|
struct ControllerColor {
|
|
|
|
u32_le body_color;
|
|
|
|
u32_le button_color;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(ControllerColor) == 8, "ControllerColor is an invalid size");
|
|
|
|
|
|
|
|
struct ControllerPadState {
|
|
|
|
union {
|
|
|
|
u64_le raw{};
|
|
|
|
// Button states
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<0, 1, u64> a;
|
|
|
|
BitField<1, 1, u64> b;
|
|
|
|
BitField<2, 1, u64> x;
|
|
|
|
BitField<3, 1, u64> y;
|
|
|
|
BitField<4, 1, u64> l_stick;
|
|
|
|
BitField<5, 1, u64> r_stick;
|
|
|
|
BitField<6, 1, u64> l;
|
|
|
|
BitField<7, 1, u64> r;
|
|
|
|
BitField<8, 1, u64> zl;
|
|
|
|
BitField<9, 1, u64> zr;
|
|
|
|
BitField<10, 1, u64> plus;
|
|
|
|
BitField<11, 1, u64> minus;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
// D-Pad
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<12, 1, u64> d_left;
|
|
|
|
BitField<13, 1, u64> d_up;
|
|
|
|
BitField<14, 1, u64> d_right;
|
|
|
|
BitField<15, 1, u64> d_down;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
// Left JoyStick
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<16, 1, u64> l_stick_left;
|
|
|
|
BitField<17, 1, u64> l_stick_up;
|
|
|
|
BitField<18, 1, u64> l_stick_right;
|
|
|
|
BitField<19, 1, u64> l_stick_down;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
// Right JoyStick
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<20, 1, u64> r_stick_left;
|
|
|
|
BitField<21, 1, u64> r_stick_up;
|
|
|
|
BitField<22, 1, u64> r_stick_right;
|
|
|
|
BitField<23, 1, u64> r_stick_down;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
// Not always active?
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<24, 1, u64> left_sl;
|
|
|
|
BitField<25, 1, u64> left_sr;
|
2018-10-18 10:00:16 +02:00
|
|
|
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<26, 1, u64> right_sl;
|
|
|
|
BitField<27, 1, u64> right_sr;
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
|
|
|
};
|
|
|
|
static_assert(sizeof(ControllerPadState) == 8, "ControllerPadState is an invalid size");
|
|
|
|
|
|
|
|
struct AnalogPosition {
|
|
|
|
s32_le x;
|
|
|
|
s32_le y;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(AnalogPosition) == 8, "AnalogPosition is an invalid size");
|
|
|
|
|
|
|
|
struct ConnectionState {
|
|
|
|
union {
|
|
|
|
u32_le raw{};
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<0, 1, u32> IsConnected;
|
|
|
|
BitField<1, 1, u32> IsWired;
|
|
|
|
BitField<2, 1, u32> IsLeftJoyConnected;
|
|
|
|
BitField<3, 1, u32> IsLeftJoyWired;
|
|
|
|
BitField<4, 1, u32> IsRightJoyConnected;
|
|
|
|
BitField<5, 1, u32> IsRightJoyWired;
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
|
|
|
};
|
|
|
|
static_assert(sizeof(ConnectionState) == 4, "ConnectionState is an invalid size");
|
|
|
|
|
2018-10-18 05:11:15 +02:00
|
|
|
struct ControllerPad {
|
2018-10-05 16:23:21 +02:00
|
|
|
ControllerPadState pad_states;
|
2018-10-06 05:14:42 +02:00
|
|
|
AnalogPosition l_stick;
|
|
|
|
AnalogPosition r_stick;
|
2018-10-18 05:11:15 +02:00
|
|
|
};
|
|
|
|
static_assert(sizeof(ControllerPad) == 0x18, "ControllerPad is an invalid size");
|
|
|
|
|
|
|
|
struct GenericStates {
|
|
|
|
s64_le timestamp;
|
|
|
|
s64_le timestamp2;
|
|
|
|
ControllerPad pad;
|
2018-10-05 16:23:21 +02:00
|
|
|
ConnectionState connection_status;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(GenericStates) == 0x30, "NPadGenericStates is an invalid size");
|
|
|
|
|
|
|
|
struct NPadGeneric {
|
|
|
|
CommonHeader common;
|
|
|
|
std::array<GenericStates, 17> npad;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(NPadGeneric) == 0x350, "NPadGeneric is an invalid size");
|
|
|
|
|
2020-09-05 04:48:03 +02:00
|
|
|
struct SixAxisStates {
|
|
|
|
s64_le timestamp{};
|
|
|
|
INSERT_PADDING_WORDS(2);
|
|
|
|
s64_le timestamp2{};
|
|
|
|
Common::Vec3f accel{};
|
|
|
|
Common::Vec3f gyro{};
|
|
|
|
Common::Vec3f rotation{};
|
|
|
|
std::array<Common::Vec3f, 3> orientation{};
|
|
|
|
s64_le always_one{1};
|
|
|
|
};
|
|
|
|
static_assert(sizeof(SixAxisStates) == 0x68, "SixAxisStates is an invalid size");
|
|
|
|
|
|
|
|
struct SixAxisGeneric {
|
|
|
|
CommonHeader common{};
|
|
|
|
std::array<SixAxisStates, 17> sixaxis{};
|
|
|
|
};
|
|
|
|
static_assert(sizeof(SixAxisGeneric) == 0x708, "SixAxisGeneric is an invalid size");
|
|
|
|
|
2018-10-05 16:23:21 +02:00
|
|
|
enum class ColorReadError : u32_le {
|
|
|
|
ReadOk = 0,
|
|
|
|
ColorDoesntExist = 1,
|
|
|
|
NoController = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct NPadProperties {
|
|
|
|
union {
|
|
|
|
s64_le raw{};
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<11, 1, s64> is_vertical;
|
|
|
|
BitField<12, 1, s64> is_horizontal;
|
|
|
|
BitField<13, 1, s64> use_plus;
|
|
|
|
BitField<14, 1, s64> use_minus;
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct NPadDevice {
|
|
|
|
union {
|
|
|
|
u32_le raw{};
|
2019-01-25 18:26:47 +01:00
|
|
|
BitField<0, 1, s32> pro_controller;
|
|
|
|
BitField<1, 1, s32> handheld;
|
|
|
|
BitField<2, 1, s32> handheld_left;
|
|
|
|
BitField<3, 1, s32> handheld_right;
|
|
|
|
BitField<4, 1, s32> joycon_left;
|
|
|
|
BitField<5, 1, s32> joycon_right;
|
|
|
|
BitField<6, 1, s32> pokeball;
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2020-09-05 04:48:03 +02:00
|
|
|
struct MotionDevice {
|
|
|
|
Common::Vec3f accel;
|
2020-09-03 02:59:34 +02:00
|
|
|
Common::Vec3f gyro;
|
2020-09-05 04:48:03 +02:00
|
|
|
Common::Vec3f rotation;
|
2020-09-03 02:59:34 +02:00
|
|
|
std::array<Common::Vec3f, 3> orientation;
|
2020-09-05 04:48:03 +02:00
|
|
|
};
|
|
|
|
|
2018-10-05 16:23:21 +02:00
|
|
|
struct NPadEntry {
|
2020-10-08 07:08:37 +02:00
|
|
|
NpadStyleSet joy_styles;
|
2020-10-06 13:00:18 +02:00
|
|
|
NpadAssignments pad_assignment;
|
2018-10-05 16:23:21 +02:00
|
|
|
|
|
|
|
ColorReadError single_color_error;
|
|
|
|
ControllerColor single_color;
|
|
|
|
|
|
|
|
ColorReadError dual_color_error;
|
|
|
|
ControllerColor left_color;
|
|
|
|
ControllerColor right_color;
|
|
|
|
|
|
|
|
NPadGeneric main_controller_states;
|
|
|
|
NPadGeneric handheld_states;
|
|
|
|
NPadGeneric dual_states;
|
|
|
|
NPadGeneric left_joy_states;
|
|
|
|
NPadGeneric right_joy_states;
|
|
|
|
NPadGeneric pokeball_states;
|
|
|
|
NPadGeneric libnx; // TODO(ogniK): Find out what this actually is, libnx seems to only be
|
|
|
|
// relying on this for the time being
|
2020-09-05 04:48:03 +02:00
|
|
|
SixAxisGeneric sixaxis_full;
|
|
|
|
SixAxisGeneric sixaxis_handheld;
|
|
|
|
SixAxisGeneric sixaxis_dual_left;
|
|
|
|
SixAxisGeneric sixaxis_dual_right;
|
|
|
|
SixAxisGeneric sixaxis_left;
|
|
|
|
SixAxisGeneric sixaxis_right;
|
2018-10-05 16:23:21 +02:00
|
|
|
NPadDevice device_type;
|
|
|
|
NPadProperties properties;
|
2018-10-17 15:11:47 +02:00
|
|
|
INSERT_PADDING_WORDS(1);
|
|
|
|
std::array<u32, 3> battery_level;
|
|
|
|
INSERT_PADDING_BYTES(0x5c);
|
2018-10-05 16:23:21 +02:00
|
|
|
INSERT_PADDING_BYTES(0xdf8);
|
|
|
|
};
|
|
|
|
static_assert(sizeof(NPadEntry) == 0x5000, "NPadEntry is an invalid size");
|
2018-10-07 11:17:04 +02:00
|
|
|
|
|
|
|
struct ControllerHolder {
|
2018-10-18 06:09:55 +02:00
|
|
|
NPadControllerType type;
|
2018-10-07 11:17:04 +02:00
|
|
|
bool is_connected;
|
|
|
|
};
|
|
|
|
|
2020-07-22 16:39:53 +02:00
|
|
|
void InitNewlyAddedController(std::size_t controller_idx);
|
2019-10-18 00:09:05 +02:00
|
|
|
bool IsControllerSupported(NPadControllerType controller) const;
|
|
|
|
void RequestPadStateUpdate(u32 npad_id);
|
|
|
|
|
2018-12-24 22:19:16 +01:00
|
|
|
u32 press_state{};
|
|
|
|
|
2020-10-08 07:08:37 +02:00
|
|
|
NpadStyleSet style{};
|
2018-10-05 16:23:21 +02:00
|
|
|
std::array<NPadEntry, 10> shared_memory_entries{};
|
2020-09-05 04:48:03 +02:00
|
|
|
using ButtonArray = std::array<
|
2018-11-02 03:03:17 +01:00
|
|
|
std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeButton::NUM_BUTTONS_HID>,
|
2020-09-05 04:48:03 +02:00
|
|
|
10>;
|
|
|
|
using StickArray = std::array<
|
2018-11-02 03:03:17 +01:00
|
|
|
std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID>,
|
2020-09-05 04:48:03 +02:00
|
|
|
10>;
|
2020-10-20 19:55:25 +02:00
|
|
|
using VibrationArray = std::array<std::array<std::unique_ptr<Input::VibrationDevice>,
|
|
|
|
Settings::NativeVibration::NUM_VIBRATIONS_HID>,
|
|
|
|
10>;
|
2020-09-03 02:59:34 +02:00
|
|
|
using MotionArray = std::array<
|
2020-10-20 19:55:25 +02:00
|
|
|
std::array<std::unique_ptr<Input::MotionDevice>, Settings::NativeMotion::NUM_MOTIONS_HID>,
|
2020-09-03 02:59:34 +02:00
|
|
|
10>;
|
2020-09-05 04:48:03 +02:00
|
|
|
ButtonArray buttons;
|
|
|
|
StickArray sticks;
|
2020-10-20 19:55:25 +02:00
|
|
|
VibrationArray vibrations;
|
2020-09-05 04:48:03 +02:00
|
|
|
MotionArray motions;
|
2018-10-05 16:23:21 +02:00
|
|
|
std::vector<u32> supported_npad_id_types{};
|
|
|
|
NpadHoldType hold_type{NpadHoldType::Vertical};
|
2020-09-18 16:10:30 +02:00
|
|
|
NpadHandheldActivationMode handheld_activation_mode{NpadHandheldActivationMode::Dual};
|
2019-09-22 15:42:41 +02:00
|
|
|
// Each controller should have their own styleset changed event
|
|
|
|
std::array<Kernel::EventPair, 10> styleset_changed_events;
|
2020-10-25 12:30:23 +01:00
|
|
|
std::array<std::array<std::chrono::steady_clock::time_point, 2>, 10> last_vibration_timepoints;
|
2020-10-20 19:55:25 +02:00
|
|
|
std::array<std::array<VibrationValue, 2>, 10> latest_vibration_values{};
|
2020-11-10 18:09:44 +01:00
|
|
|
bool permit_vibration_session_enabled{false};
|
2020-10-22 12:55:23 +02:00
|
|
|
std::array<std::array<bool, 2>, 10> vibration_devices_mounted{};
|
2018-10-10 12:38:43 +02:00
|
|
|
std::array<ControllerHolder, 10> connected_controllers{};
|
2020-09-30 12:34:08 +02:00
|
|
|
std::array<bool, 10> unintended_home_button_input_protection{};
|
2020-06-21 21:48:02 +02:00
|
|
|
GyroscopeZeroDriftMode gyroscope_zero_drift_mode{GyroscopeZeroDriftMode::Standard};
|
2020-09-05 04:48:03 +02:00
|
|
|
bool sixaxis_sensors_enabled{true};
|
|
|
|
bool sixaxis_at_rest{true};
|
2018-10-18 05:11:15 +02:00
|
|
|
std::array<ControllerPad, 10> npad_pad_states{};
|
2019-07-01 07:12:57 +02:00
|
|
|
bool is_in_lr_assignment_mode{false};
|
2019-09-22 08:41:34 +02:00
|
|
|
Core::System& system;
|
2018-10-05 16:23:21 +02:00
|
|
|
};
|
2018-10-06 05:14:42 +02:00
|
|
|
} // namespace Service::HID
|