Exverge/suyu
3
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity

Morph review first wave

Browse source
This commit is contained in:
german77 2021-10-22 23:04:06 -05:00 committed by Narr the Reg
parent e2e5f1beaf
commit b564f024f0
23 changed files with 117 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/core/core.h
View file

@ -289,7 +289,7 @@ public:
/// Provides a constant reference to the kernel instance.
[[nodiscard]] const Kernel::KernelCore& Kernel() const;
/// Gets a mutable reference to the HID interface
/// Gets a mutable reference to the HID interface.
[[nodiscard]] HID::HIDCore& HIDCore();
/// Gets an immutable reference to the HID interface.

3
src/core/frontend/applets/controller.cpp
View file

@ -13,8 +13,7 @@ namespace Core::Frontend {
ControllerApplet::~ControllerApplet() = default;
DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_)
: hid_core{hid_core_} {}
DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_) : hid_core{hid_core_} {}
DefaultControllerApplet::~DefaultControllerApplet() = default;

4
src/core/hid/emulated_console.cpp
View file

@ -6,7 +6,7 @@
#include "core/hid/input_converter.h"
namespace Core::HID {
EmulatedConsole::EmulatedConsole() {}
EmulatedConsole::EmulatedConsole() = default;
EmulatedConsole::~EmulatedConsole() = default;
@ -191,7 +191,7 @@ TouchFingerState EmulatedConsole::GetTouch() const {
}
void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {
for (const std::pair<int, ConsoleUpdateCallback> poller_pair : callback_list) {
for (const auto& poller_pair : callback_list) {
const ConsoleUpdateCallback& poller = poller_pair.second;
if (poller.on_change) {
poller.on_change(type);

10
src/core/hid/emulated_console.h
View file

@ -20,7 +20,7 @@
namespace Core::HID {
struct ConsoleMotionInfo {
Input::MotionStatus raw_status;
Input::MotionStatus raw_status{};
MotionInput emulated{};
};
@ -34,21 +34,21 @@ using ConsoleMotionValues = ConsoleMotionInfo;
using TouchValues = std::array<Input::TouchStatus, 16>;
struct TouchFinger {
u64_le last_touch{};
u64 last_touch{};
Common::Point<float> position{};
u32_le id{};
bool pressed{};
u32 id{};
TouchAttribute attribute{};
bool pressed{};
};
// Contains all motion related data that is used on the services
struct ConsoleMotion {
bool is_at_rest{};
Common::Vec3f accel{};
Common::Vec3f gyro{};
Common::Vec3f rotation{};
std::array<Common::Vec3f, 3> orientation{};
Common::Quaternion<f32> quaternion{};
bool is_at_rest{};
};
using TouchFingerState = std::array<TouchFinger, 16>;

6
src/core/hid/emulated_controller.cpp
View file

@ -865,10 +865,10 @@ BatteryLevelState EmulatedController::GetBattery() const {
return controller.battery_state;
}
void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_service_update) {
for (const std::pair<int, ControllerUpdateCallback> poller_pair : callback_list) {
void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npad_service_update) {
for (const auto& poller_pair : callback_list) {
const ControllerUpdateCallback& poller = poller_pair.second;
if (!is_service_update && poller.is_service) {
if (!is_npad_service_update && poller.is_npad_service) {
continue;
}
if (poller.on_change) {

22
src/core/hid/emulated_controller.h
View file

@ -20,7 +20,7 @@
namespace Core::HID {
struct ControllerMotionInfo {
Input::MotionStatus raw_status;
Input::MotionStatus raw_status{};
MotionInput emulated{};
};
@ -51,28 +51,28 @@ using BatteryValues = std::array<Input::BatteryStatus, 3>;
using VibrationValues = std::array<Input::VibrationStatus, 2>;
struct AnalogSticks {
AnalogStickState left;
AnalogStickState right;
AnalogStickState left{};
AnalogStickState right{};
};
struct ControllerColors {
NpadControllerColor fullkey;
NpadControllerColor left;
NpadControllerColor right;
NpadControllerColor fullkey{};
NpadControllerColor left{};
NpadControllerColor right{};
};
struct BatteryLevelState {
NpadPowerInfo dual;
NpadPowerInfo left;
NpadPowerInfo right;
NpadPowerInfo dual{};
NpadPowerInfo left{};
NpadPowerInfo right{};
};
struct ControllerMotion {
bool is_at_rest;
Common::Vec3f accel{};
Common::Vec3f gyro{};
Common::Vec3f rotation{};
std::array<Common::Vec3f, 3> orientation{};
bool is_at_rest{};
};
using MotionState = std::array<ControllerMotion, 2>;
@ -113,7 +113,7 @@ enum class ControllerTriggerType {
struct ControllerUpdateCallback {
std::function<void(ControllerTriggerType)> on_change;
bool is_service;
bool is_npad_service;
};
class EmulatedController {

4
src/core/hid/emulated_devices.cpp
View file

@ -9,7 +9,7 @@
namespace Core::HID {
EmulatedDevices::EmulatedDevices() {}
EmulatedDevices::EmulatedDevices() = default;
EmulatedDevices::~EmulatedDevices() = default;
@ -332,7 +332,7 @@ MousePosition EmulatedDevices::GetMousePosition() const {
}
void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {
for (const std::pair<int, InterfaceUpdateCallback> poller_pair : callback_list) {
for (const auto& poller_pair : callback_list) {
const InterfaceUpdateCallback& poller = poller_pair.second;
if (poller.on_change) {
poller.on_change(type);

8
src/core/hid/hid_core.cpp
View file

@ -113,8 +113,8 @@ NpadStyleTag HIDCore::GetSupportedStyleTag() const {
s8 HIDCore::GetPlayerCount() const {
s8 active_players = 0;
for (std::size_t player_index = 0; player_index < available_controllers -2; player_index++) {
const auto* controller = GetEmulatedControllerByIndex(player_index);
for (std::size_t player_index = 0; player_index < available_controllers - 2; ++player_index) {
const auto* const controller = GetEmulatedControllerByIndex(player_index);
if (controller->IsConnected()) {
active_players++;
}
@ -123,8 +123,8 @@ s8 HIDCore::GetPlayerCount() const {
}
NpadIdType HIDCore::GetFirstNpadId() const {
for (std::size_t player_index = 0; player_index < available_controllers; player_index++) {
const auto* controller = GetEmulatedControllerByIndex(player_index);
for (std::size_t player_index = 0; player_index < available_controllers; ++player_index) {
const auto* const controller = GetEmulatedControllerByIndex(player_index);
if (controller->IsConnected()) {
return controller->GetNpadIdType();
}

48
src/core/hid/hid_types.h
View file

@ -100,7 +100,7 @@ enum class NpadType : u8 {
// This is nn::hid::NpadStyleTag
struct NpadStyleTag {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> fullkey;
BitField<1, 1, u32> handheld;
@ -132,35 +132,35 @@ static_assert(sizeof(TouchAttribute) == 0x4, "TouchAttribute is an invalid size"
// This is nn::hid::TouchState
struct TouchState {
u64_le delta_time;
u64 delta_time;
TouchAttribute attribute;
u32_le finger;
Common::Point<u32_le> position;
u32_le diameter_x;
u32_le diameter_y;
u32_le rotation_angle;
u32 finger;
Common::Point<u32> position;
u32 diameter_x;
u32 diameter_y;
u32 rotation_angle;
};
static_assert(sizeof(TouchState) == 0x28, "Touchstate is an invalid size");
// This is nn::hid::NpadControllerColor
struct NpadControllerColor {
u32_le body;
u32_le button;
u32 body;
u32 button;
};
static_assert(sizeof(NpadControllerColor) == 8, "NpadControllerColor is an invalid size");
// This is nn::hid::AnalogStickState
struct AnalogStickState {
s32_le x;
s32_le y;
s32 x;
s32 y;
};
static_assert(sizeof(AnalogStickState) == 8, "AnalogStickState is an invalid size");
// This is nn::hid::server::NpadGcTriggerState
struct NpadGcTriggerState {
s64_le sampling_number{};
s32_le left{};
s32_le right{};
s64 sampling_number{};
s32 left{};
s32 right{};
};
static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size");
@ -286,7 +286,7 @@ static_assert(sizeof(NpadButtonState) == 0x8, "NpadButtonState has incorrect siz
// This is nn::hid::DebugPadButton
struct DebugPadButton {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> a;
BitField<1, 1, u32> b;
BitField<2, 1, u32> x;
@ -345,7 +345,7 @@ static_assert(sizeof(VibrationDeviceInfo) == 0x8, "VibrationDeviceInfo has incor
// This is nn::hid::KeyboardModifier
struct KeyboardModifier {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> control;
BitField<1, 1, u32> shift;
BitField<2, 1, u32> left_alt;
@ -383,7 +383,7 @@ static_assert(sizeof(MouseButton) == 0x4, "MouseButton is an invalid size");
// This is nn::hid::MouseAttribute
struct MouseAttribute {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> transferable;
BitField<1, 1, u32> is_connected;
};
@ -392,13 +392,13 @@ static_assert(sizeof(MouseAttribute) == 0x4, "MouseAttribute is an invalid size"
// This is nn::hid::detail::MouseState
struct MouseState {
s64_le sampling_number;
s32_le x;
s32_le y;
s32_le delta_x;
s32_le delta_y;
s32_le delta_wheel_x;
s32_le delta_wheel_y;
s64 sampling_number;
s32 x;
s32 y;
s32 delta_x;
s32 delta_y;
s32 delta_wheel_x;
s32 delta_wheel_y;
MouseButton button;
MouseAttribute attribute;
};

12
src/core/hid/input_converter.cpp
View file

@ -142,8 +142,8 @@ Input::StickStatus TransformToStick(const Input::CallbackStatus& callback) {
}
SanitizeStick(status.x, status.y, true);
const Input::AnalogProperties& properties_x = status.x.properties;
const Input::AnalogProperties& properties_y = status.y.properties;
const auto& properties_x = status.x.properties;
const auto& properties_y = status.y.properties;
const float x = status.x.value;
const float y = status.y.value;
@ -213,7 +213,7 @@ Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback) {
}
SanitizeAnalog(status.analog, true);
const Input::AnalogProperties& properties = status.analog.properties;
const auto& properties = status.analog.properties;
float& value = status.analog.value;
// Set button status
@ -231,7 +231,7 @@ Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback) {
}
void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value) {
const Input::AnalogProperties& properties = analog.properties;
const auto& properties = analog.properties;
float& raw_value = analog.raw_value;
float& value = analog.value;
@ -271,8 +271,8 @@ void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value) {
}
void SanitizeStick(Input::AnalogStatus& analog_x, Input::AnalogStatus& analog_y, bool clamp_value) {
const Input::AnalogProperties& properties_x = analog_x.properties;
const Input::AnalogProperties& properties_y = analog_y.properties;
const auto& properties_x = analog_x.properties;
const auto& properties_y = analog_y.properties;
float& raw_x = analog_x.raw_value;
float& raw_y = analog_y.raw_value;
float& x = analog_x.value;

14
src/core/hle/service/hid/controllers/console_sixaxis.h
View file

@ -35,8 +35,8 @@ public:
private:
struct SevenSixAxisState {
INSERT_PADDING_WORDS(4); // unused
s64_le sampling_number{};
s64_le sampling_number2{};
s64 sampling_number{};
s64 sampling_number2{};
u64 unknown{};
Common::Vec3f accel{};
Common::Vec3f gyro{};
@ -45,10 +45,10 @@ private:
static_assert(sizeof(SevenSixAxisState) == 0x50, "SevenSixAxisState is an invalid size");
struct CommonHeader {
s64_le timestamp;
s64_le total_entry_count;
s64_le last_entry_index;
s64_le entry_count;
s64 timestamp;
s64 total_entry_count;
s64 last_entry_index;
s64 entry_count;
};
static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");
@ -61,7 +61,7 @@ private:
// This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat
struct ConsoleSharedMemory {
u64_le sampling_number{};
u64 sampling_number{};
bool is_seven_six_axis_sensor_at_rest{};
f32 verticalization_error{};
Common::Vec3f gyro_bias{};

4
src/core/hle/service/hid/controllers/debug_pad.h
View file

@ -38,7 +38,7 @@ private:
// This is nn::hid::DebugPadAttribute
struct DebugPadAttribute {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> connected;
};
};
@ -46,7 +46,7 @@ private:
// This is nn::hid::DebugPadState
struct DebugPadState {
s64_le sampling_number;
s64 sampling_number;
DebugPadAttribute attribute;
Core::HID::DebugPadButton pad_state;
Core::HID::AnalogStickState r_stick;

9
src/core/hle/service/hid/controllers/gesture.cpp
View file

@ -65,10 +65,7 @@ void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing, u
void Controller_Gesture::ReadTouchInput() {
const auto touch_status = console->GetTouch();
for (std::size_t id = 0; id < fingers.size(); ++id) {
const Core::HID::TouchFinger& status = touch_status[id];
Finger& finger = fingers[id];
finger.pos = status.position;
finger.pressed = status.pressed;
fingers[id] = touch_status[id];
}
}
@ -315,14 +312,14 @@ const Controller_Gesture::GestureState& Controller_Gesture::GetLastGestureEntry(
Controller_Gesture::GestureProperties Controller_Gesture::GetGestureProperties() {
GestureProperties gesture;
std::array<Finger, MAX_POINTS> active_fingers;
std::array<Core::HID::TouchFinger, MAX_POINTS> active_fingers;
const auto end_iter = std::copy_if(fingers.begin(), fingers.end(), active_fingers.begin(),
[](const auto& finger) { return finger.pressed; });
gesture.active_points =
static_cast<std::size_t>(std::distance(active_fingers.begin(), end_iter));
for (size_t id = 0; id < gesture.active_points; ++id) {
const auto& [active_x, active_y] = active_fingers[id].pos;
const auto& [active_x, active_y] = active_fingers[id].position;
gesture.points[id] = {
.x = static_cast<s32>(active_x * Layout::ScreenUndocked::Width),
.y = static_cast<s32>(active_y * Layout::ScreenUndocked::Height),

33
src/core/hle/service/hid/controllers/gesture.h
View file

@ -60,7 +60,7 @@ private:
// This is nn::hid::GestureAttribute
struct GestureAttribute {
union {
u32_le raw{};
u32 raw{};
BitField<4, 1, u32> is_new_touch;
BitField<8, 1, u32> is_double_tap;
@ -70,33 +70,28 @@ private:
// This is nn::hid::GestureState
struct GestureState {
s64_le sampling_number;
s64_le detection_count;
s64 sampling_number;
s64 detection_count;
GestureType type;
GestureDirection direction;
Common::Point<s32_le> pos;
Common::Point<s32_le> delta;
Common::Point<s32> pos;
Common::Point<s32> delta;
f32 vel_x;
f32 vel_y;
GestureAttribute attributes;
f32 scale;
f32 rotation_angle;
s32_le point_count;
std::array<Common::Point<s32_le>, 4> points;
s32 point_count;
std::array<Common::Point<s32>, 4> points;
};
static_assert(sizeof(GestureState) == 0x60, "GestureState is an invalid size");
struct Finger {
Common::Point<f32> pos{};
bool pressed{};
};
struct GestureProperties {
std::array<Common::Point<s32_le>, MAX_POINTS> points{};
std::array<Common::Point<s32>, MAX_POINTS> points{};
std::size_t active_points{};
Common::Point<s32_le> mid_point{};
s64_le detection_count{};
u64_le delta_time{};
Common::Point<s32> mid_point{};
s64 detection_count{};
u64 delta_time{};
f32 average_distance{};
f32 angle{};
};
@ -150,10 +145,10 @@ private:
Core::HID::EmulatedConsole* console;
std::array<Finger, MAX_POINTS> fingers{};
std::array<Core::HID::TouchFinger, MAX_POINTS> fingers{};
GestureProperties last_gesture{};
s64_le last_update_timestamp{};
s64_le last_tap_timestamp{};
s64 last_update_timestamp{};
s64 last_tap_timestamp{};
f32 last_pan_time_difference{};
bool force_update{false};
bool enable_press_and_tap{false};

2
src/core/hle/service/hid/controllers/keyboard.h
View file

@ -37,7 +37,7 @@ public:
private:
// This is nn::hid::detail::KeyboardState
struct KeyboardState {
s64_le sampling_number;
s64 sampling_number;
Core::HID::KeyboardModifier modifier;
Core::HID::KeyboardKey key;
};

4
src/core/hle/service/hid/controllers/npad.cpp
View file

@ -106,7 +106,7 @@ Controller_NPad::Controller_NPad(Core::System& system_,
Core::HID::ControllerUpdateCallback engine_callback{
.on_change = [this,
i](Core::HID::ControllerTriggerType type) { ControllerUpdate(type, i); },
.is_service = true,
.is_npad_service = true,
};
controller.callback_key = controller.device->SetCallback(engine_callback);
}
@ -157,7 +157,6 @@ void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type,
void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
auto& controller = controller_data[controller_idx];
LOG_WARNING(Service_HID, "Connect {} {}", controller_idx, controller.is_connected);
const auto controller_type = controller.device->GetNpadType();
auto& shared_memory = controller.shared_memory_entry;
if (controller_type == Core::HID::NpadType::None) {
@ -892,7 +891,6 @@ void Controller_NPad::DisconnectNpad(u32 npad_id) {
void Controller_NPad::DisconnectNpadAtIndex(std::size_t npad_index) {
auto& controller = controller_data[npad_index];
LOG_WARNING(Service_HID, "Disconnect {} {}", npad_index, controller.is_connected);
for (std::size_t device_idx = 0; device_idx < controller.vibration.size(); ++device_idx) {
// Send an empty vibration to stop any vibrations.
VibrateControllerAtIndex(npad_index, device_idx, {});

22
src/core/hle/service/hid/controllers/npad.h
View file

@ -195,7 +195,7 @@ public:
private:
// This is nn::hid::detail::ColorAttribute
enum class ColorAttribute : u32_le {
enum class ColorAttribute : u32 {
Ok = 0,
ReadError = 1,
NoController = 2,
@ -220,7 +220,7 @@ private:
// This is nn::hid::NpadAttribute
struct NpadAttribute {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> is_connected;
BitField<1, 1, u32> is_wired;
BitField<2, 1, u32> is_left_connected;
@ -251,7 +251,7 @@ private:
// This is nn::hid::SixAxisSensorAttribute
struct SixAxisSensorAttribute {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> is_connected;
BitField<1, 1, u32> is_interpolated;
};
@ -260,8 +260,8 @@ private:
// This is nn::hid::SixAxisSensorState
struct SixAxisSensorState {
s64_le delta_time{};
s64_le sampling_number{};
s64 delta_time{};
s64 sampling_number{};
Common::Vec3f accel{};
Common::Vec3f gyro{};
Common::Vec3f rotation{};
@ -273,16 +273,16 @@ private:
// This is nn::hid::server::NpadGcTriggerState
struct NpadGcTriggerState {
s64_le sampling_number{};
s32_le l_analog{};
s32_le r_analog{};
s64 sampling_number{};
s32 l_analog{};
s32 r_analog{};
};
static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size");
// This is nn::hid::NpadSystemProperties
struct NPadSystemProperties {
union {
s64_le raw{};
s64 raw{};
BitField<0, 1, s64> is_charging_joy_dual;
BitField<1, 1, s64> is_charging_joy_left;
BitField<2, 1, s64> is_charging_joy_right;
@ -303,7 +303,7 @@ private:
// This is nn::hid::NpadSystemButtonProperties
struct NpadSystemButtonProperties {
union {
s32_le raw{};
s32 raw{};
BitField<0, 1, s32> is_home_button_protection_enabled;
};
};
@ -313,7 +313,7 @@ private:
// This is nn::hid::system::DeviceType
struct DeviceType {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, s32> fullkey;
BitField<1, 1, s32> debug_pad;
BitField<2, 1, s32> handheld_left;

8
src/core/hle/service/hid/controllers/stubbed.h
View file

@ -26,10 +26,10 @@ public:
private:
struct CommonHeader {
s64_le timestamp;
s64_le total_entry_count;
s64_le last_entry_index;
s64_le entry_count;
s64 timestamp;
s64 total_entry_count;
s64 last_entry_index;
s64 entry_count;
};
static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");

4
src/core/hle/service/hid/controllers/touchscreen.cpp
View file

@ -66,7 +66,7 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
}
}
std::array<Finger, MAX_FINGERS> active_fingers;
std::array<Core::HID::TouchFinger, MAX_FINGERS> active_fingers;
const auto end_iter = std::copy_if(fingers.begin(), fingers.end(), active_fingers.begin(),
[](const auto& finger) { return finger.pressed; });
const auto active_fingers_count =
@ -76,7 +76,7 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
const auto& last_entry = touch_screen_lifo.ReadCurrentEntry().state;
next_state.sampling_number = last_entry.sampling_number + 1;
next_state.entry_count = static_cast<s32_le>(active_fingers_count);
next_state.entry_count = static_cast<s32>(active_fingers_count);
for (std::size_t id = 0; id < MAX_FINGERS; ++id) {
auto& touch_entry = next_state.states[id];

14
src/core/hle/service/hid/controllers/touchscreen.h
View file

@ -50,27 +50,19 @@ private:
// This is nn::hid::TouchScreenState
struct TouchScreenState {
s64_le sampling_number;
s32_le entry_count;
s64 sampling_number;
s32 entry_count;
INSERT_PADDING_BYTES(4); // Reserved
std::array<Core::HID::TouchState, MAX_FINGERS> states;
};
static_assert(sizeof(TouchScreenState) == 0x290, "TouchScreenState is an invalid size");
struct Finger {
u64_le last_touch{};
Common::Point<float> position;
u32_le id{};
bool pressed{};
Core::HID::TouchAttribute attribute;
};
// This is nn::hid::detail::TouchScreenLifo
Lifo<TouchScreenState> touch_screen_lifo{};
static_assert(sizeof(touch_screen_lifo) == 0x2C38, "touch_screen_lifo is an invalid size");
TouchScreenState next_state{};
std::array<Finger, MAX_FINGERS> fingers;
std::array<Core::HID::TouchFinger, MAX_FINGERS> fingers;
Core::HID::EmulatedConsole* console;
};
} // namespace Service::HID

6
src/core/hle/service/hid/controllers/xpad.h
View file

@ -31,7 +31,7 @@ private:
// This is nn::hid::BasicXpadAttributeSet
struct BasicXpadAttributeSet {
union {
u32_le raw{};
u32 raw{};
BitField<0, 1, u32> is_connected;
BitField<1, 1, u32> is_wired;
BitField<2, 1, u32> is_left_connected;
@ -45,7 +45,7 @@ private:
// This is nn::hid::BasicXpadButtonSet
struct BasicXpadButtonSet {
union {
u32_le raw{};
u32 raw{};
// Button states
BitField<0, 1, u32> a;
BitField<1, 1, u32> b;
@ -93,7 +93,7 @@ private:
// This is nn::hid::detail::BasicXpadState
struct BasicXpadState {
s64_le sampling_number;
s64 sampling_number;
BasicXpadAttributeSet attributes;
BasicXpadButtonSet pad_states;
Core::HID::AnalogStickState l_stick;

10
src/core/hle/service/hid/ring_lifo.h
View file

@ -12,16 +12,16 @@ constexpr std::size_t max_entry_size = 17;
template <typename State>
struct AtomicStorage {
s64_le sampling_number;
s64 sampling_number;
State state;
};
template <typename State>
struct Lifo {
s64_le timestamp{};
s64_le total_entry_count = max_entry_size;
s64_le last_entry_index{};
s64_le entry_count{};
s64 timestamp{};
s64 total_entry_count = max_entry_size;
s64 last_entry_index{};
s64 entry_count{};
std::array<AtomicStorage<State>, max_entry_size> entries{};
const AtomicStorage<State>& ReadCurrentEntry() const {

2
src/yuzu/configuration/configure_input_player_widget.cpp
View file

@ -28,7 +28,7 @@ void PlayerControlPreview::SetController(Core::HID::EmulatedController* controll
controller = controller_;
Core::HID::ControllerUpdateCallback engine_callback{
.on_change = [this](Core::HID::ControllerTriggerType type) { ControllerUpdate(type); },
.is_service = false,
.is_npad_service = false,
};
callback_key = controller->SetCallback(engine_callback);
ControllerUpdate(Core::HID::ControllerTriggerType::All);