franklinblanco/yuzu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

service: hid: Create appropriate hid resources

Browse Source
This commit is contained in:
Narr the Reg 2023-11-17 11:46:26 -06:00 committed by german77
parent 8da5bd27e9
commit cff2d0e19e
36 changed files with 1634 additions and 1424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/core/CMakeLists.txt
View File

@ -529,6 +529,7 @@ add_library(core STATIC
hle/service/hid/hid_server.h hle/service/hid/hid_server.h
hle/service/hid/hid_system_server.cpp hle/service/hid/hid_system_server.cpp
hle/service/hid/hid_system_server.h hle/service/hid/hid_system_server.h
hle/service/hid/hid_util.h
hle/service/hid/hidbus.cpp hle/service/hid/hidbus.cpp
hle/service/hid/hidbus.h hle/service/hid/hidbus.h
hle/service/hid/irs.cpp hle/service/hid/irs.cpp
@ -540,8 +541,8 @@ add_library(core STATIC
hle/service/hid/xcd.cpp hle/service/hid/xcd.cpp
hle/service/hid/xcd.h hle/service/hid/xcd.h
hle/service/hid/errors.h hle/service/hid/errors.h
hle/service/hid/controllers/console_sixaxis.cpp hle/service/hid/controllers/console_six_axis.cpp
hle/service/hid/controllers/console_sixaxis.h hle/service/hid/controllers/console_six_axis.h
hle/service/hid/controllers/controller_base.cpp hle/service/hid/controllers/controller_base.cpp
hle/service/hid/controllers/controller_base.h hle/service/hid/controllers/controller_base.h
hle/service/hid/controllers/debug_pad.cpp hle/service/hid/controllers/debug_pad.cpp
@ -556,6 +557,10 @@ add_library(core STATIC
hle/service/hid/controllers/npad.h hle/service/hid/controllers/npad.h
hle/service/hid/controllers/palma.cpp hle/service/hid/controllers/palma.cpp
hle/service/hid/controllers/palma.h hle/service/hid/controllers/palma.h
hle/service/hid/controllers/seven_six_axis.cpp
hle/service/hid/controllers/seven_six_axis.h
hle/service/hid/controllers/six_axis.cpp
hle/service/hid/controllers/six_axis.h
hle/service/hid/controllers/stubbed.cpp hle/service/hid/controllers/stubbed.cpp
hle/service/hid/controllers/stubbed.h hle/service/hid/controllers/stubbed.h
hle/service/hid/controllers/touchscreen.cpp hle/service/hid/controllers/touchscreen.cpp

17
src/core/hid/emulated_controller.cpp
View File

@ -8,6 +8,7 @@
#include "common/thread.h" #include "common/thread.h"
#include "core/hid/emulated_controller.h" #include "core/hid/emulated_controller.h"
#include "core/hid/input_converter.h" #include "core/hid/input_converter.h"
#include "core/hle/service/hid/hid_util.h"
namespace Core::HID { namespace Core::HID {
constexpr s32 HID_JOYSTICK_MAX = 0x7fff; constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
@ -82,7 +83,7 @@ Settings::ControllerType EmulatedController::MapNPadToSettingsType(NpadStyleInde
} }
void EmulatedController::ReloadFromSettings() { void EmulatedController::ReloadFromSettings() {
const auto player_index = NpadIdTypeToIndex(npad_id_type); const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
const auto& player = Settings::values.players.GetValue()[player_index]; const auto& player = Settings::values.players.GetValue()[player_index];
for (std::size_t index = 0; index < player.buttons.size(); ++index) { for (std::size_t index = 0; index < player.buttons.size(); ++index) {
@ -118,7 +119,7 @@ void EmulatedController::ReloadFromSettings() {
} }
void EmulatedController::ReloadColorsFromSettings() { void EmulatedController::ReloadColorsFromSettings() {
const auto player_index = NpadIdTypeToIndex(npad_id_type); const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
const auto& player = Settings::values.players.GetValue()[player_index]; const auto& player = Settings::values.players.GetValue()[player_index];
// Avoid updating colors if overridden by physical controller // Avoid updating colors if overridden by physical controller
@ -215,7 +216,7 @@ void EmulatedController::LoadDevices() {
} }
void EmulatedController::LoadTASParams() { void EmulatedController::LoadTASParams() {
const auto player_index = NpadIdTypeToIndex(npad_id_type); const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
Common::ParamPackage common_params{}; Common::ParamPackage common_params{};
common_params.Set("engine", "tas"); common_params.Set("engine", "tas");
common_params.Set("port", static_cast<int>(player_index)); common_params.Set("port", static_cast<int>(player_index));
@ -264,7 +265,7 @@ void EmulatedController::LoadTASParams() {
} }
void EmulatedController::LoadVirtualGamepadParams() { void EmulatedController::LoadVirtualGamepadParams() {
const auto player_index = NpadIdTypeToIndex(npad_id_type); const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
Common::ParamPackage common_params{}; Common::ParamPackage common_params{};
common_params.Set("engine", "virtual_gamepad"); common_params.Set("engine", "virtual_gamepad");
common_params.Set("port", static_cast<int>(player_index)); common_params.Set("port", static_cast<int>(player_index));
@ -615,7 +616,7 @@ bool EmulatedController::IsConfiguring() const {
} }
void EmulatedController::SaveCurrentConfig() { void EmulatedController::SaveCurrentConfig() {
const auto player_index = NpadIdTypeToIndex(npad_id_type); const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
auto& player = Settings::values.players.GetValue()[player_index]; auto& player = Settings::values.players.GetValue()[player_index];
player.connected = is_connected; player.connected = is_connected;
player.controller_type = MapNPadToSettingsType(npad_type); player.controller_type = MapNPadToSettingsType(npad_type);
@ -1212,7 +1213,7 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
if (!output_devices[device_index]) { if (!output_devices[device_index]) {
return false; return false;
} }
const auto player_index = NpadIdTypeToIndex(npad_id_type); const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
const auto& player = Settings::values.players.GetValue()[player_index]; const auto& player = Settings::values.players.GetValue()[player_index];
const f32 strength = static_cast<f32>(player.vibration_strength) / 100.0f; const f32 strength = static_cast<f32>(player.vibration_strength) / 100.0f;
@ -1238,7 +1239,7 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
} }
bool EmulatedController::IsVibrationEnabled(std::size_t device_index) { bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
const auto player_index = NpadIdTypeToIndex(npad_id_type); const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
const auto& player = Settings::values.players.GetValue()[player_index]; const auto& player = Settings::values.players.GetValue()[player_index];
if (!player.vibration_enabled) { if (!player.vibration_enabled) {
@ -1648,7 +1649,7 @@ void EmulatedController::SetNpadStyleIndex(NpadStyleIndex npad_type_) {
} }
if (is_connected) { if (is_connected) {
LOG_WARNING(Service_HID, "Controller {} type changed while it's connected", LOG_WARNING(Service_HID, "Controller {} type changed while it's connected",
NpadIdTypeToIndex(npad_id_type)); Service::HID::NpadIdTypeToIndex(npad_id_type));
} }
npad_type = npad_type_; npad_type = npad_type_;
} }

5
src/core/hid/hid_core.cpp
View File

@ -6,6 +6,7 @@
#include "core/hid/emulated_controller.h" #include "core/hid/emulated_controller.h"
#include "core/hid/emulated_devices.h" #include "core/hid/emulated_devices.h"
#include "core/hid/hid_core.h" #include "core/hid/hid_core.h"
#include "core/hle/service/hid/hid_util.h"
namespace Core::HID { namespace Core::HID {
@ -98,11 +99,11 @@ const EmulatedDevices* HIDCore::GetEmulatedDevices() const {
} }
EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) { EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) {
return GetEmulatedController(IndexToNpadIdType(index)); return GetEmulatedController(Service::HID::IndexToNpadIdType(index));
} }
const EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) const { const EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) const {
return GetEmulatedController(IndexToNpadIdType(index)); return GetEmulatedController(Service::HID::IndexToNpadIdType(index));
} }
void HIDCore::SetSupportedStyleTag(NpadStyleTag style_tag) { void HIDCore::SetSupportedStyleTag(NpadStyleTag style_tag) {

80
src/core/hid/hid_types.h
View File

@ -8,6 +8,7 @@
#include "common/common_types.h" #include "common/common_types.h"
#include "common/point.h" #include "common/point.h"
#include "common/uuid.h" #include "common/uuid.h"
#include "common/vector_math.h"
namespace Core::HID { namespace Core::HID {
@ -598,6 +599,29 @@ struct SixAxisSensorIcInformation {
static_assert(sizeof(SixAxisSensorIcInformation) == 0xC8, static_assert(sizeof(SixAxisSensorIcInformation) == 0xC8,
"SixAxisSensorIcInformation is an invalid size"); "SixAxisSensorIcInformation is an invalid size");
// This is nn::hid::SixAxisSensorAttribute
struct SixAxisSensorAttribute {
union {
u32 raw{};
BitField<0, 1, u32> is_connected;
BitField<1, 1, u32> is_interpolated;
};
};
static_assert(sizeof(SixAxisSensorAttribute) == 4, "SixAxisSensorAttribute is an invalid size");
// This is nn::hid::SixAxisSensorState
struct SixAxisSensorState {
s64 delta_time{};
s64 sampling_number{};
Common::Vec3f accel{};
Common::Vec3f gyro{};
Common::Vec3f rotation{};
std::array<Common::Vec3f, 3> orientation{};
SixAxisSensorAttribute attribute{};
INSERT_PADDING_BYTES(4); // Reserved
};
static_assert(sizeof(SixAxisSensorState) == 0x60, "SixAxisSensorState is an invalid size");
// This is nn::hid::VibrationDeviceHandle // This is nn::hid::VibrationDeviceHandle
struct VibrationDeviceHandle { struct VibrationDeviceHandle {
NpadStyleIndex npad_type{NpadStyleIndex::None}; NpadStyleIndex npad_type{NpadStyleIndex::None};
@ -708,60 +732,4 @@ struct UniquePadId {
}; };
static_assert(sizeof(UniquePadId) == 0x8, "UniquePadId is an invalid size"); static_assert(sizeof(UniquePadId) == 0x8, "UniquePadId is an invalid size");
/// Converts a NpadIdType to an array index.
constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
switch (npad_id_type) {
case NpadIdType::Player1:
return 0;
case NpadIdType::Player2:
return 1;
case NpadIdType::Player3:
return 2;
case NpadIdType::Player4:
return 3;
case NpadIdType::Player5:
return 4;
case NpadIdType::Player6:
return 5;
case NpadIdType::Player7:
return 6;
case NpadIdType::Player8:
return 7;
case NpadIdType::Handheld:
return 8;
case NpadIdType::Other:
return 9;
default:
return 0;
}
}
/// Converts an array index to a NpadIdType
constexpr NpadIdType IndexToNpadIdType(size_t index) {
switch (index) {
case 0:
return NpadIdType::Player1;
case 1:
return NpadIdType::Player2;
case 2:
return NpadIdType::Player3;
case 3:
return NpadIdType::Player4;
case 4:
return NpadIdType::Player5;
case 5:
return NpadIdType::Player6;
case 6:
return NpadIdType::Player7;
case 7:
return NpadIdType::Player8;
case 8:
return NpadIdType::Handheld;
case 9:
return NpadIdType::Other;
default:
return NpadIdType::Invalid;
}
}
} // namespace Core::HID } // namespace Core::HID

4
src/core/hid/input_interpreter.cpp
View File

@ -13,14 +13,14 @@ InputInterpreter::InputInterpreter(Core::System& system)
: npad{system.ServiceManager() : npad{system.ServiceManager()
.GetService<Service::HID::IHidServer>("hid") .GetService<Service::HID::IHidServer>("hid")
->GetResourceManager() ->GetResourceManager()
->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad)} { ->GetNpad()} {
ResetButtonStates(); ResetButtonStates();
} }
InputInterpreter::~InputInterpreter() = default; InputInterpreter::~InputInterpreter() = default;
void InputInterpreter::PollInput() { void InputInterpreter::PollInput() {
const auto button_state = npad.GetAndResetPressState(); const auto button_state = npad->GetAndResetPressState();
previous_index = current_index; previous_index = current_index;
current_index = (current_index + 1) % button_states.size(); current_index = (current_index + 1) % button_states.size();

4
src/core/hid/input_interpreter.h
View File

@ -16,7 +16,7 @@ enum class NpadButton : u64;
} }
namespace Service::HID { namespace Service::HID {
class Controller_NPad; class NPad;
} }
/** /**
@ -101,7 +101,7 @@ public:
} }
private: private:
Service::HID::Controller_NPad& npad; std::shared_ptr<Service::HID::NPad> npad;
/// Stores 9 consecutive button states polled from HID. /// Stores 9 consecutive button states polled from HID.
std::array<Core::HID::NpadButton, 9> button_states{}; std::array<Core::HID::NpadButton, 9> button_states{};

42
src/core/hle/service/hid/controllers/console_six_axis.cpp Normal file
View File

@ -0,0 +1,42 @@
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "core/core.h"
#include "core/core_timing.h"
#include "core/hid/emulated_console.h"
#include "core/hid/hid_core.h"
#include "core/hle/service/hid/controllers/console_six_axis.h"
#include "core/memory.h"
namespace Service::HID {
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C200;
ConsoleSixAxis::ConsoleSixAxis(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
: ControllerBase{hid_core_} {
console = hid_core.GetEmulatedConsole();
static_assert(SHARED_MEMORY_OFFSET + sizeof(ConsoleSharedMemory) < shared_memory_size,
"ConsoleSharedMemory is bigger than the shared memory");
shared_memory = std::construct_at(
reinterpret_cast<ConsoleSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
}
ConsoleSixAxis::~ConsoleSixAxis() = default;
void ConsoleSixAxis::OnInit() {}
void ConsoleSixAxis::OnRelease() {}
void ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) {
return;
}
const auto motion_status = console->GetMotion();
shared_memory->sampling_number++;
shared_memory->is_seven_six_axis_sensor_at_rest = motion_status.is_at_rest;
shared_memory->verticalization_error = motion_status.verticalization_error;
shared_memory->gyro_bias = motion_status.gyro_bias;
}
} // namespace Service::HID

43
src/core/hle/service/hid/controllers/console_six_axis.h Normal file
View File

@ -0,0 +1,43 @@
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/vector_math.h"
#include "core/hle/service/hid/controllers/controller_base.h"
namespace Core::HID {
class EmulatedConsole;
} // namespace Core::HID
namespace Service::HID {
class ConsoleSixAxis final : public ControllerBase {
public:
explicit ConsoleSixAxis(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
~ConsoleSixAxis() override;
// Called when the controller is initialized
void OnInit() override;
// When the controller is released
void OnRelease() override;
// When the controller is requesting an update for the shared memory
void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
private:
// This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat
struct ConsoleSharedMemory {
u64 sampling_number{};
bool is_seven_six_axis_sensor_at_rest{};
INSERT_PADDING_BYTES(3); // padding
f32 verticalization_error{};
Common::Vec3f gyro_bias{};
INSERT_PADDING_BYTES(4); // padding
};
static_assert(sizeof(ConsoleSharedMemory) == 0x20, "ConsoleSharedMemory is an invalid size");
ConsoleSharedMemory* shared_memory = nullptr;
Core::HID::EmulatedConsole* console = nullptr;
};
} // namespace Service::HID

10
src/core/hle/service/hid/controllers/debug_pad.cpp
View File

@ -13,7 +13,7 @@
namespace Service::HID { namespace Service::HID {
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x00000; constexpr std::size_t SHARED_MEMORY_OFFSET = 0x00000;
Controller_DebugPad::Controller_DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) DebugPad::DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
: ControllerBase{hid_core_} { : ControllerBase{hid_core_} {
static_assert(SHARED_MEMORY_OFFSET + sizeof(DebugPadSharedMemory) < shared_memory_size, static_assert(SHARED_MEMORY_OFFSET + sizeof(DebugPadSharedMemory) < shared_memory_size,
"DebugPadSharedMemory is bigger than the shared memory"); "DebugPadSharedMemory is bigger than the shared memory");
@ -22,13 +22,13 @@ Controller_DebugPad::Controller_DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_
controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other); controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other);
} }
Controller_DebugPad::~Controller_DebugPad() = default; DebugPad::~DebugPad() = default;
void Controller_DebugPad::OnInit() {} void DebugPad::OnInit() {}
void Controller_DebugPad::OnRelease() {} void DebugPad::OnRelease() {}
void Controller_DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
shared_memory->debug_pad_lifo.buffer_count = 0; shared_memory->debug_pad_lifo.buffer_count = 0;
shared_memory->debug_pad_lifo.buffer_tail = 0; shared_memory->debug_pad_lifo.buffer_tail = 0;

6
src/core/hle/service/hid/controllers/debug_pad.h
View File

@ -15,10 +15,10 @@ struct AnalogStickState;
} // namespace Core::HID } // namespace Core::HID
namespace Service::HID { namespace Service::HID {
class Controller_DebugPad final : public ControllerBase { class DebugPad final : public ControllerBase {
public: public:
explicit Controller_DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); explicit DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
~Controller_DebugPad() override; ~DebugPad() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;

50
src/core/hle/service/hid/controllers/gesture.cpp
View File

@ -23,7 +23,7 @@ constexpr f32 Square(s32 num) {
return static_cast<f32>(num * num); return static_cast<f32>(num * num);
} }
Controller_Gesture::Controller_Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) Gesture::Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
: ControllerBase(hid_core_) { : ControllerBase(hid_core_) {
static_assert(SHARED_MEMORY_OFFSET + sizeof(GestureSharedMemory) < shared_memory_size, static_assert(SHARED_MEMORY_OFFSET + sizeof(GestureSharedMemory) < shared_memory_size,
"GestureSharedMemory is bigger than the shared memory"); "GestureSharedMemory is bigger than the shared memory");
@ -31,17 +31,17 @@ Controller_Gesture::Controller_Gesture(Core::HID::HIDCore& hid_core_, u8* raw_sh
reinterpret_cast<GestureSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); reinterpret_cast<GestureSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
console = hid_core.GetEmulatedConsole(); console = hid_core.GetEmulatedConsole();
} }
Controller_Gesture::~Controller_Gesture() = default; Gesture::~Gesture() = default;
void Controller_Gesture::OnInit() { void Gesture::OnInit() {
shared_memory->gesture_lifo.buffer_count = 0; shared_memory->gesture_lifo.buffer_count = 0;
shared_memory->gesture_lifo.buffer_tail = 0; shared_memory->gesture_lifo.buffer_tail = 0;
force_update = true; force_update = true;
} }
void Controller_Gesture::OnRelease() {} void Gesture::OnRelease() {}
void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
shared_memory->gesture_lifo.buffer_count = 0; shared_memory->gesture_lifo.buffer_count = 0;
shared_memory->gesture_lifo.buffer_tail = 0; shared_memory->gesture_lifo.buffer_tail = 0;
@ -64,7 +64,7 @@ void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
UpdateGestureSharedMemory(gesture, time_difference); UpdateGestureSharedMemory(gesture, time_difference);
} }
void Controller_Gesture::ReadTouchInput() { void Gesture::ReadTouchInput() {
if (!Settings::values.touchscreen.enabled) { if (!Settings::values.touchscreen.enabled) {
fingers = {}; fingers = {};
return; return;
@ -76,8 +76,7 @@ void Controller_Gesture::ReadTouchInput() {
} }
} }
bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture, bool Gesture::ShouldUpdateGesture(const GestureProperties& gesture, f32 time_difference) {
f32 time_difference) {
const auto& last_entry = GetLastGestureEntry(); const auto& last_entry = GetLastGestureEntry();
if (force_update) { if (force_update) {
force_update = false; force_update = false;
@ -100,8 +99,7 @@ bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
return false; return false;
} }
void Controller_Gesture::UpdateGestureSharedMemory(GestureProperties& gesture, void Gesture::UpdateGestureSharedMemory(GestureProperties& gesture, f32 time_difference) {
f32 time_difference) {
GestureType type = GestureType::Idle; GestureType type = GestureType::Idle;
GestureAttribute attributes{}; GestureAttribute attributes{};
@ -138,7 +136,7 @@ void Controller_Gesture::UpdateGestureSharedMemory(GestureProperties& gesture,
shared_memory->gesture_lifo.WriteNextEntry(next_state); shared_memory->gesture_lifo.WriteNextEntry(next_state);
} }
void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& type, void Gesture::NewGesture(GestureProperties& gesture, GestureType& type,
GestureAttribute& attributes) { GestureAttribute& attributes) {
const auto& last_entry = GetLastGestureEntry(); const auto& last_entry = GetLastGestureEntry();
@ -152,7 +150,7 @@ void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& typ
} }
} }
void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, GestureType& type, void Gesture::UpdateExistingGesture(GestureProperties& gesture, GestureType& type,
f32 time_difference) { f32 time_difference) {
const auto& last_entry = GetLastGestureEntry(); const auto& last_entry = GetLastGestureEntry();
@ -186,9 +184,8 @@ void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, Gestu
} }
} }
void Controller_Gesture::EndGesture(GestureProperties& gesture, void Gesture::EndGesture(GestureProperties& gesture, GestureProperties& last_gesture_props,
GestureProperties& last_gesture_props, GestureType& type, GestureType& type, GestureAttribute& attributes, f32 time_difference) {
GestureAttribute& attributes, f32 time_difference) {
const auto& last_entry = GetLastGestureEntry(); const auto& last_entry = GetLastGestureEntry();
if (last_gesture_props.active_points != 0) { if (last_gesture_props.active_points != 0) {
@ -222,9 +219,8 @@ void Controller_Gesture::EndGesture(GestureProperties& gesture,
} }
} }
void Controller_Gesture::SetTapEvent(GestureProperties& gesture, void Gesture::SetTapEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
GestureProperties& last_gesture_props, GestureType& type, GestureType& type, GestureAttribute& attributes) {
GestureAttribute& attributes) {
type = GestureType::Tap; type = GestureType::Tap;
gesture = last_gesture_props; gesture = last_gesture_props;
force_update = true; force_update = true;
@ -236,9 +232,8 @@ void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
} }
} }
void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture, void Gesture::UpdatePanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
GestureProperties& last_gesture_props, GestureType& type, GestureType& type, f32 time_difference) {
f32 time_difference) {
const auto& last_entry = GetLastGestureEntry(); const auto& last_entry = GetLastGestureEntry();
next_state.delta = gesture.mid_point - last_entry.pos; next_state.delta = gesture.mid_point - last_entry.pos;
@ -263,9 +258,8 @@ void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
} }
} }
void Controller_Gesture::EndPanEvent(GestureProperties& gesture, void Gesture::EndPanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
GestureProperties& last_gesture_props, GestureType& type, GestureType& type, f32 time_difference) {
f32 time_difference) {
const auto& last_entry = GetLastGestureEntry(); const auto& last_entry = GetLastGestureEntry();
next_state.vel_x = next_state.vel_x =
static_cast<f32>(last_entry.delta.x) / (last_pan_time_difference + time_difference); static_cast<f32>(last_entry.delta.x) / (last_pan_time_difference + time_difference);
@ -287,8 +281,8 @@ void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
force_update = true; force_update = true;
} }
void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture, void Gesture::SetSwipeEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
GestureProperties& last_gesture_props, GestureType& type) { GestureType& type) {
const auto& last_entry = GetLastGestureEntry(); const auto& last_entry = GetLastGestureEntry();
type = GestureType::Swipe; type = GestureType::Swipe;
@ -311,11 +305,11 @@ void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture,
next_state.direction = GestureDirection::Up; next_state.direction = GestureDirection::Up;
} }
const Controller_Gesture::GestureState& Controller_Gesture::GetLastGestureEntry() const { const Gesture::GestureState& Gesture::GetLastGestureEntry() const {
return shared_memory->gesture_lifo.ReadCurrentEntry().state; return shared_memory->gesture_lifo.ReadCurrentEntry().state;
} }
Controller_Gesture::GestureProperties Controller_Gesture::GetGestureProperties() { Gesture::GestureProperties Gesture::GetGestureProperties() {
GestureProperties gesture; GestureProperties gesture;
std::array<Core::HID::TouchFinger, 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 end_iter = std::copy_if(fingers.begin(), fingers.end(), active_fingers.begin(),

6
src/core/hle/service/hid/controllers/gesture.h
View File

@ -12,10 +12,10 @@
#include "core/hle/service/hid/ring_lifo.h" #include "core/hle/service/hid/ring_lifo.h"
namespace Service::HID { namespace Service::HID {
class Controller_Gesture final : public ControllerBase { class Gesture final : public ControllerBase {
public: public:
explicit Controller_Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); explicit Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
~Controller_Gesture() override; ~Gesture() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;

10
src/core/hle/service/hid/controllers/keyboard.cpp
View File

@ -12,7 +12,7 @@
namespace Service::HID { namespace Service::HID {
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800; constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
Controller_Keyboard::Controller_Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) Keyboard::Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
: ControllerBase{hid_core_} { : ControllerBase{hid_core_} {
static_assert(SHARED_MEMORY_OFFSET + sizeof(KeyboardSharedMemory) < shared_memory_size, static_assert(SHARED_MEMORY_OFFSET + sizeof(KeyboardSharedMemory) < shared_memory_size,
"KeyboardSharedMemory is bigger than the shared memory"); "KeyboardSharedMemory is bigger than the shared memory");
@ -21,13 +21,13 @@ Controller_Keyboard::Controller_Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_
emulated_devices = hid_core.GetEmulatedDevices(); emulated_devices = hid_core.GetEmulatedDevices();
} }
Controller_Keyboard::~Controller_Keyboard() = default; Keyboard::~Keyboard() = default;
void Controller_Keyboard::OnInit() {} void Keyboard::OnInit() {}
void Controller_Keyboard::OnRelease() {} void Keyboard::OnRelease() {}
void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
shared_memory->keyboard_lifo.buffer_count = 0; shared_memory->keyboard_lifo.buffer_count = 0;
shared_memory->keyboard_lifo.buffer_tail = 0; shared_memory->keyboard_lifo.buffer_tail = 0;

6
src/core/hle/service/hid/controllers/keyboard.h
View File

@ -14,10 +14,10 @@ struct KeyboardKey;
} // namespace Core::HID } // namespace Core::HID
namespace Service::HID { namespace Service::HID {
class Controller_Keyboard final : public ControllerBase { class Keyboard final : public ControllerBase {
public: public:
explicit Controller_Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); explicit Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
~Controller_Keyboard() override; ~Keyboard() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;

11
src/core/hle/service/hid/controllers/mouse.cpp
View File

@ -12,8 +12,7 @@
namespace Service::HID { namespace Service::HID {
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400; constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400;
Controller_Mouse::Controller_Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) Mouse::Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) : ControllerBase{hid_core_} {
: ControllerBase{hid_core_} {
static_assert(SHARED_MEMORY_OFFSET + sizeof(MouseSharedMemory) < shared_memory_size, static_assert(SHARED_MEMORY_OFFSET + sizeof(MouseSharedMemory) < shared_memory_size,
"MouseSharedMemory is bigger than the shared memory"); "MouseSharedMemory is bigger than the shared memory");
shared_memory = std::construct_at( shared_memory = std::construct_at(
@ -21,12 +20,12 @@ Controller_Mouse::Controller_Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared
emulated_devices = hid_core.GetEmulatedDevices(); emulated_devices = hid_core.GetEmulatedDevices();
} }
Controller_Mouse::~Controller_Mouse() = default; Mouse::~Mouse() = default;
void Controller_Mouse::OnInit() {} void Mouse::OnInit() {}
void Controller_Mouse::OnRelease() {} void Mouse::OnRelease() {}
void Controller_Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
shared_memory->mouse_lifo.buffer_count = 0; shared_memory->mouse_lifo.buffer_count = 0;
shared_memory->mouse_lifo.buffer_tail = 0; shared_memory->mouse_lifo.buffer_tail = 0;

6
src/core/hle/service/hid/controllers/mouse.h
View File

@ -14,10 +14,10 @@ struct AnalogStickState;
} // namespace Core::HID } // namespace Core::HID
namespace Service::HID { namespace Service::HID {
class Controller_Mouse final : public ControllerBase { class Mouse final : public ControllerBase {
public: public:
explicit Controller_Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); explicit Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
~Controller_Mouse() override; ~Mouse() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;

584
src/core/hle/service/hid/controllers/npad.cpp
View File

@ -18,6 +18,7 @@
#include "core/hle/kernel/k_readable_event.h" #include "core/hle/kernel/k_readable_event.h"
#include "core/hle/service/hid/controllers/npad.h" #include "core/hle/service/hid/controllers/npad.h"
#include "core/hle/service/hid/errors.h" #include "core/hle/service/hid/errors.h"
#include "core/hle/service/hid/hid_util.h"
#include "core/hle/service/kernel_helpers.h" #include "core/hle/service/kernel_helpers.h"
namespace Service::HID { namespace Service::HID {
@ -29,59 +30,7 @@ constexpr std::array<Core::HID::NpadIdType, 10> npad_id_list{
Core::HID::NpadIdType::Handheld, Core::HID::NpadIdType::Handheld,
}; };
bool Controller_NPad::IsNpadIdValid(Core::HID::NpadIdType npad_id) { NPad::NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
switch (npad_id) {
case Core::HID::NpadIdType::Player1:
case Core::HID::NpadIdType::Player2:
case Core::HID::NpadIdType::Player3:
case Core::HID::NpadIdType::Player4:
case Core::HID::NpadIdType::Player5:
case Core::HID::NpadIdType::Player6:
case Core::HID::NpadIdType::Player7:
case Core::HID::NpadIdType::Player8:
case Core::HID::NpadIdType::Other:
case Core::HID::NpadIdType::Handheld:
return true;
default:
LOG_ERROR(Service_HID, "Invalid npad id {}", npad_id);
return false;
}
}
Result Controller_NPad::IsDeviceHandleValid(const Core::HID::VibrationDeviceHandle& device_handle) {
const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(device_handle.npad_id));
const bool npad_type = device_handle.npad_type < Core::HID::NpadStyleIndex::MaxNpadType;
const bool device_index = device_handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex;
if (!npad_type) {
return VibrationInvalidStyleIndex;
}
if (!npad_id) {
return VibrationInvalidNpadId;
}
if (!device_index) {
return VibrationDeviceIndexOutOfRange;
}
return ResultSuccess;
}
Result Controller_NPad::VerifyValidSixAxisSensorHandle(
const Core::HID::SixAxisSensorHandle& device_handle) {
const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(device_handle.npad_id));
const bool device_index = device_handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex;
if (!npad_id) {
return InvalidNpadId;
}
if (!device_index) {
return NpadDeviceIndexOutOfRange;
}
return ResultSuccess;
}
Controller_NPad::Controller_NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
KernelHelpers::ServiceContext& service_context_) KernelHelpers::ServiceContext& service_context_)
: ControllerBase{hid_core_}, service_context{service_context_} { : ControllerBase{hid_core_}, service_context{service_context_} {
static_assert(NPAD_OFFSET + (NPAD_COUNT * sizeof(NpadInternalState)) < shared_memory_size); static_assert(NPAD_OFFSET + (NPAD_COUNT * sizeof(NpadInternalState)) < shared_memory_size);
@ -103,7 +52,7 @@ Controller_NPad::Controller_NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_m
} }
} }
Controller_NPad::~Controller_NPad() { NPad::~NPad() {
for (std::size_t i = 0; i < controller_data.size(); ++i) { for (std::size_t i = 0; i < controller_data.size(); ++i) {
auto& controller = controller_data[i]; auto& controller = controller_data[i];
controller.device->DeleteCallback(controller.callback_key); controller.device->DeleteCallback(controller.callback_key);
@ -111,8 +60,7 @@ Controller_NPad::~Controller_NPad() {
OnRelease(); OnRelease();
} }
void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx) {
std::size_t controller_idx) {
if (type == Core::HID::ControllerTriggerType::All) { if (type == Core::HID::ControllerTriggerType::All) {
ControllerUpdate(Core::HID::ControllerTriggerType::Connected, controller_idx); ControllerUpdate(Core::HID::ControllerTriggerType::Connected, controller_idx);
ControllerUpdate(Core::HID::ControllerTriggerType::Battery, controller_idx); ControllerUpdate(Core::HID::ControllerTriggerType::Battery, controller_idx);
@ -150,7 +98,7 @@ void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type,
} }
} }
void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) { void NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
auto& controller = GetControllerFromNpadIdType(npad_id); auto& controller = GetControllerFromNpadIdType(npad_id);
if (!IsControllerSupported(controller.device->GetNpadStyleIndex())) { if (!IsControllerSupported(controller.device->GetNpadStyleIndex())) {
return; return;
@ -350,7 +298,7 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
hid_core.SetLastActiveController(npad_id); hid_core.SetLastActiveController(npad_id);
} }
void Controller_NPad::OnInit() { void NPad::OnInit() {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
return; return;
} }
@ -384,7 +332,7 @@ void Controller_NPad::OnInit() {
} }
} }
void Controller_NPad::WriteEmptyEntry(NpadInternalState* npad) { void NPad::WriteEmptyEntry(NpadInternalState* npad) {
NPadGenericState dummy_pad_state{}; NPadGenericState dummy_pad_state{};
NpadGcTriggerState dummy_gc_state{}; NpadGcTriggerState dummy_gc_state{};
dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().sampling_number + 1; dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().sampling_number + 1;
@ -405,7 +353,7 @@ void Controller_NPad::WriteEmptyEntry(NpadInternalState* npad) {
npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state); npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
} }
void Controller_NPad::OnRelease() { void NPad::OnRelease() {
is_controller_initialized = false; is_controller_initialized = false;
for (std::size_t i = 0; i < controller_data.size(); ++i) { for (std::size_t i = 0; i < controller_data.size(); ++i) {
auto& controller = controller_data[i]; auto& controller = controller_data[i];
@ -416,7 +364,7 @@ void Controller_NPad::OnRelease() {
} }
} }
void Controller_NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) { void NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
auto& controller = GetControllerFromNpadIdType(npad_id); auto& controller = GetControllerFromNpadIdType(npad_id);
const auto controller_type = controller.device->GetNpadStyleIndex(); const auto controller_type = controller.device->GetNpadStyleIndex();
@ -485,7 +433,7 @@ void Controller_NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
} }
} }
void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
return; return;
} }
@ -615,134 +563,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
} }
} }
void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing) { void NPad::SetSupportedStyleSet(Core::HID::NpadStyleTag style_set) {
if (!IsControllerActivated()) {
return;
}
for (std::size_t i = 0; i < controller_data.size(); ++i) {
auto& controller = controller_data[i];
const auto& controller_type = controller.device->GetNpadStyleIndex();
if (controller_type == Core::HID::NpadStyleIndex::None ||
!controller.device->IsConnected()) {
continue;
}
auto* npad = controller.shared_memory;
const auto& motion_state = controller.device->GetMotions();
auto& sixaxis_fullkey_state = controller.sixaxis_fullkey_state;
auto& sixaxis_handheld_state = controller.sixaxis_handheld_state;
auto& sixaxis_dual_left_state = controller.sixaxis_dual_left_state;
auto& sixaxis_dual_right_state = controller.sixaxis_dual_right_state;
auto& sixaxis_left_lifo_state = controller.sixaxis_left_lifo_state;
auto& sixaxis_right_lifo_state = controller.sixaxis_right_lifo_state;
// Clear previous state
sixaxis_fullkey_state = {};
sixaxis_handheld_state = {};
sixaxis_dual_left_state = {};
sixaxis_dual_right_state = {};
sixaxis_left_lifo_state = {};
sixaxis_right_lifo_state = {};
if (controller.sixaxis_sensor_enabled && Settings::values.motion_enabled.GetValue()) {
controller.sixaxis_at_rest = true;
for (std::size_t e = 0; e < motion_state.size(); ++e) {
controller.sixaxis_at_rest =
controller.sixaxis_at_rest && motion_state[e].is_at_rest;
}
}
const auto set_motion_state = [&](SixAxisSensorState& state,
const Core::HID::ControllerMotion& hid_state) {
using namespace std::literals::chrono_literals;
static constexpr SixAxisSensorState default_motion_state = {
.delta_time = std::chrono::nanoseconds(5ms).count(),
.accel = {0, 0, -1.0f},
.orientation =
{
Common::Vec3f{1.0f, 0, 0},
Common::Vec3f{0, 1.0f, 0},
Common::Vec3f{0, 0, 1.0f},
},
.attribute = {1},
};
if (!controller.sixaxis_sensor_enabled) {
state = default_motion_state;
return;
}
if (!Settings::values.motion_enabled.GetValue()) {
state = default_motion_state;
return;
}
state.attribute.is_connected.Assign(1);
state.delta_time = std::chrono::nanoseconds(5ms).count();
state.accel = hid_state.accel;
state.gyro = hid_state.gyro;
state.rotation = hid_state.rotation;
state.orientation = hid_state.orientation;
};
switch (controller_type) {
case Core::HID::NpadStyleIndex::None:
ASSERT(false);
break;
case Core::HID::NpadStyleIndex::ProController:
set_motion_state(sixaxis_fullkey_state, motion_state[0]);
break;
case Core::HID::NpadStyleIndex::Handheld:
set_motion_state(sixaxis_handheld_state, motion_state[0]);
break;
case Core::HID::NpadStyleIndex::JoyconDual:
set_motion_state(sixaxis_dual_left_state, motion_state[0]);
set_motion_state(sixaxis_dual_right_state, motion_state[1]);
break;
case Core::HID::NpadStyleIndex::JoyconLeft:
set_motion_state(sixaxis_left_lifo_state, motion_state[0]);
break;
case Core::HID::NpadStyleIndex::JoyconRight:
set_motion_state(sixaxis_right_lifo_state, motion_state[1]);
break;
case Core::HID::NpadStyleIndex::Pokeball:
using namespace std::literals::chrono_literals;
set_motion_state(sixaxis_fullkey_state, motion_state[0]);
sixaxis_fullkey_state.delta_time = std::chrono::nanoseconds(15ms).count();
break;
default:
break;
}
sixaxis_fullkey_state.sampling_number =
npad->sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_handheld_state.sampling_number =
npad->sixaxis_handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_dual_left_state.sampling_number =
npad->sixaxis_dual_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_dual_right_state.sampling_number =
npad->sixaxis_dual_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_left_lifo_state.sampling_number =
npad->sixaxis_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_right_lifo_state.sampling_number =
npad->sixaxis_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
if (Core::HID::IndexToNpadIdType(i) == Core::HID::NpadIdType::Handheld) {
// This buffer only is updated on handheld on HW
npad->sixaxis_handheld_lifo.WriteNextEntry(sixaxis_handheld_state);
} else {
// Handheld doesn't update this buffer on HW
npad->sixaxis_fullkey_lifo.WriteNextEntry(sixaxis_fullkey_state);
}
npad->sixaxis_dual_left_lifo.WriteNextEntry(sixaxis_dual_left_state);
npad->sixaxis_dual_right_lifo.WriteNextEntry(sixaxis_dual_right_state);
npad->sixaxis_left_lifo.WriteNextEntry(sixaxis_left_lifo_state);
npad->sixaxis_right_lifo.WriteNextEntry(sixaxis_right_lifo_state);
}
}
void Controller_NPad::SetSupportedStyleSet(Core::HID::NpadStyleTag style_set) {
hid_core.SetSupportedStyleTag(style_set); hid_core.SetSupportedStyleTag(style_set);
if (is_controller_initialized) { if (is_controller_initialized) {
@ -753,14 +574,14 @@ void Controller_NPad::SetSupportedStyleSet(Core::HID::NpadStyleTag style_set) {
is_controller_initialized = true; is_controller_initialized = true;
} }
Core::HID::NpadStyleTag Controller_NPad::GetSupportedStyleSet() const { Core::HID::NpadStyleTag NPad::GetSupportedStyleSet() const {
if (!is_controller_initialized) { if (!is_controller_initialized) {
return {Core::HID::NpadStyleSet::None}; return {Core::HID::NpadStyleSet::None};
} }
return hid_core.GetSupportedStyleTag(); return hid_core.GetSupportedStyleTag();
} }
Result Controller_NPad::SetSupportedNpadIdTypes(std::span<const u8> data) { Result NPad::SetSupportedNpadIdTypes(std::span<const u8> data) {
constexpr std::size_t max_number_npad_ids = 0xa; constexpr std::size_t max_number_npad_ids = 0xa;
const auto length = data.size(); const auto length = data.size();
ASSERT(length > 0 && (length % sizeof(u32)) == 0); ASSERT(length > 0 && (length % sizeof(u32)) == 0);
@ -776,17 +597,17 @@ Result Controller_NPad::SetSupportedNpadIdTypes(std::span<const u8> data) {
return ResultSuccess; return ResultSuccess;
} }
void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) { void NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
const auto copy_amount = supported_npad_id_types.size() * sizeof(u32); const auto copy_amount = supported_npad_id_types.size() * sizeof(u32);
ASSERT(max_length <= copy_amount); ASSERT(max_length <= copy_amount);
std::memcpy(data, supported_npad_id_types.data(), copy_amount); std::memcpy(data, supported_npad_id_types.data(), copy_amount);
} }
std::size_t Controller_NPad::GetSupportedNpadIdTypesSize() const { std::size_t NPad::GetSupportedNpadIdTypesSize() const {
return supported_npad_id_types.size(); return supported_npad_id_types.size();
} }
void Controller_NPad::SetHoldType(NpadJoyHoldType joy_hold_type) { void NPad::SetHoldType(NpadJoyHoldType joy_hold_type) {
if (joy_hold_type != NpadJoyHoldType::Horizontal && if (joy_hold_type != NpadJoyHoldType::Horizontal &&
joy_hold_type != NpadJoyHoldType::Vertical) { joy_hold_type != NpadJoyHoldType::Vertical) {
LOG_ERROR(Service_HID, "Npad joy hold type needs to be valid, joy_hold_type={}", LOG_ERROR(Service_HID, "Npad joy hold type needs to be valid, joy_hold_type={}",
@ -796,11 +617,11 @@ void Controller_NPad::SetHoldType(NpadJoyHoldType joy_hold_type) {
hold_type = joy_hold_type; hold_type = joy_hold_type;
} }
Controller_NPad::NpadJoyHoldType Controller_NPad::GetHoldType() const { NPad::NpadJoyHoldType NPad::GetHoldType() const {
return hold_type; return hold_type;
} }
void Controller_NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_mode) { void NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_mode) {
if (activation_mode >= NpadHandheldActivationMode::MaxActivationMode) { if (activation_mode >= NpadHandheldActivationMode::MaxActivationMode) {
ASSERT_MSG(false, "Activation mode should be always None, Single or Dual"); ASSERT_MSG(false, "Activation mode should be always None, Single or Dual");
return; return;
@ -809,21 +630,20 @@ void Controller_NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode a
handheld_activation_mode = activation_mode; handheld_activation_mode = activation_mode;
} }
Controller_NPad::NpadHandheldActivationMode Controller_NPad::GetNpadHandheldActivationMode() const { NPad::NpadHandheldActivationMode NPad::GetNpadHandheldActivationMode() const {
return handheld_activation_mode; return handheld_activation_mode;
} }
void Controller_NPad::SetNpadCommunicationMode(NpadCommunicationMode communication_mode_) { void NPad::SetNpadCommunicationMode(NpadCommunicationMode communication_mode_) {
communication_mode = communication_mode_; communication_mode = communication_mode_;
} }
Controller_NPad::NpadCommunicationMode Controller_NPad::GetNpadCommunicationMode() const { NPad::NpadCommunicationMode NPad::GetNpadCommunicationMode() const {
return communication_mode; return communication_mode;
} }
bool Controller_NPad::SetNpadMode(Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id, bool NPad::SetNpadMode(Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
NpadJoyDeviceType npad_device_type, NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode) {
NpadJoyAssignmentMode assignment_mode) {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
return false; return false;
@ -892,8 +712,7 @@ bool Controller_NPad::SetNpadMode(Core::HID::NpadIdType& new_npad_id, Core::HID:
return true; return true;
} }
bool Controller_NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id, bool NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id, std::size_t device_index,
std::size_t device_index,
const Core::HID::VibrationValue& vibration_value) { const Core::HID::VibrationValue& vibration_value) {
auto& controller = GetControllerFromNpadIdType(npad_id); auto& controller = GetControllerFromNpadIdType(npad_id);
if (!controller.device->IsConnected()) { if (!controller.device->IsConnected()) {
@ -938,10 +757,9 @@ bool Controller_NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id,
return controller.device->SetVibration(device_index, vibration); return controller.device->SetVibration(device_index, vibration);
} }
void Controller_NPad::VibrateController( void NPad::VibrateController(const Core::HID::VibrationDeviceHandle& vibration_device_handle,
const Core::HID::VibrationDeviceHandle& vibration_device_handle,
const Core::HID::VibrationValue& vibration_value) { const Core::HID::VibrationValue& vibration_value) {
if (IsDeviceHandleValid(vibration_device_handle).IsError()) { if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
return; return;
} }
@ -985,7 +803,7 @@ void Controller_NPad::VibrateController(
} }
} }
void Controller_NPad::VibrateControllers( void NPad::VibrateControllers(
std::span<const Core::HID::VibrationDeviceHandle> vibration_device_handles, std::span<const Core::HID::VibrationDeviceHandle> vibration_device_handles,
std::span<const Core::HID::VibrationValue> vibration_values) { std::span<const Core::HID::VibrationValue> vibration_values) {
if (!Settings::values.vibration_enabled.GetValue() && !permit_vibration_session_enabled) { if (!Settings::values.vibration_enabled.GetValue() && !permit_vibration_session_enabled) {
@ -1002,9 +820,9 @@ void Controller_NPad::VibrateControllers(
} }
} }
Core::HID::VibrationValue Controller_NPad::GetLastVibration( Core::HID::VibrationValue NPad::GetLastVibration(
const Core::HID::VibrationDeviceHandle& vibration_device_handle) const { const Core::HID::VibrationDeviceHandle& vibration_device_handle) const {
if (IsDeviceHandleValid(vibration_device_handle).IsError()) { if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
return {}; return {};
} }
@ -1013,9 +831,9 @@ Core::HID::VibrationValue Controller_NPad::GetLastVibration(
return controller.vibration[device_index].latest_vibration_value; return controller.vibration[device_index].latest_vibration_value;
} }
void Controller_NPad::InitializeVibrationDevice( void NPad::InitializeVibrationDevice(
const Core::HID::VibrationDeviceHandle& vibration_device_handle) { const Core::HID::VibrationDeviceHandle& vibration_device_handle) {
if (IsDeviceHandleValid(vibration_device_handle).IsError()) { if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
return; return;
} }
@ -1024,7 +842,7 @@ void Controller_NPad::InitializeVibrationDevice(
InitializeVibrationDeviceAtIndex(npad_index, device_index); InitializeVibrationDeviceAtIndex(npad_index, device_index);
} }
void Controller_NPad::InitializeVibrationDeviceAtIndex(Core::HID::NpadIdType npad_id, void NPad::InitializeVibrationDeviceAtIndex(Core::HID::NpadIdType npad_id,
std::size_t device_index) { std::size_t device_index) {
auto& controller = GetControllerFromNpadIdType(npad_id); auto& controller = GetControllerFromNpadIdType(npad_id);
if (!Settings::values.vibration_enabled.GetValue()) { if (!Settings::values.vibration_enabled.GetValue()) {
@ -1036,13 +854,13 @@ void Controller_NPad::InitializeVibrationDeviceAtIndex(Core::HID::NpadIdType npa
controller.device->IsVibrationEnabled(device_index); controller.device->IsVibrationEnabled(device_index);
} }
void Controller_NPad::SetPermitVibrationSession(bool permit_vibration_session) { void NPad::SetPermitVibrationSession(bool permit_vibration_session) {
permit_vibration_session_enabled = permit_vibration_session; permit_vibration_session_enabled = permit_vibration_session;
} }
bool Controller_NPad::IsVibrationDeviceMounted( bool NPad::IsVibrationDeviceMounted(
const Core::HID::VibrationDeviceHandle& vibration_device_handle) const { const Core::HID::VibrationDeviceHandle& vibration_device_handle) const {
if (IsDeviceHandleValid(vibration_device_handle).IsError()) { if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
return false; return false;
} }
@ -1051,7 +869,7 @@ bool Controller_NPad::IsVibrationDeviceMounted(
return controller.vibration[device_index].device_mounted; return controller.vibration[device_index].device_mounted;
} }
Kernel::KReadableEvent& Controller_NPad::GetStyleSetChangedEvent(Core::HID::NpadIdType npad_id) { Kernel::KReadableEvent& NPad::GetStyleSetChangedEvent(Core::HID::NpadIdType npad_id) {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
// Fallback to player 1 // Fallback to player 1
@ -1063,18 +881,17 @@ Kernel::KReadableEvent& Controller_NPad::GetStyleSetChangedEvent(Core::HID::Npad
return controller.styleset_changed_event->GetReadableEvent(); return controller.styleset_changed_event->GetReadableEvent();
} }
void Controller_NPad::SignalStyleSetChangedEvent(Core::HID::NpadIdType npad_id) const { void NPad::SignalStyleSetChangedEvent(Core::HID::NpadIdType npad_id) const {
const auto& controller = GetControllerFromNpadIdType(npad_id); const auto& controller = GetControllerFromNpadIdType(npad_id);
controller.styleset_changed_event->Signal(); controller.styleset_changed_event->Signal();
} }
void Controller_NPad::AddNewControllerAt(Core::HID::NpadStyleIndex controller, void NPad::AddNewControllerAt(Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id) {
Core::HID::NpadIdType npad_id) {
UpdateControllerAt(controller, npad_id, true); UpdateControllerAt(controller, npad_id, true);
} }
void Controller_NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type, void NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type, Core::HID::NpadIdType npad_id,
Core::HID::NpadIdType npad_id, bool connected) { bool connected) {
auto& controller = GetControllerFromNpadIdType(npad_id); auto& controller = GetControllerFromNpadIdType(npad_id);
if (!connected) { if (!connected) {
DisconnectNpad(npad_id); DisconnectNpad(npad_id);
@ -1085,7 +902,7 @@ void Controller_NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type,
InitNewlyAddedController(npad_id); InitNewlyAddedController(npad_id);
} }
Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) { Result NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
return InvalidNpadId; return InvalidNpadId;
@ -1134,54 +951,9 @@ Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
return ResultSuccess; return ResultSuccess;
} }
Result Controller_NPad::SetGyroscopeZeroDriftMode( Result NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode drift_mode) {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
auto& sixaxis = GetSixaxisState(sixaxis_handle);
auto& controller = GetControllerFromHandle(sixaxis_handle);
sixaxis.gyroscope_zero_drift_mode = drift_mode;
controller.device->SetGyroscopeZeroDriftMode(drift_mode);
return ResultSuccess;
}
Result Controller_NPad::GetGyroscopeZeroDriftMode(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode& drift_mode) const {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
drift_mode = sixaxis.gyroscope_zero_drift_mode;
return ResultSuccess;
}
Result Controller_NPad::IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool& is_at_rest) const {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& controller = GetControllerFromHandle(sixaxis_handle);
is_at_rest = controller.sixaxis_at_rest;
return ResultSuccess;
}
Result Controller_NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const { const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle); const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) { if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw); LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid; return is_valid;
@ -1192,65 +964,9 @@ Result Controller_NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
return ResultSuccess; return ResultSuccess;
} }
Result Controller_NPad::EnableSixAxisSensorUnalteredPassthrough( Result NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled) {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
auto& sixaxis = GetSixaxisState(sixaxis_handle);
sixaxis.unaltered_passtrough = is_enabled;
return ResultSuccess;
}
Result Controller_NPad::IsSixAxisSensorUnalteredPassthroughEnabled(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
is_enabled = sixaxis.unaltered_passtrough;
return ResultSuccess;
}
Result Controller_NPad::LoadSixAxisSensorCalibrationParameter(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorCalibrationParameter& calibration) const {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
// TODO: Request this data to the controller. On error return 0xd8ca
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
calibration = sixaxis.calibration;
return ResultSuccess;
}
Result Controller_NPad::GetSixAxisSensorIcInformation(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorIcInformation& ic_information) const {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
// TODO: Request this data to the controller. On error return 0xd8ca
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
ic_information = sixaxis.ic_information;
return ResultSuccess;
}
Result Controller_NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
const Core::HID::SixAxisSensorHandle& sixaxis_handle) { const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle); const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) { if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw); LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid; return is_valid;
@ -1262,82 +978,31 @@ Result Controller_NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
return ResultSuccess; return ResultSuccess;
} }
Result Controller_NPad::SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle, NPad::SixAxisLifo& NPad::GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id) {
bool sixaxis_status) { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_fullkey_lifo;
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
} }
auto& controller = GetControllerFromHandle(sixaxis_handle); NPad::SixAxisLifo& NPad::GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id) {
controller.sixaxis_sensor_enabled = sixaxis_status; return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_handheld_lifo;
return ResultSuccess;
} }
Result Controller_NPad::IsSixAxisSensorFusionEnabled( NPad::SixAxisLifo& NPad::GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id) {
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_fusion_enabled) const { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_dual_left_lifo;
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
} }
const auto& sixaxis = GetSixaxisState(sixaxis_handle); NPad::SixAxisLifo& NPad::GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id) {
is_fusion_enabled = sixaxis.is_fusion_enabled; return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_dual_right_lifo;
return ResultSuccess;
}
Result Controller_NPad::SetSixAxisFusionEnabled(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_fusion_enabled) {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
} }
auto& sixaxis = GetSixaxisState(sixaxis_handle); NPad::SixAxisLifo& NPad::GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id) {
sixaxis.is_fusion_enabled = is_fusion_enabled; return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_left_lifo;
return ResultSuccess;
} }
Result Controller_NPad::SetSixAxisFusionParameters( NPad::SixAxisLifo& NPad::GetSixAxisRightLifo(Core::HID::NpadIdType npad_id) {
const Core::HID::SixAxisSensorHandle& sixaxis_handle, return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_right_lifo;
Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters) {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
} }
const auto param1 = sixaxis_fusion_parameters.parameter1; Result NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
if (param1 < 0.0f || param1 > 1.0f) {
return InvalidSixAxisFusionRange;
}
auto& sixaxis = GetSixaxisState(sixaxis_handle);
sixaxis.fusion = sixaxis_fusion_parameters;
return ResultSuccess;
}
Result Controller_NPad::GetSixAxisFusionParameters(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorFusionParameters& parameters) const {
const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
parameters = sixaxis.fusion;
return ResultSuccess;
}
Result Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
Core::HID::NpadIdType npad_id_2) { Core::HID::NpadIdType npad_id_2) {
if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) { if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1, LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
@ -1400,18 +1065,17 @@ Result Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
return ResultSuccess; return ResultSuccess;
} }
void Controller_NPad::StartLRAssignmentMode() { void NPad::StartLRAssignmentMode() {
// Nothing internally is used for lr assignment mode. Since we have the ability to set the // Nothing internally is used for lr assignment mode. Since we have the ability to set the
// controller types from boot, it doesn't really matter about showing a selection screen // controller types from boot, it doesn't really matter about showing a selection screen
is_in_lr_assignment_mode = true; is_in_lr_assignment_mode = true;
} }
void Controller_NPad::StopLRAssignmentMode() { void NPad::StopLRAssignmentMode() {
is_in_lr_assignment_mode = false; is_in_lr_assignment_mode = false;
} }
Result Controller_NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Result NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2) {
Core::HID::NpadIdType npad_id_2) {
if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) { if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1, LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
npad_id_2); npad_id_2);
@ -1442,8 +1106,7 @@ Result Controller_NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
return ResultSuccess; return ResultSuccess;
} }
Result Controller_NPad::GetLedPattern(Core::HID::NpadIdType npad_id, Result NPad::GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const {
Core::HID::LedPattern& pattern) const {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
return InvalidNpadId; return InvalidNpadId;
@ -1453,7 +1116,7 @@ Result Controller_NPad::GetLedPattern(Core::HID::NpadIdType npad_id,
return ResultSuccess; return ResultSuccess;
} }
Result Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id, Result NPad::IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
bool& is_valid) const { bool& is_valid) const {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
@ -1464,8 +1127,8 @@ Result Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::
return ResultSuccess; return ResultSuccess;
} }
Result Controller_NPad::SetUnintendedHomeButtonInputProtectionEnabled( Result NPad::SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled,
bool is_protection_enabled, Core::HID::NpadIdType npad_id) { Core::HID::NpadIdType npad_id) {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
return InvalidNpadId; return InvalidNpadId;
@ -1475,11 +1138,11 @@ Result Controller_NPad::SetUnintendedHomeButtonInputProtectionEnabled(
return ResultSuccess; return ResultSuccess;
} }
void Controller_NPad::SetAnalogStickUseCenterClamp(bool use_center_clamp) { void NPad::SetAnalogStickUseCenterClamp(bool use_center_clamp) {
analog_stick_use_center_clamp = use_center_clamp; analog_stick_use_center_clamp = use_center_clamp;
} }
void Controller_NPad::ClearAllConnectedControllers() { void NPad::ClearAllConnectedControllers() {
for (auto& controller : controller_data) { for (auto& controller : controller_data) {
if (controller.device->IsConnected() && if (controller.device->IsConnected() &&
controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None) { controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None) {
@ -1489,13 +1152,13 @@ void Controller_NPad::ClearAllConnectedControllers() {
} }
} }
void Controller_NPad::DisconnectAllConnectedControllers() { void NPad::DisconnectAllConnectedControllers() {
for (auto& controller : controller_data) { for (auto& controller : controller_data) {
controller.device->Disconnect(); controller.device->Disconnect();
} }
} }
void Controller_NPad::ConnectAllDisconnectedControllers() { void NPad::ConnectAllDisconnectedControllers() {
for (auto& controller : controller_data) { for (auto& controller : controller_data) {
if (controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None && if (controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None &&
!controller.device->IsConnected()) { !controller.device->IsConnected()) {
@ -1504,18 +1167,18 @@ void Controller_NPad::ConnectAllDisconnectedControllers() {
} }
} }
void Controller_NPad::ClearAllControllers() { void NPad::ClearAllControllers() {
for (auto& controller : controller_data) { for (auto& controller : controller_data) {
controller.device->Disconnect(); controller.device->Disconnect();
controller.device->SetNpadStyleIndex(Core::HID::NpadStyleIndex::None); controller.device->SetNpadStyleIndex(Core::HID::NpadStyleIndex::None);
} }
} }
Core::HID::NpadButton Controller_NPad::GetAndResetPressState() { Core::HID::NpadButton NPad::GetAndResetPressState() {
return static_cast<Core::HID::NpadButton>(press_state.exchange(0)); return static_cast<Core::HID::NpadButton>(press_state.exchange(0));
} }
void Controller_NPad::ApplyNpadSystemCommonPolicy() { void NPad::ApplyNpadSystemCommonPolicy() {
Core::HID::NpadStyleTag styletag{}; Core::HID::NpadStyleTag styletag{};
styletag.fullkey.Assign(1); styletag.fullkey.Assign(1);
styletag.handheld.Assign(1); styletag.handheld.Assign(1);
@ -1540,7 +1203,7 @@ void Controller_NPad::ApplyNpadSystemCommonPolicy() {
supported_npad_id_types[9] = Core::HID::NpadIdType::Handheld; supported_npad_id_types[9] = Core::HID::NpadIdType::Handheld;
} }
bool Controller_NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller) const { bool NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller) const {
if (controller == Core::HID::NpadStyleIndex::Handheld) { if (controller == Core::HID::NpadStyleIndex::Handheld) {
const bool support_handheld = const bool support_handheld =
std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(), std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(),
@ -1591,51 +1254,50 @@ bool Controller_NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller
return false; return false;
} }
Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle( NPad::NpadControllerData& NPad::GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id);
}
const Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) const {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id);
}
Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle(
const Core::HID::VibrationDeviceHandle& device_handle) { const Core::HID::VibrationDeviceHandle& device_handle) {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id); const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id); return GetControllerFromNpadIdType(npad_id);
} }
const Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle( const NPad::NpadControllerData& NPad::GetControllerFromHandle(
const Core::HID::VibrationDeviceHandle& device_handle) const { const Core::HID::VibrationDeviceHandle& device_handle) const {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id); const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id); return GetControllerFromNpadIdType(npad_id);
} }
Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromNpadIdType( NPad::NpadControllerData& NPad::GetControllerFromHandle(
Core::HID::NpadIdType npad_id) { const Core::HID::SixAxisSensorHandle& device_handle) {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id);
}
const NPad::NpadControllerData& NPad::GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) const {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id);
}
NPad::NpadControllerData& NPad::GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
npad_id = Core::HID::NpadIdType::Player1; npad_id = Core::HID::NpadIdType::Player1;
} }
const auto npad_index = Core::HID::NpadIdTypeToIndex(npad_id); const auto npad_index = NpadIdTypeToIndex(npad_id);
return controller_data[npad_index]; return controller_data[npad_index];
} }
const Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromNpadIdType( const NPad::NpadControllerData& NPad::GetControllerFromNpadIdType(
Core::HID::NpadIdType npad_id) const { Core::HID::NpadIdType npad_id) const {
if (!IsNpadIdValid(npad_id)) { if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id); LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
npad_id = Core::HID::NpadIdType::Player1; npad_id = Core::HID::NpadIdType::Player1;
} }
const auto npad_index = Core::HID::NpadIdTypeToIndex(npad_id); const auto npad_index = NpadIdTypeToIndex(npad_id);
return controller_data[npad_index]; return controller_data[npad_index];
} }
Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties( Core::HID::SixAxisSensorProperties& NPad::GetSixaxisProperties(
const Core::HID::SixAxisSensorHandle& sixaxis_handle) { const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
auto& controller = GetControllerFromHandle(sixaxis_handle); auto& controller = GetControllerFromHandle(sixaxis_handle);
switch (sixaxis_handle.npad_type) { switch (sixaxis_handle.npad_type) {
@ -1658,7 +1320,7 @@ Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties(
} }
} }
const Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties( const Core::HID::SixAxisSensorProperties& NPad::GetSixaxisProperties(
const Core::HID::SixAxisSensorHandle& sixaxis_handle) const { const Core::HID::SixAxisSensorHandle& sixaxis_handle) const {
const auto& controller = GetControllerFromHandle(sixaxis_handle); const auto& controller = GetControllerFromHandle(sixaxis_handle);
switch (sixaxis_handle.npad_type) { switch (sixaxis_handle.npad_type) {
@ -1681,65 +1343,13 @@ const Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties(
} }
} }
Controller_NPad::SixaxisParameters& Controller_NPad::GetSixaxisState( NPad::AppletDetailedUiType NPad::GetAppletDetailedUiType(Core::HID::NpadIdType npad_id) {
const Core::HID::SixAxisSensorHandle& sixaxis_handle) { const auto& shared_memory = GetControllerFromNpadIdType(npad_id).shared_memory;
auto& controller = GetControllerFromHandle(sixaxis_handle);
switch (sixaxis_handle.npad_type) {
case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadStyleIndex::Pokeball:
return controller.sixaxis_fullkey;
case Core::HID::NpadStyleIndex::Handheld:
return controller.sixaxis_handheld;
case Core::HID::NpadStyleIndex::JoyconDual:
if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
return controller.sixaxis_dual_left;
}
return controller.sixaxis_dual_right;
case Core::HID::NpadStyleIndex::JoyconLeft:
return controller.sixaxis_left;
case Core::HID::NpadStyleIndex::JoyconRight:
return controller.sixaxis_right;
default:
return controller.sixaxis_unknown;
}
}
const Controller_NPad::SixaxisParameters& Controller_NPad::GetSixaxisState( return {
const Core::HID::SixAxisSensorHandle& sixaxis_handle) const {
const auto& controller = GetControllerFromHandle(sixaxis_handle);
switch (sixaxis_handle.npad_type) {
case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadStyleIndex::Pokeball:
return controller.sixaxis_fullkey;
case Core::HID::NpadStyleIndex::Handheld:
return controller.sixaxis_handheld;
case Core::HID::NpadStyleIndex::JoyconDual:
if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
return controller.sixaxis_dual_left;
}
return controller.sixaxis_dual_right;
case Core::HID::NpadStyleIndex::JoyconLeft:
return controller.sixaxis_left;
case Core::HID::NpadStyleIndex::JoyconRight:
return controller.sixaxis_right;
default:
return controller.sixaxis_unknown;
}
}
Controller_NPad::AppletDetailedUiType Controller_NPad::GetAppletDetailedUiType(
Core::HID::NpadIdType npad_id) {
auto controller = GetControllerFromNpadIdType(npad_id);
auto shared_memory = controller.shared_memory;
Service::HID::Controller_NPad::AppletFooterUiType applet_footer_type =
shared_memory->applet_footer_type;
Controller_NPad::AppletDetailedUiType detailed_ui_type{
.ui_variant = 0, .ui_variant = 0,
.footer = applet_footer_type, .footer = shared_memory->applet_footer_type,
}; };
return detailed_ui_type;
} }
} // namespace Service::HID } // namespace Service::HID

124
src/core/hle/service/hid/controllers/npad.h
View File

@ -10,7 +10,6 @@
#include "common/bit_field.h" #include "common/bit_field.h"
#include "common/common_types.h" #include "common/common_types.h"
#include "common/vector_math.h"
#include "core/hid/hid_types.h" #include "core/hid/hid_types.h"
#include "core/hle/service/hid/controllers/controller_base.h" #include "core/hle/service/hid/controllers/controller_base.h"
@ -34,11 +33,11 @@ union Result;
namespace Service::HID { namespace Service::HID {
class Controller_NPad final : public ControllerBase { class NPad final : public ControllerBase {
public: public:
explicit Controller_NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_, explicit NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
KernelHelpers::ServiceContext& service_context_); KernelHelpers::ServiceContext& service_context_);
~Controller_NPad() override; ~NPad() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;
@ -49,9 +48,6 @@ public:
// When the controller is requesting an update for the shared memory // When the controller is requesting an update for the shared memory
void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
// When the controller is requesting a motion update for the shared memory
void OnMotionUpdate(const Core::Timing::CoreTiming& core_timing) override;
// This is nn::hid::NpadJoyHoldType // This is nn::hid::NpadJoyHoldType
enum class NpadJoyHoldType : u64 { enum class NpadJoyHoldType : u64 {
Vertical = 0, Vertical = 0,
@ -133,6 +129,8 @@ public:
Revision3 = 3, Revision3 = 3,
}; };
using SixAxisLifo = Lifo<Core::HID::SixAxisSensorState, hid_entry_count>;
void SetSupportedStyleSet(Core::HID::NpadStyleTag style_set); void SetSupportedStyleSet(Core::HID::NpadStyleTag style_set);
Core::HID::NpadStyleTag GetSupportedStyleSet() const; Core::HID::NpadStyleTag GetSupportedStyleSet() const;
@ -185,37 +183,18 @@ public:
Result DisconnectNpad(Core::HID::NpadIdType npad_id); Result DisconnectNpad(Core::HID::NpadIdType npad_id);
Result SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode drift_mode);
Result GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode& drift_mode) const;
Result IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool& is_at_rest) const;
Result IsFirmwareUpdateAvailableForSixAxisSensor( Result IsFirmwareUpdateAvailableForSixAxisSensor(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const; const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const;
Result EnableSixAxisSensorUnalteredPassthrough(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled);
Result IsSixAxisSensorUnalteredPassthroughEnabled(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const;
Result LoadSixAxisSensorCalibrationParameter(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorCalibrationParameter& calibration) const;
Result GetSixAxisSensorIcInformation(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorIcInformation& ic_information) const;
Result ResetIsSixAxisSensorDeviceNewlyAssigned( Result ResetIsSixAxisSensorDeviceNewlyAssigned(
const Core::HID::SixAxisSensorHandle& sixaxis_handle); const Core::HID::SixAxisSensorHandle& sixaxis_handle);
Result SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool sixaxis_status); SixAxisLifo& GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id);
Result IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle, SixAxisLifo& GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id);
bool& is_fusion_enabled) const; SixAxisLifo& GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id);
Result SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle, SixAxisLifo& GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id);
bool is_fusion_enabled); SixAxisLifo& GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id);
Result SetSixAxisFusionParameters( SixAxisLifo& GetSixAxisRightLifo(Core::HID::NpadIdType npad_id);
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters);
Result GetSixAxisFusionParameters(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorFusionParameters& parameters) const;
Result GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const; Result GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const;
Result IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id, Result IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
bool& is_enabled) const; bool& is_enabled) const;
@ -239,10 +218,6 @@ public:
void ApplyNpadSystemCommonPolicy(); void ApplyNpadSystemCommonPolicy();
static bool IsNpadIdValid(Core::HID::NpadIdType npad_id);
static Result IsDeviceHandleValid(const Core::HID::VibrationDeviceHandle& device_handle);
static Result VerifyValidSixAxisSensorHandle(
const Core::HID::SixAxisSensorHandle& device_handle);
AppletDetailedUiType GetAppletDetailedUiType(Core::HID::NpadIdType npad_id); AppletDetailedUiType GetAppletDetailedUiType(Core::HID::NpadIdType npad_id);
private: private:
@ -302,29 +277,6 @@ private:
}; };
static_assert(sizeof(NPadGenericState) == 0x28, "NPadGenericState is an invalid size"); static_assert(sizeof(NPadGenericState) == 0x28, "NPadGenericState is an invalid size");
// This is nn::hid::SixAxisSensorAttribute
struct SixAxisSensorAttribute {
union {
u32 raw{};
BitField<0, 1, u32> is_connected;
BitField<1, 1, u32> is_interpolated;
};
};
static_assert(sizeof(SixAxisSensorAttribute) == 4, "SixAxisSensorAttribute is an invalid size");
// This is nn::hid::SixAxisSensorState
struct SixAxisSensorState {
s64 delta_time{};
s64 sampling_number{};
Common::Vec3f accel{};
Common::Vec3f gyro{};
Common::Vec3f rotation{};
std::array<Common::Vec3f, 3> orientation{};
SixAxisSensorAttribute attribute{};
INSERT_PADDING_BYTES(4); // Reserved
};
static_assert(sizeof(SixAxisSensorState) == 0x60, "SixAxisSensorState is an invalid size");
// This is nn::hid::server::NpadGcTriggerState // This is nn::hid::server::NpadGcTriggerState
struct NpadGcTriggerState { struct NpadGcTriggerState {
s64 sampling_number{}; s64 sampling_number{};
@ -444,12 +396,12 @@ private:
Lifo<NPadGenericState, hid_entry_count> joy_right_lifo{}; Lifo<NPadGenericState, hid_entry_count> joy_right_lifo{};
Lifo<NPadGenericState, hid_entry_count> palma_lifo{}; Lifo<NPadGenericState, hid_entry_count> palma_lifo{};
Lifo<NPadGenericState, hid_entry_count> system_ext_lifo{}; Lifo<NPadGenericState, hid_entry_count> system_ext_lifo{};
Lifo<SixAxisSensorState, hid_entry_count> sixaxis_fullkey_lifo{}; Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_fullkey_lifo{};
Lifo<SixAxisSensorState, hid_entry_count> sixaxis_handheld_lifo{}; Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_handheld_lifo{};
Lifo<SixAxisSensorState, hid_entry_count> sixaxis_dual_left_lifo{}; Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_dual_left_lifo{};
Lifo<SixAxisSensorState, hid_entry_count> sixaxis_dual_right_lifo{}; Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_dual_right_lifo{};
Lifo<SixAxisSensorState, hid_entry_count> sixaxis_left_lifo{}; Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_left_lifo{};
Lifo<SixAxisSensorState, hid_entry_count> sixaxis_right_lifo{}; Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_right_lifo{};
DeviceType device_type{}; DeviceType device_type{};
INSERT_PADDING_BYTES(0x4); // Reserved INSERT_PADDING_BYTES(0x4); // Reserved
NPadSystemProperties system_properties{}; NPadSystemProperties system_properties{};
@ -483,16 +435,6 @@ private:
std::chrono::steady_clock::time_point last_vibration_timepoint{}; std::chrono::steady_clock::time_point last_vibration_timepoint{};
}; };
struct SixaxisParameters {
bool is_fusion_enabled{true};
bool unaltered_passtrough{false};
Core::HID::SixAxisSensorFusionParameters fusion{};
Core::HID::SixAxisSensorCalibrationParameter calibration{};
Core::HID::SixAxisSensorIcInformation ic_information{};
Core::HID::GyroscopeZeroDriftMode gyroscope_zero_drift_mode{
Core::HID::GyroscopeZeroDriftMode::Standard};
};
struct NpadControllerData { struct NpadControllerData {
Kernel::KEvent* styleset_changed_event{}; Kernel::KEvent* styleset_changed_event{};
NpadInternalState* shared_memory = nullptr; NpadInternalState* shared_memory = nullptr;
@ -506,27 +448,10 @@ private:
bool is_dual_left_connected{true}; bool is_dual_left_connected{true};
bool is_dual_right_connected{true}; bool is_dual_right_connected{true};
// Motion parameters
bool sixaxis_at_rest{true};
bool sixaxis_sensor_enabled{true};
SixaxisParameters sixaxis_fullkey{};
SixaxisParameters sixaxis_handheld{};
SixaxisParameters sixaxis_dual_left{};
SixaxisParameters sixaxis_dual_right{};
SixaxisParameters sixaxis_left{};
SixaxisParameters sixaxis_right{};
SixaxisParameters sixaxis_unknown{};
// Current pad state // Current pad state
NPadGenericState npad_pad_state{}; NPadGenericState npad_pad_state{};
NPadGenericState npad_libnx_state{}; NPadGenericState npad_libnx_state{};
NpadGcTriggerState npad_trigger_state{}; NpadGcTriggerState npad_trigger_state{};
SixAxisSensorState sixaxis_fullkey_state{};
SixAxisSensorState sixaxis_handheld_state{};
SixAxisSensorState sixaxis_dual_left_state{};
SixAxisSensorState sixaxis_dual_right_state{};
SixAxisSensorState sixaxis_left_lifo_state{};
SixAxisSensorState sixaxis_right_lifo_state{};
int callback_key{}; int callback_key{};
}; };
@ -536,14 +461,14 @@ private:
void RequestPadStateUpdate(Core::HID::NpadIdType npad_id); void RequestPadStateUpdate(Core::HID::NpadIdType npad_id);
void WriteEmptyEntry(NpadInternalState* npad); void WriteEmptyEntry(NpadInternalState* npad);
NpadControllerData& GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle);
const NpadControllerData& GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) const;
NpadControllerData& GetControllerFromHandle( NpadControllerData& GetControllerFromHandle(
const Core::HID::VibrationDeviceHandle& device_handle); const Core::HID::VibrationDeviceHandle& device_handle);
const NpadControllerData& GetControllerFromHandle( const NpadControllerData& GetControllerFromHandle(
const Core::HID::VibrationDeviceHandle& device_handle) const; const Core::HID::VibrationDeviceHandle& device_handle) const;
NpadControllerData& GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle);
const NpadControllerData& GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) const;
NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id); NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id);
const NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) const; const NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) const;
@ -551,9 +476,6 @@ private:
const Core::HID::SixAxisSensorHandle& device_handle); const Core::HID::SixAxisSensorHandle& device_handle);
const Core::HID::SixAxisSensorProperties& GetSixaxisProperties( const Core::HID::SixAxisSensorProperties& GetSixaxisProperties(
const Core::HID::SixAxisSensorHandle& device_handle) const; const Core::HID::SixAxisSensorHandle& device_handle) const;
SixaxisParameters& GetSixaxisState(const Core::HID::SixAxisSensorHandle& device_handle);
const SixaxisParameters& GetSixaxisState(
const Core::HID::SixAxisSensorHandle& device_handle) const;
std::atomic<u64> press_state{}; std::atomic<u64> press_state{};

74
src/core/hle/service/hid/controllers/palma.cpp
View File

@ -12,35 +12,35 @@
namespace Service::HID { namespace Service::HID {
Controller_Palma::Controller_Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_, Palma::Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
KernelHelpers::ServiceContext& service_context_) KernelHelpers::ServiceContext& service_context_)
: ControllerBase{hid_core_}, service_context{service_context_} { : ControllerBase{hid_core_}, service_context{service_context_} {
controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other); controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other);
operation_complete_event = service_context.CreateEvent("hid:PalmaOperationCompleteEvent"); operation_complete_event = service_context.CreateEvent("hid:PalmaOperationCompleteEvent");
} }
Controller_Palma::~Controller_Palma() { Palma::~Palma() {
service_context.CloseEvent(operation_complete_event); service_context.CloseEvent(operation_complete_event);
}; };
void Controller_Palma::OnInit() {} void Palma::OnInit() {}
void Controller_Palma::OnRelease() {} void Palma::OnRelease() {}
void Controller_Palma::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void Palma::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
return; return;
} }
} }
Result Controller_Palma::GetPalmaConnectionHandle(Core::HID::NpadIdType npad_id, Result Palma::GetPalmaConnectionHandle(Core::HID::NpadIdType npad_id,
PalmaConnectionHandle& handle) { PalmaConnectionHandle& handle) {
active_handle.npad_id = npad_id; active_handle.npad_id = npad_id;
handle = active_handle; handle = active_handle;
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::InitializePalma(const PalmaConnectionHandle& handle) { Result Palma::InitializePalma(const PalmaConnectionHandle& handle) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -48,7 +48,7 @@ Result Controller_Palma::InitializePalma(const PalmaConnectionHandle& handle) {
return ResultSuccess; return ResultSuccess;
} }
Kernel::KReadableEvent& Controller_Palma::AcquirePalmaOperationCompleteEvent( Kernel::KReadableEvent& Palma::AcquirePalmaOperationCompleteEvent(
const PalmaConnectionHandle& handle) const { const PalmaConnectionHandle& handle) const {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
LOG_ERROR(Service_HID, "Invalid npad id {}", handle.npad_id); LOG_ERROR(Service_HID, "Invalid npad id {}", handle.npad_id);
@ -56,7 +56,7 @@ Kernel::KReadableEvent& Controller_Palma::AcquirePalmaOperationCompleteEvent(
return operation_complete_event->GetReadableEvent(); return operation_complete_event->GetReadableEvent();
} }
Result Controller_Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& handle, Result Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
PalmaOperationType& operation_type, PalmaOperationType& operation_type,
PalmaOperationData& data) const { PalmaOperationData& data) const {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
@ -67,8 +67,7 @@ Result Controller_Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& hand
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle, Result Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_activity) {
u64 palma_activity) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -79,8 +78,7 @@ Result Controller_Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle,
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::SetPalmaFrModeType(const PalmaConnectionHandle& handle, Result Palma::SetPalmaFrModeType(const PalmaConnectionHandle& handle, PalmaFrModeType fr_mode_) {
PalmaFrModeType fr_mode_) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -88,7 +86,7 @@ Result Controller_Palma::SetPalmaFrModeType(const PalmaConnectionHandle& handle,
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) { Result Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -99,25 +97,25 @@ Result Controller_Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::EnablePalmaStep(const PalmaConnectionHandle& handle, bool is_enabled) { Result Palma::EnablePalmaStep(const PalmaConnectionHandle& handle, bool is_enabled) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::ResetPalmaStep(const PalmaConnectionHandle& handle) { Result Palma::ResetPalmaStep(const PalmaConnectionHandle& handle) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
return ResultSuccess; return ResultSuccess;
} }
void Controller_Palma::ReadPalmaApplicationSection() {} void Palma::ReadPalmaApplicationSection() {}
void Controller_Palma::WritePalmaApplicationSection() {} void Palma::WritePalmaApplicationSection() {}
Result Controller_Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) { Result Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -128,7 +126,7 @@ Result Controller_Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) { Result Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -139,10 +137,9 @@ Result Controller_Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle&
return ResultSuccess; return ResultSuccess;
} }
void Controller_Palma::WritePalmaActivityEntry() {} void Palma::WritePalmaActivityEntry() {}
Result Controller_Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle, Result Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle, u64 unknown) {
u64 unknown) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -153,7 +150,7 @@ Result Controller_Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandl
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWaveSet wave, Result Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWaveSet wave,
Common::ProcessAddress t_mem, u64 size) { Common::ProcessAddress t_mem, u64 size) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
@ -165,7 +162,7 @@ Result Controller_Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle, Result Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle,
s32 database_id_version_) { s32 database_id_version_) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
@ -178,8 +175,7 @@ Result Controller_Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnec
return ResultSuccess; return ResultSuccess;
} }
Result Controller_Palma::GetPalmaDataBaseIdentificationVersion( Result Palma::GetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle) {
const PalmaConnectionHandle& handle) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -191,26 +187,26 @@ Result Controller_Palma::GetPalmaDataBaseIdentificationVersion(
return ResultSuccess; return ResultSuccess;
} }
void Controller_Palma::SuspendPalmaFeature() {} void Palma::SuspendPalmaFeature() {}
Result Controller_Palma::GetPalmaOperationResult(const PalmaConnectionHandle& handle) const { Result Palma::GetPalmaOperationResult(const PalmaConnectionHandle& handle) const {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
return operation.result; return operation.result;
} }
void Controller_Palma::ReadPalmaPlayLog() {} void Palma::ReadPalmaPlayLog() {}
void Controller_Palma::ResetPalmaPlayLog() {} void Palma::ResetPalmaPlayLog() {}
void Controller_Palma::SetIsPalmaAllConnectable(bool is_all_connectable) { void Palma::SetIsPalmaAllConnectable(bool is_all_connectable) {
// If true controllers are able to be paired // If true controllers are able to be paired
is_connectable = is_all_connectable; is_connectable = is_all_connectable;
} }
void Controller_Palma::SetIsPalmaPairedConnectable() {} void Palma::SetIsPalmaPairedConnectable() {}
Result Controller_Palma::PairPalma(const PalmaConnectionHandle& handle) { Result Palma::PairPalma(const PalmaConnectionHandle& handle) {
if (handle.npad_id != active_handle.npad_id) { if (handle.npad_id != active_handle.npad_id) {
return InvalidPalmaHandle; return InvalidPalmaHandle;
} }
@ -218,14 +214,14 @@ Result Controller_Palma::PairPalma(const PalmaConnectionHandle& handle) {
return ResultSuccess; return ResultSuccess;
} }
void Controller_Palma::SetPalmaBoostMode(bool boost_mode) {} void Palma::SetPalmaBoostMode(bool boost_mode) {}
void Controller_Palma::CancelWritePalmaWaveEntry() {} void Palma::CancelWritePalmaWaveEntry() {}
void Controller_Palma::EnablePalmaBoostMode() {} void Palma::EnablePalmaBoostMode() {}
void Controller_Palma::GetPalmaBluetoothAddress() {} void Palma::GetPalmaBluetoothAddress() {}
void Controller_Palma::SetDisallowedPalmaConnection() {} void Palma::SetDisallowedPalmaConnection() {}
} // namespace Service::HID } // namespace Service::HID

6
src/core/hle/service/hid/controllers/palma.h
View File

@ -23,7 +23,7 @@ class EmulatedController;
} // namespace Core::HID } // namespace Core::HID
namespace Service::HID { namespace Service::HID {
class Controller_Palma final : public ControllerBase { class Palma final : public ControllerBase {
public: public:
using PalmaOperationData = std::array<u8, 0x140>; using PalmaOperationData = std::array<u8, 0x140>;
@ -97,9 +97,9 @@ public:
static_assert(sizeof(PalmaConnectionHandle) == 0x8, static_assert(sizeof(PalmaConnectionHandle) == 0x8,
"PalmaConnectionHandle has incorrect size."); "PalmaConnectionHandle has incorrect size.");
explicit Controller_Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_, explicit Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
KernelHelpers::ServiceContext& service_context_); KernelHelpers::ServiceContext& service_context_);
~Controller_Palma() override; ~Palma() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;

38
src/core/hle/service/hid/controllers/console_sixaxis.cpp → src/core/hle/service/hid/controllers/seven_six_axis.cpp
View File

@ -1,32 +1,29 @@
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later
#include <cstring>
#include "common/common_types.h"
#include "core/core.h" #include "core/core.h"
#include "core/core_timing.h" #include "core/core_timing.h"
#include "core/frontend/emu_window.h"
#include "core/hid/emulated_console.h" #include "core/hid/emulated_console.h"
#include "core/hid/emulated_devices.h"
#include "core/hid/hid_core.h" #include "core/hid/hid_core.h"
#include "core/hle/service/hid/controllers/console_sixaxis.h" #include "core/hle/service/hid/controllers/seven_six_axis.h"
#include "core/memory.h" #include "core/memory.h"
namespace Service::HID { namespace Service::HID {
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C200; SevenSixAxis::SevenSixAxis(Core::System& system_)
Controller_ConsoleSixAxis::Controller_ConsoleSixAxis(Core::System& system_, u8* raw_shared_memory_)
: ControllerBase{system_.HIDCore()}, system{system_} { : ControllerBase{system_.HIDCore()}, system{system_} {
console = hid_core.GetEmulatedConsole(); console = hid_core.GetEmulatedConsole();
static_assert(SHARED_MEMORY_OFFSET + sizeof(ConsoleSharedMemory) < shared_memory_size,
"ConsoleSharedMemory is bigger than the shared memory");
shared_memory = std::construct_at(
reinterpret_cast<ConsoleSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
} }
Controller_ConsoleSixAxis::~Controller_ConsoleSixAxis() = default; SevenSixAxis::~SevenSixAxis() = default;
void Controller_ConsoleSixAxis::OnInit() {} void SevenSixAxis::OnInit() {}
void SevenSixAxis::OnRelease() {}
void Controller_ConsoleSixAxis::OnRelease() {} void SevenSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
void Controller_ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated() || transfer_memory == 0) { if (!IsControllerActivated() || transfer_memory == 0) {
seven_sixaxis_lifo.buffer_count = 0; seven_sixaxis_lifo.buffer_count = 0;
seven_sixaxis_lifo.buffer_tail = 0; seven_sixaxis_lifo.buffer_tail = 0;
@ -53,22 +50,17 @@ void Controller_ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_ti
-motion_status.quaternion.xyz.z, -motion_status.quaternion.xyz.z,
}; };
shared_memory->sampling_number++;
shared_memory->is_seven_six_axis_sensor_at_rest = motion_status.is_at_rest;
shared_memory->verticalization_error = motion_status.verticalization_error;
shared_memory->gyro_bias = motion_status.gyro_bias;
// Update seven six axis transfer memory
seven_sixaxis_lifo.WriteNextEntry(next_seven_sixaxis_state); seven_sixaxis_lifo.WriteNextEntry(next_seven_sixaxis_state);
system.ApplicationMemory().WriteBlock(transfer_memory, &seven_sixaxis_lifo, system.ApplicationMemory().WriteBlock(transfer_memory, &seven_sixaxis_lifo,
sizeof(seven_sixaxis_lifo)); sizeof(seven_sixaxis_lifo));
} }
void Controller_ConsoleSixAxis::SetTransferMemoryAddress(Common::ProcessAddress t_mem) { void SevenSixAxis::SetTransferMemoryAddress(Common::ProcessAddress t_mem) {
transfer_memory = t_mem; transfer_memory = t_mem;
} }
void Controller_ConsoleSixAxis::ResetTimestamp() { void SevenSixAxis::ResetTimestamp() {
last_saved_timestamp = last_global_timestamp; last_saved_timestamp = last_global_timestamp;
} }
} // namespace Service::HID } // namespace Service::HID

33
src/core/hle/service/hid/controllers/console_sixaxis.h → src/core/hle/service/hid/controllers/seven_six_axis.h
View File

@ -1,10 +1,9 @@
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later
#pragma once #pragma once
#include <array> #include "common/common_types.h"
#include "common/quaternion.h" #include "common/quaternion.h"
#include "common/typed_address.h" #include "common/typed_address.h"
#include "core/hle/service/hid/controllers/controller_base.h" #include "core/hle/service/hid/controllers/controller_base.h"
@ -19,10 +18,10 @@ class EmulatedConsole;
} // namespace Core::HID } // namespace Core::HID
namespace Service::HID { namespace Service::HID {
class Controller_ConsoleSixAxis final : public ControllerBase { class SevenSixAxis final : public ControllerBase {
public: public:
explicit Controller_ConsoleSixAxis(Core::System& system_, u8* raw_shared_memory_); explicit SevenSixAxis(Core::System& system_);
~Controller_ConsoleSixAxis() override; ~SevenSixAxis() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;
@ -51,28 +50,16 @@ private:
}; };
static_assert(sizeof(SevenSixAxisState) == 0x48, "SevenSixAxisState is an invalid size"); static_assert(sizeof(SevenSixAxisState) == 0x48, "SevenSixAxisState is an invalid size");
// This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat
struct ConsoleSharedMemory {
u64 sampling_number{};
bool is_seven_six_axis_sensor_at_rest{};
INSERT_PADDING_BYTES(3); // padding
f32 verticalization_error{};
Common::Vec3f gyro_bias{};
INSERT_PADDING_BYTES(4); // padding
};
static_assert(sizeof(ConsoleSharedMemory) == 0x20, "ConsoleSharedMemory is an invalid size");
Lifo<SevenSixAxisState, 0x21> seven_sixaxis_lifo{}; Lifo<SevenSixAxisState, 0x21> seven_sixaxis_lifo{};
static_assert(sizeof(seven_sixaxis_lifo) == 0xA70, "SevenSixAxisState is an invalid size"); static_assert(sizeof(seven_sixaxis_lifo) == 0xA70, "SevenSixAxisState is an invalid size");
SevenSixAxisState next_seven_sixaxis_state{};
Common::ProcessAddress transfer_memory{};
ConsoleSharedMemory* shared_memory = nullptr;
Core::HID::EmulatedConsole* console = nullptr;
u64 last_saved_timestamp{}; u64 last_saved_timestamp{};
u64 last_global_timestamp{}; u64 last_global_timestamp{};
SevenSixAxisState next_seven_sixaxis_state{};
Common::ProcessAddress transfer_memory{};
Core::HID::EmulatedConsole* console = nullptr;
Core::System& system; Core::System& system;
}; };
} // namespace Service::HID } // namespace Service::HID

413
src/core/hle/service/hid/controllers/six_axis.cpp Normal file
View File

@ -0,0 +1,413 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include "common/common_types.h"
#include "core/core_timing.h"
#include "core/hid/emulated_controller.h"
#include "core/hid/hid_core.h"
#include "core/hle/service/hid/controllers/npad.h"
#include "core/hle/service/hid/controllers/six_axis.h"
#include "core/hle/service/hid/errors.h"
#include "core/hle/service/hid/hid_util.h"
namespace Service::HID {
SixAxis::SixAxis(Core::HID::HIDCore& hid_core_, std::shared_ptr<NPad> npad_)
: ControllerBase{hid_core_}, npad{npad_} {
for (std::size_t i = 0; i < controller_data.size(); ++i) {
auto& controller = controller_data[i];
controller.device = hid_core.GetEmulatedControllerByIndex(i);
}
}
SixAxis::~SixAxis() = default;
void SixAxis::OnInit() {}
void SixAxis::OnRelease() {}
void SixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) {
return;
}
for (std::size_t i = 0; i < controller_data.size(); ++i) {
auto& controller = controller_data[i];
const auto npad_id = IndexToNpadIdType(i);
const auto& controller_type = controller.device->GetNpadStyleIndex();
if (controller_type == Core::HID::NpadStyleIndex::None ||
!controller.device->IsConnected()) {
continue;
}
const auto& motion_state = controller.device->GetMotions();
auto& sixaxis_fullkey_state = controller.sixaxis_fullkey_state;
auto& sixaxis_handheld_state = controller.sixaxis_handheld_state;
auto& sixaxis_dual_left_state = controller.sixaxis_dual_left_state;
auto& sixaxis_dual_right_state = controller.sixaxis_dual_right_state;
auto& sixaxis_left_lifo_state = controller.sixaxis_left_lifo_state;
auto& sixaxis_right_lifo_state = controller.sixaxis_right_lifo_state;
auto& sixaxis_fullkey_lifo = npad->GetSixAxisFullkeyLifo(npad_id);
auto& sixaxis_handheld_lifo = npad->GetSixAxisHandheldLifo(npad_id);
auto& sixaxis_dual_left_lifo = npad->GetSixAxisDualLeftLifo(npad_id);
auto& sixaxis_dual_right_lifo = npad->GetSixAxisDualRightLifo(npad_id);
auto& sixaxis_left_lifo = npad->GetSixAxisLeftLifo(npad_id);
auto& sixaxis_right_lifo = npad->GetSixAxisRightLifo(npad_id);
// Clear previous state
sixaxis_fullkey_state = {};
sixaxis_handheld_state = {};
sixaxis_dual_left_state = {};
sixaxis_dual_right_state = {};
sixaxis_left_lifo_state = {};
sixaxis_right_lifo_state = {};
if (controller.sixaxis_sensor_enabled && Settings::values.motion_enabled.GetValue()) {
controller.sixaxis_at_rest = true;
for (std::size_t e = 0; e < motion_state.size(); ++e) {
controller.sixaxis_at_rest =
controller.sixaxis_at_rest && motion_state[e].is_at_rest;
}
}
const auto set_motion_state = [&](Core::HID::SixAxisSensorState& state,
const Core::HID::ControllerMotion& hid_state) {
using namespace std::literals::chrono_literals;
static constexpr Core::HID::SixAxisSensorState default_motion_state = {
.delta_time = std::chrono::nanoseconds(5ms).count(),
.accel = {0, 0, -1.0f},
.orientation =
{
Common::Vec3f{1.0f, 0, 0},
Common::Vec3f{0, 1.0f, 0},
Common::Vec3f{0, 0, 1.0f},
},
.attribute = {1},
};
if (!controller.sixaxis_sensor_enabled) {
state = default_motion_state;
return;
}
if (!Settings::values.motion_enabled.GetValue()) {
state = default_motion_state;
return;
}
state.attribute.is_connected.Assign(1);
state.delta_time = std::chrono::nanoseconds(5ms).count();
state.accel = hid_state.accel;
state.gyro = hid_state.gyro;
state.rotation = hid_state.rotation;
state.orientation = hid_state.orientation;
};
switch (controller_type) {
case Core::HID::NpadStyleIndex::None:
ASSERT(false);
break;
case Core::HID::NpadStyleIndex::ProController:
set_motion_state(sixaxis_fullkey_state, motion_state[0]);
break;
case Core::HID::NpadStyleIndex::Handheld:
set_motion_state(sixaxis_handheld_state, motion_state[0]);
break;
case Core::HID::NpadStyleIndex::JoyconDual:
set_motion_state(sixaxis_dual_left_state, motion_state[0]);
set_motion_state(sixaxis_dual_right_state, motion_state[1]);
break;
case Core::HID::NpadStyleIndex::JoyconLeft:
set_motion_state(sixaxis_left_lifo_state, motion_state[0]);
break;
case Core::HID::NpadStyleIndex::JoyconRight:
set_motion_state(sixaxis_right_lifo_state, motion_state[1]);
break;
case Core::HID::NpadStyleIndex::Pokeball:
using namespace std::literals::chrono_literals;
set_motion_state(sixaxis_fullkey_state, motion_state[0]);
sixaxis_fullkey_state.delta_time = std::chrono::nanoseconds(15ms).count();
break;
default:
break;
}
sixaxis_fullkey_state.sampling_number =
sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_handheld_state.sampling_number =
sixaxis_handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_dual_left_state.sampling_number =
sixaxis_dual_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_dual_right_state.sampling_number =
sixaxis_dual_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_left_lifo_state.sampling_number =
sixaxis_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
sixaxis_right_lifo_state.sampling_number =
sixaxis_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
if (IndexToNpadIdType(i) == Core::HID::NpadIdType::Handheld) {
// This buffer only is updated on handheld on HW
sixaxis_handheld_lifo.WriteNextEntry(sixaxis_handheld_state);
} else {
// Handheld doesn't update this buffer on HW
sixaxis_fullkey_lifo.WriteNextEntry(sixaxis_fullkey_state);
}
sixaxis_dual_left_lifo.WriteNextEntry(sixaxis_dual_left_state);
sixaxis_dual_right_lifo.WriteNextEntry(sixaxis_dual_right_state);
sixaxis_left_lifo.WriteNextEntry(sixaxis_left_lifo_state);
sixaxis_right_lifo.WriteNextEntry(sixaxis_right_lifo_state);
}
}
Result SixAxis::SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode drift_mode) {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
auto& sixaxis = GetSixaxisState(sixaxis_handle);
auto& controller = GetControllerFromHandle(sixaxis_handle);
sixaxis.gyroscope_zero_drift_mode = drift_mode;
controller.device->SetGyroscopeZeroDriftMode(drift_mode);
return ResultSuccess;
}
Result SixAxis::GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode& drift_mode) const {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
drift_mode = sixaxis.gyroscope_zero_drift_mode;
return ResultSuccess;
}
Result SixAxis::IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool& is_at_rest) const {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& controller = GetControllerFromHandle(sixaxis_handle);
is_at_rest = controller.sixaxis_at_rest;
return ResultSuccess;
}
Result SixAxis::LoadSixAxisSensorCalibrationParameter(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorCalibrationParameter& calibration) const {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
// TODO: Request this data to the controller. On error return 0xd8ca
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
calibration = sixaxis.calibration;
return ResultSuccess;
}
Result SixAxis::GetSixAxisSensorIcInformation(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorIcInformation& ic_information) const {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
// TODO: Request this data to the controller. On error return 0xd8ca
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
ic_information = sixaxis.ic_information;
return ResultSuccess;
}
Result SixAxis::EnableSixAxisSensorUnalteredPassthrough(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled) {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
auto& sixaxis = GetSixaxisState(sixaxis_handle);
sixaxis.unaltered_passtrough = is_enabled;
return ResultSuccess;
}
Result SixAxis::IsSixAxisSensorUnalteredPassthroughEnabled(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
is_enabled = sixaxis.unaltered_passtrough;
return ResultSuccess;
}
Result SixAxis::SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool sixaxis_status) {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
auto& controller = GetControllerFromHandle(sixaxis_handle);
controller.sixaxis_sensor_enabled = sixaxis_status;
return ResultSuccess;
}
Result SixAxis::IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool& is_fusion_enabled) const {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
is_fusion_enabled = sixaxis.is_fusion_enabled;
return ResultSuccess;
}
Result SixAxis::SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool is_fusion_enabled) {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
auto& sixaxis = GetSixaxisState(sixaxis_handle);
sixaxis.is_fusion_enabled = is_fusion_enabled;
return ResultSuccess;
}
Result SixAxis::SetSixAxisFusionParameters(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters) {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto param1 = sixaxis_fusion_parameters.parameter1;
if (param1 < 0.0f || param1 > 1.0f) {
return InvalidSixAxisFusionRange;
}
auto& sixaxis = GetSixaxisState(sixaxis_handle);
sixaxis.fusion = sixaxis_fusion_parameters;
return ResultSuccess;
}
Result SixAxis::GetSixAxisFusionParameters(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorFusionParameters& parameters) const {
const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
if (is_valid.IsError()) {
LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
return is_valid;
}
const auto& sixaxis = GetSixaxisState(sixaxis_handle);
parameters = sixaxis.fusion;
return ResultSuccess;
}
SixAxis::SixaxisParameters& SixAxis::GetSixaxisState(
const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
auto& controller = GetControllerFromHandle(sixaxis_handle);
switch (sixaxis_handle.npad_type) {
case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadStyleIndex::Pokeball:
return controller.sixaxis_fullkey;
case Core::HID::NpadStyleIndex::Handheld:
return controller.sixaxis_handheld;
case Core::HID::NpadStyleIndex::JoyconDual:
if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
return controller.sixaxis_dual_left;
}
return controller.sixaxis_dual_right;
case Core::HID::NpadStyleIndex::JoyconLeft:
return controller.sixaxis_left;
case Core::HID::NpadStyleIndex::JoyconRight:
return controller.sixaxis_right;
default:
return controller.sixaxis_unknown;
}
}
const SixAxis::SixaxisParameters& SixAxis::GetSixaxisState(
const Core::HID::SixAxisSensorHandle& sixaxis_handle) const {
const auto& controller = GetControllerFromHandle(sixaxis_handle);
switch (sixaxis_handle.npad_type) {
case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadStyleIndex::Pokeball:
return controller.sixaxis_fullkey;
case Core::HID::NpadStyleIndex::Handheld:
return controller.sixaxis_handheld;
case Core::HID::NpadStyleIndex::JoyconDual:
if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
return controller.sixaxis_dual_left;
}
return controller.sixaxis_dual_right;
case Core::HID::NpadStyleIndex::JoyconLeft:
return controller.sixaxis_left;
case Core::HID::NpadStyleIndex::JoyconRight:
return controller.sixaxis_right;
default:
return controller.sixaxis_unknown;
}
}
SixAxis::NpadControllerData& SixAxis::GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id);
}
const SixAxis::NpadControllerData& SixAxis::GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) const {
const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
return GetControllerFromNpadIdType(npad_id);
}
SixAxis::NpadControllerData& SixAxis::GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) {
if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
npad_id = Core::HID::NpadIdType::Player1;
}
const auto npad_index = NpadIdTypeToIndex(npad_id);
return controller_data[npad_index];
}
const SixAxis::NpadControllerData& SixAxis::GetControllerFromNpadIdType(
Core::HID::NpadIdType npad_id) const {
if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
npad_id = Core::HID::NpadIdType::Player1;
}
const auto npad_index = NpadIdTypeToIndex(npad_id);
return controller_data[npad_index];
}
} // namespace Service::HID

111
src/core/hle/service/hid/controllers/six_axis.h Normal file
View File

@ -0,0 +1,111 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "common/common_types.h"
#include "core/hid/hid_types.h"
#include "core/hle/service/hid/controllers/controller_base.h"
#include "core/hle/service/hid/ring_lifo.h"
namespace Core::HID {
class EmulatedController;
} // namespace Core::HID
namespace Service::HID {
class NPad;
class SixAxis final : public ControllerBase {
public:
explicit SixAxis(Core::HID::HIDCore& hid_core_, std::shared_ptr<NPad> npad_);
~SixAxis() override;
// Called when the controller is initialized
void OnInit() override;
// When the controller is released
void OnRelease() override;
// When the controller is requesting an update for the shared memory
void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
Result SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode drift_mode);
Result GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode& drift_mode) const;
Result IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool& is_at_rest) const;
Result EnableSixAxisSensorUnalteredPassthrough(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled);
Result IsSixAxisSensorUnalteredPassthroughEnabled(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const;
Result LoadSixAxisSensorCalibrationParameter(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorCalibrationParameter& calibration) const;
Result GetSixAxisSensorIcInformation(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorIcInformation& ic_information) const;
Result SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool sixaxis_status);
Result IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool& is_fusion_enabled) const;
Result SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
bool is_fusion_enabled);
Result SetSixAxisFusionParameters(
const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters);
Result GetSixAxisFusionParameters(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::SixAxisSensorFusionParameters& parameters) const;
private:
static constexpr std::size_t NPAD_COUNT = 10;
struct SixaxisParameters {
bool is_fusion_enabled{true};
bool unaltered_passtrough{false};
Core::HID::SixAxisSensorFusionParameters fusion{};
Core::HID::SixAxisSensorCalibrationParameter calibration{};
Core::HID::SixAxisSensorIcInformation ic_information{};
Core::HID::GyroscopeZeroDriftMode gyroscope_zero_drift_mode{
Core::HID::GyroscopeZeroDriftMode::Standard};
};
struct NpadControllerData {
Core::HID::EmulatedController* device = nullptr;
// Motion parameters
bool sixaxis_at_rest{true};
bool sixaxis_sensor_enabled{true};
SixaxisParameters sixaxis_fullkey{};
SixaxisParameters sixaxis_handheld{};
SixaxisParameters sixaxis_dual_left{};
SixaxisParameters sixaxis_dual_right{};
SixaxisParameters sixaxis_left{};
SixaxisParameters sixaxis_right{};
SixaxisParameters sixaxis_unknown{};
// Current pad state
Core::HID::SixAxisSensorState sixaxis_fullkey_state{};
Core::HID::SixAxisSensorState sixaxis_handheld_state{};
Core::HID::SixAxisSensorState sixaxis_dual_left_state{};
Core::HID::SixAxisSensorState sixaxis_dual_right_state{};
Core::HID::SixAxisSensorState sixaxis_left_lifo_state{};
Core::HID::SixAxisSensorState sixaxis_right_lifo_state{};
int callback_key{};
};
SixaxisParameters& GetSixaxisState(const Core::HID::SixAxisSensorHandle& device_handle);
const SixaxisParameters& GetSixaxisState(
const Core::HID::SixAxisSensorHandle& device_handle) const;
NpadControllerData& GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle);
const NpadControllerData& GetControllerFromHandle(
const Core::HID::SixAxisSensorHandle& device_handle) const;
NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id);
const NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) const;
std::shared_ptr<NPad> npad;
std::array<NpadControllerData, NPAD_COUNT> controller_data{};
};
} // namespace Service::HID

11
src/core/hle/service/hid/controllers/touchscreen.cpp
View File

@ -15,8 +15,7 @@
namespace Service::HID { namespace Service::HID {
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400; constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
Controller_Touchscreen::Controller_Touchscreen(Core::HID::HIDCore& hid_core_, TouchScreen::TouchScreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
u8* raw_shared_memory_)
: ControllerBase{hid_core_} { : ControllerBase{hid_core_} {
static_assert(SHARED_MEMORY_OFFSET + sizeof(TouchSharedMemory) < shared_memory_size, static_assert(SHARED_MEMORY_OFFSET + sizeof(TouchSharedMemory) < shared_memory_size,
"TouchSharedMemory is bigger than the shared memory"); "TouchSharedMemory is bigger than the shared memory");
@ -25,13 +24,13 @@ Controller_Touchscreen::Controller_Touchscreen(Core::HID::HIDCore& hid_core_,
console = hid_core.GetEmulatedConsole(); console = hid_core.GetEmulatedConsole();
} }
Controller_Touchscreen::~Controller_Touchscreen() = default; TouchScreen::~TouchScreen() = default;
void Controller_Touchscreen::OnInit() {} void TouchScreen::OnInit() {}
void Controller_Touchscreen::OnRelease() {} void TouchScreen::OnRelease() {}
void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void TouchScreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
shared_memory->touch_screen_lifo.timestamp = core_timing.GetGlobalTimeNs().count(); shared_memory->touch_screen_lifo.timestamp = core_timing.GetGlobalTimeNs().count();
if (!IsControllerActivated()) { if (!IsControllerActivated()) {

6
src/core/hle/service/hid/controllers/touchscreen.h
View File

@ -14,10 +14,10 @@ class EmulatedConsole;
} // namespace Core::HID } // namespace Core::HID
namespace Service::HID { namespace Service::HID {
class Controller_Touchscreen final : public ControllerBase { class TouchScreen final : public ControllerBase {
public: public:
explicit Controller_Touchscreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); explicit TouchScreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
~Controller_Touchscreen() override; ~TouchScreen() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;

11
src/core/hle/service/hid/controllers/xpad.cpp
View File

@ -10,20 +10,19 @@
namespace Service::HID { namespace Service::HID {
constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00; constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00;
Controller_XPad::Controller_XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) XPad::XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) : ControllerBase{hid_core_} {
: ControllerBase{hid_core_} {
static_assert(SHARED_MEMORY_OFFSET + sizeof(XpadSharedMemory) < shared_memory_size, static_assert(SHARED_MEMORY_OFFSET + sizeof(XpadSharedMemory) < shared_memory_size,
"XpadSharedMemory is bigger than the shared memory"); "XpadSharedMemory is bigger than the shared memory");
shared_memory = std::construct_at( shared_memory = std::construct_at(
reinterpret_cast<XpadSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); reinterpret_cast<XpadSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
} }
Controller_XPad::~Controller_XPad() = default; XPad::~XPad() = default;
void Controller_XPad::OnInit() {} void XPad::OnInit() {}
void Controller_XPad::OnRelease() {} void XPad::OnRelease() {}
void Controller_XPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) { void XPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
if (!IsControllerActivated()) { if (!IsControllerActivated()) {
shared_memory->basic_xpad_lifo.buffer_count = 0; shared_memory->basic_xpad_lifo.buffer_count = 0;
shared_memory->basic_xpad_lifo.buffer_tail = 0; shared_memory->basic_xpad_lifo.buffer_tail = 0;

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

@ -10,10 +10,10 @@
#include "core/hle/service/hid/ring_lifo.h" #include "core/hle/service/hid/ring_lifo.h"
namespace Service::HID { namespace Service::HID {
class Controller_XPad final : public ControllerBase { class XPad final : public ControllerBase {
public: public:
explicit Controller_XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); explicit XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
~Controller_XPad() override; ~XPad() override;
// Called when the controller is initialized // Called when the controller is initialized
void OnInit() override; void OnInit() override;

433
src/core/hle/service/hid/hid_server.cpp
View File

File diff suppressed because it is too large Load Diff

24
src/core/hle/service/hid/hid_system_server.cpp
View File

@ -240,9 +240,7 @@ IHidSystemServer::~IHidSystemServer() {
void IHidSystemServer::ApplyNpadSystemCommonPolicy(HLERequestContext& ctx) { void IHidSystemServer::ApplyNpadSystemCommonPolicy(HLERequestContext& ctx) {
LOG_WARNING(Service_HID, "called"); LOG_WARNING(Service_HID, "called");
GetResourceManager() GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy();
->GetController<Controller_NPad>(HidController::NPad)
.ApplyNpadSystemCommonPolicy();
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -273,9 +271,7 @@ void IHidSystemServer::GetLastActiveNpad(HLERequestContext& ctx) {
void IHidSystemServer::ApplyNpadSystemCommonPolicyFull(HLERequestContext& ctx) { void IHidSystemServer::ApplyNpadSystemCommonPolicyFull(HLERequestContext& ctx) {
LOG_WARNING(Service_HID, "called"); LOG_WARNING(Service_HID, "called");
GetResourceManager() GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy();
->GetController<Controller_NPad>(HidController::NPad)
.ApplyNpadSystemCommonPolicy();
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -304,10 +300,7 @@ void IHidSystemServer::GetMaskedSupportedNpadStyleSet(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "(STUBBED) called"); LOG_INFO(Service_HID, "(STUBBED) called");
Core::HID::NpadStyleSet supported_styleset = Core::HID::NpadStyleSet supported_styleset =
GetResourceManager() GetResourceManager()->GetNpad()->GetSupportedStyleSet().raw;
->GetController<Controller_NPad>(HidController::NPad)
.GetSupportedStyleSet()
.raw;
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -320,10 +313,7 @@ void IHidSystemServer::SetSupportedNpadStyleSetAll(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "(STUBBED) called"); LOG_INFO(Service_HID, "(STUBBED) called");
Core::HID::NpadStyleSet supported_styleset = Core::HID::NpadStyleSet supported_styleset =
GetResourceManager() GetResourceManager()->GetNpad()->GetSupportedStyleSet().raw;
->GetController<Controller_NPad>(HidController::NPad)
.GetSupportedStyleSet()
.raw;
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -337,10 +327,8 @@ void IHidSystemServer::GetAppletDetailedUiType(HLERequestContext& ctx) {
LOG_DEBUG(Service_HID, "called, npad_id_type={}", LOG_DEBUG(Service_HID, "called, npad_id_type={}",
npad_id_type); // Spams a lot when controller applet is running npad_id_type); // Spams a lot when controller applet is running
const Service::HID::Controller_NPad::AppletDetailedUiType detailed_ui_type = const NPad::AppletDetailedUiType detailed_ui_type =
GetResourceManager() GetResourceManager()->GetNpad()->GetAppletDetailedUiType(npad_id_type);
->GetController<Controller_NPad>(HidController::NPad)
.GetAppletDetailedUiType(npad_id_type);
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);

146
src/core/hle/service/hid/hid_util.h Normal file
View File

@ -0,0 +1,146 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "core/hid/hid_types.h"
#include "core/hle/service/hid/errors.h"
namespace Service::HID {
constexpr bool IsNpadIdValid(const Core::HID::NpadIdType npad_id) {
switch (npad_id) {
case Core::HID::NpadIdType::Player1:
case Core::HID::NpadIdType::Player2:
case Core::HID::NpadIdType::Player3:
case Core::HID::NpadIdType::Player4:
case Core::HID::NpadIdType::Player5:
case Core::HID::NpadIdType::Player6:
case Core::HID::NpadIdType::Player7:
case Core::HID::NpadIdType::Player8:
case Core::HID::NpadIdType::Other:
case Core::HID::NpadIdType::Handheld:
return true;
default:
return false;
}
}
constexpr Result IsSixaxisHandleValid(const Core::HID::SixAxisSensorHandle& handle) {
const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(handle.npad_id));
const bool device_index = handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex;
if (!npad_id) {
return InvalidNpadId;
}
if (!device_index) {
return NpadDeviceIndexOutOfRange;
}
return ResultSuccess;
}
constexpr Result IsVibrationHandleValid(const Core::HID::VibrationDeviceHandle& handle) {
switch (handle.npad_type) {
case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadStyleIndex::Handheld:
case Core::HID::NpadStyleIndex::JoyconDual:
case Core::HID::NpadStyleIndex::JoyconLeft:
case Core::HID::NpadStyleIndex::JoyconRight:
case Core::HID::NpadStyleIndex::GameCube:
case Core::HID::NpadStyleIndex::N64:
case Core::HID::NpadStyleIndex::SystemExt:
case Core::HID::NpadStyleIndex::System:
// These support vibration
break;
default:
return VibrationInvalidStyleIndex;
}
if (!IsNpadIdValid(static_cast<Core::HID::NpadIdType>(handle.npad_id))) {
return VibrationInvalidNpadId;
}
if (handle.device_index >= Core::HID::DeviceIndex::MaxDeviceIndex) {
return VibrationDeviceIndexOutOfRange;
}
return ResultSuccess;
}
/// Converts a Core::HID::NpadIdType to an array index.
constexpr size_t NpadIdTypeToIndex(Core::HID::NpadIdType npad_id_type) {
switch (npad_id_type) {
case Core::HID::NpadIdType::Player1:
return 0;
case Core::HID::NpadIdType::Player2:
return 1;
case Core::HID::NpadIdType::Player3:
return 2;
case Core::HID::NpadIdType::Player4:
return 3;
case Core::HID::NpadIdType::Player5:
return 4;
case Core::HID::NpadIdType::Player6:
return 5;
case Core::HID::NpadIdType::Player7:
return 6;
case Core::HID::NpadIdType::Player8:
return 7;
case Core::HID::NpadIdType::Handheld:
return 8;
case Core::HID::NpadIdType::Other:
return 9;
default:
return 8;
}
}
/// Converts an array index to a Core::HID::NpadIdType
constexpr Core::HID::NpadIdType IndexToNpadIdType(size_t index) {
switch (index) {
case 0:
return Core::HID::NpadIdType::Player1;
case 1:
return Core::HID::NpadIdType::Player2;
case 2:
return Core::HID::NpadIdType::Player3;
case 3:
return Core::HID::NpadIdType::Player4;
case 4:
return Core::HID::NpadIdType::Player5;
case 5:
return Core::HID::NpadIdType::Player6;
case 6:
return Core::HID::NpadIdType::Player7;
case 7:
return Core::HID::NpadIdType::Player8;
case 8:
return Core::HID::NpadIdType::Handheld;
case 9:
return Core::HID::NpadIdType::Other;
default:
return Core::HID::NpadIdType::Invalid;
}
}
constexpr Core::HID::NpadStyleSet GetStylesetByIndex(std::size_t index) {
switch (index) {
case 0:
return Core::HID::NpadStyleSet::Fullkey;
case 1:
return Core::HID::NpadStyleSet::Handheld;
case 2:
return Core::HID::NpadStyleSet::JoyDual;
case 3:
return Core::HID::NpadStyleSet::JoyLeft;
case 4:
return Core::HID::NpadStyleSet::JoyRight;
case 5:
return Core::HID::NpadStyleSet::Palma;
default:
return Core::HID::NpadStyleSet::None;
}
}
} // namespace Service::HID

5
src/core/hle/service/hid/irs.cpp
View File

@ -12,6 +12,7 @@
#include "core/hle/kernel/k_transfer_memory.h" #include "core/hle/kernel/k_transfer_memory.h"
#include "core/hle/kernel/kernel.h" #include "core/hle/kernel/kernel.h"
#include "core/hle/service/hid/errors.h" #include "core/hle/service/hid/errors.h"
#include "core/hle/service/hid/hid_util.h"
#include "core/hle/service/hid/irs.h" #include "core/hle/service/hid/irs.h"
#include "core/hle/service/hid/irsensor/clustering_processor.h" #include "core/hle/service/hid/irsensor/clustering_processor.h"
#include "core/hle/service/hid/irsensor/image_transfer_processor.h" #include "core/hle/service/hid/irsensor/image_transfer_processor.h"
@ -320,7 +321,7 @@ void IRS::GetNpadIrCameraHandle(HLERequestContext& ctx) {
} }
Core::IrSensor::IrCameraHandle camera_handle{ Core::IrSensor::IrCameraHandle camera_handle{
.npad_id = static_cast<u8>(NpadIdTypeToIndex(npad_id)), .npad_id = static_cast<u8>(HID::NpadIdTypeToIndex(npad_id)),
.npad_type = Core::HID::NpadStyleIndex::None, .npad_type = Core::HID::NpadStyleIndex::None,
}; };
@ -545,7 +546,7 @@ void IRS::ActivateIrsensorWithFunctionLevel(HLERequestContext& ctx) {
Result IRS::IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_handle) const { Result IRS::IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_handle) const {
if (camera_handle.npad_id > if (camera_handle.npad_id >
static_cast<u8>(NpadIdTypeToIndex(Core::HID::NpadIdType::Handheld))) { static_cast<u8>(HID::NpadIdTypeToIndex(Core::HID::NpadIdType::Handheld))) {
return InvalidIrCameraHandle; return InvalidIrCameraHandle;
} }
if (camera_handle.npad_type != Core::HID::NpadStyleIndex::None) { if (camera_handle.npad_type != Core::HID::NpadStyleIndex::None) {

155
src/core/hle/service/hid/resource_manager.cpp
View File

@ -9,14 +9,15 @@
#include "core/hle/service/hid/resource_manager.h" #include "core/hle/service/hid/resource_manager.h"
#include "core/hle/service/ipc_helpers.h" #include "core/hle/service/ipc_helpers.h"
#include "core/hle/service/hid/controllers/console_sixaxis.h" #include "core/hle/service/hid/controllers/console_six_axis.h"
#include "core/hle/service/hid/controllers/controller_base.h"
#include "core/hle/service/hid/controllers/debug_pad.h" #include "core/hle/service/hid/controllers/debug_pad.h"
#include "core/hle/service/hid/controllers/gesture.h" #include "core/hle/service/hid/controllers/gesture.h"
#include "core/hle/service/hid/controllers/keyboard.h" #include "core/hle/service/hid/controllers/keyboard.h"
#include "core/hle/service/hid/controllers/mouse.h" #include "core/hle/service/hid/controllers/mouse.h"
#include "core/hle/service/hid/controllers/npad.h" #include "core/hle/service/hid/controllers/npad.h"
#include "core/hle/service/hid/controllers/palma.h" #include "core/hle/service/hid/controllers/palma.h"
#include "core/hle/service/hid/controllers/seven_six_axis.h"
#include "core/hle/service/hid/controllers/six_axis.h"
#include "core/hle/service/hid/controllers/stubbed.h" #include "core/hle/service/hid/controllers/stubbed.h"
#include "core/hle/service/hid/controllers/touchscreen.h" #include "core/hle/service/hid/controllers/touchscreen.h"
#include "core/hle/service/hid/controllers/xpad.h" #include "core/hle/service/hid/controllers/xpad.h"
@ -42,76 +43,132 @@ void ResourceManager::Initialize() {
} }
u8* shared_memory = system.Kernel().GetHidSharedMem().GetPointer(); u8* shared_memory = system.Kernel().GetHidSharedMem().GetPointer();
MakeController<Controller_DebugPad>(HidController::DebugPad, shared_memory); debug_pad = std::make_shared<DebugPad>(system.HIDCore(), shared_memory);
MakeController<Controller_Touchscreen>(HidController::Touchscreen, shared_memory); mouse = std::make_shared<Mouse>(system.HIDCore(), shared_memory);
MakeController<Controller_Mouse>(HidController::Mouse, shared_memory); debug_mouse = std::make_shared<DebugMouse>(system.HIDCore(), shared_memory);
MakeController<Controller_Keyboard>(HidController::Keyboard, shared_memory); keyboard = std::make_shared<Keyboard>(system.HIDCore(), shared_memory);
MakeController<Controller_XPad>(HidController::XPad, shared_memory); unique_pad = std::make_shared<UniquePad>(system.HIDCore(), shared_memory);
MakeController<Controller_Stubbed>(HidController::HomeButton, shared_memory); npad = std::make_shared<NPad>(system.HIDCore(), shared_memory, service_context);
MakeController<Controller_Stubbed>(HidController::SleepButton, shared_memory); gesture = std::make_shared<Gesture>(system.HIDCore(), shared_memory);
MakeController<Controller_Stubbed>(HidController::CaptureButton, shared_memory); touch_screen = std::make_shared<TouchScreen>(system.HIDCore(), shared_memory);
MakeController<Controller_Stubbed>(HidController::InputDetector, shared_memory); xpad = std::make_shared<XPad>(system.HIDCore(), shared_memory);
MakeController<Controller_Stubbed>(HidController::UniquePad, shared_memory);
MakeControllerWithServiceContext<Controller_NPad>(HidController::NPad, shared_memory); palma = std::make_shared<Palma>(system.HIDCore(), shared_memory, service_context);
MakeController<Controller_Gesture>(HidController::Gesture, shared_memory);
MakeController<Controller_ConsoleSixAxis>(HidController::ConsoleSixAxisSensor, shared_memory); home_button = std::make_shared<HomeButton>(system.HIDCore(), shared_memory);
MakeController<Controller_Stubbed>(HidController::DebugMouse, shared_memory); sleep_button = std::make_shared<SleepButton>(system.HIDCore(), shared_memory);
MakeControllerWithServiceContext<Controller_Palma>(HidController::Palma, shared_memory); capture_button = std::make_shared<CaptureButton>(system.HIDCore(), shared_memory);
six_axis = std::make_shared<SixAxis>(system.HIDCore(), npad);
console_six_axis = std::make_shared<ConsoleSixAxis>(system.HIDCore(), shared_memory);
seven_six_axis = std::make_shared<SevenSixAxis>(system);
home_button->SetCommonHeaderOffset(0x4C00);
sleep_button->SetCommonHeaderOffset(0x4E00);
capture_button->SetCommonHeaderOffset(0x5000);
unique_pad->SetCommonHeaderOffset(0x5A00);
debug_mouse->SetCommonHeaderOffset(0x3DC00);
// Homebrew doesn't try to activate some controllers, so we activate them by default // Homebrew doesn't try to activate some controllers, so we activate them by default
GetController<Controller_NPad>(HidController::NPad).Activate(); npad->Activate();
GetController<Controller_Touchscreen>(HidController::Touchscreen).Activate(); six_axis->Activate();
touch_screen->Activate();
GetController<Controller_Stubbed>(HidController::HomeButton).SetCommonHeaderOffset(0x4C00);
GetController<Controller_Stubbed>(HidController::SleepButton).SetCommonHeaderOffset(0x4E00);
GetController<Controller_Stubbed>(HidController::CaptureButton).SetCommonHeaderOffset(0x5000);
GetController<Controller_Stubbed>(HidController::InputDetector).SetCommonHeaderOffset(0x5200);
GetController<Controller_Stubbed>(HidController::UniquePad).SetCommonHeaderOffset(0x5A00);
GetController<Controller_Stubbed>(HidController::DebugMouse).SetCommonHeaderOffset(0x3DC00);
system.HIDCore().ReloadInputDevices(); system.HIDCore().ReloadInputDevices();
is_initialized = true; is_initialized = true;
} }
std::shared_ptr<CaptureButton> ResourceManager::GetCaptureButton() const {
return capture_button;
}
std::shared_ptr<ConsoleSixAxis> ResourceManager::GetConsoleSixAxis() const {
return console_six_axis;
}
std::shared_ptr<DebugMouse> ResourceManager::GetDebugMouse() const {
return debug_mouse;
}
std::shared_ptr<DebugPad> ResourceManager::GetDebugPad() const {
return debug_pad;
}
std::shared_ptr<Gesture> ResourceManager::GetGesture() const {
return gesture;
}
std::shared_ptr<HomeButton> ResourceManager::GetHomeButton() const {
return home_button;
}
std::shared_ptr<Keyboard> ResourceManager::GetKeyboard() const {
return keyboard;
}
std::shared_ptr<Mouse> ResourceManager::GetMouse() const {
return mouse;
}
std::shared_ptr<NPad> ResourceManager::GetNpad() const {
return npad;
}
std::shared_ptr<Palma> ResourceManager::GetPalma() const {
return palma;
}
std::shared_ptr<SevenSixAxis> ResourceManager::GetSevenSixAxis() const {
return seven_six_axis;
}
std::shared_ptr<SixAxis> ResourceManager::GetSixAxis() const {
return six_axis;
}
std::shared_ptr<SleepButton> ResourceManager::GetSleepButton() const {
return sleep_button;
}
std::shared_ptr<TouchScreen> ResourceManager::GetTouchScreen() const {
return touch_screen;
}
std::shared_ptr<UniquePad> ResourceManager::GetUniquePad() const {
return unique_pad;
}
void ResourceManager::UpdateControllers(std::uintptr_t user_data, void ResourceManager::UpdateControllers(std::uintptr_t user_data,
std::chrono::nanoseconds ns_late) { std::chrono::nanoseconds ns_late) {
auto& core_timing = system.CoreTiming(); auto& core_timing = system.CoreTiming();
debug_pad->OnUpdate(core_timing);
for (const auto& controller : controllers) { unique_pad->OnUpdate(core_timing);
// Keyboard has it's own update event gesture->OnUpdate(core_timing);
if (controller == controllers[static_cast<size_t>(HidController::Keyboard)]) { touch_screen->OnUpdate(core_timing);
continue; palma->OnUpdate(core_timing);
} home_button->OnUpdate(core_timing);
// Mouse has it's own update event sleep_button->OnUpdate(core_timing);
if (controller == controllers[static_cast<size_t>(HidController::Mouse)]) { capture_button->OnUpdate(core_timing);
continue; xpad->OnUpdate(core_timing);
}
// Npad has it's own update event
if (controller == controllers[static_cast<size_t>(HidController::NPad)]) {
continue;
}
controller->OnUpdate(core_timing);
}
} }
void ResourceManager::UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) { void ResourceManager::UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
auto& core_timing = system.CoreTiming(); auto& core_timing = system.CoreTiming();
npad->OnUpdate(core_timing);
controllers[static_cast<size_t>(HidController::NPad)]->OnUpdate(core_timing);
} }
void ResourceManager::UpdateMouseKeyboard(std::uintptr_t user_data, void ResourceManager::UpdateMouseKeyboard(std::uintptr_t user_data,
std::chrono::nanoseconds ns_late) { std::chrono::nanoseconds ns_late) {
auto& core_timing = system.CoreTiming(); auto& core_timing = system.CoreTiming();
mouse->OnUpdate(core_timing);
controllers[static_cast<size_t>(HidController::Mouse)]->OnUpdate(core_timing); debug_mouse->OnUpdate(core_timing);
controllers[static_cast<size_t>(HidController::Keyboard)]->OnUpdate(core_timing); keyboard->OnUpdate(core_timing);
} }
void ResourceManager::UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) { void ResourceManager::UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
auto& core_timing = system.CoreTiming(); auto& core_timing = system.CoreTiming();
six_axis->OnUpdate(core_timing);
controllers[static_cast<size_t>(HidController::NPad)]->OnMotionUpdate(core_timing); seven_six_axis->OnUpdate(core_timing);
console_six_axis->OnUpdate(core_timing);
} }
IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource) IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource)

117
src/core/hle/service/hid/resource_manager.h
View File

@ -3,10 +3,6 @@
#pragma once #pragma once
#include <chrono>
#include "core/core.h"
#include "core/hle/service/hid/controllers/controller_base.h"
#include "core/hle/service/kernel_helpers.h" #include "core/hle/service/kernel_helpers.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"
@ -14,74 +10,85 @@ namespace Core::Timing {
struct EventType; struct EventType;
} }
namespace Core::HID {
class HIDCore;
}
namespace Service::HID { namespace Service::HID {
class Controller_Stubbed;
class ConsoleSixAxis;
class DebugPad;
class Gesture;
class Keyboard;
class Mouse;
class NPad;
class Palma;
class SevenSixAxis;
class SixAxis;
class TouchScreen;
class XPad;
enum class HidController : std::size_t { using CaptureButton = Controller_Stubbed;
DebugPad, using DebugMouse = Controller_Stubbed;
Touchscreen, using HomeButton = Controller_Stubbed;
Mouse, using SleepButton = Controller_Stubbed;
Keyboard, using UniquePad = Controller_Stubbed;
XPad,
HomeButton,
SleepButton,
CaptureButton,
InputDetector,
UniquePad,
NPad,
Gesture,
ConsoleSixAxisSensor,
DebugMouse,
Palma,
MaxControllers,
};
class ResourceManager { class ResourceManager {
public: public:
explicit ResourceManager(Core::System& system_); explicit ResourceManager(Core::System& system_);
~ResourceManager(); ~ResourceManager();
template <typename T>
T& GetController(HidController controller) {
return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
}
template <typename T>
const T& GetController(HidController controller) const {
return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
}
void Initialize(); void Initialize();
std::shared_ptr<CaptureButton> GetCaptureButton() const;
std::shared_ptr<ConsoleSixAxis> GetConsoleSixAxis() const;
std::shared_ptr<DebugMouse> GetDebugMouse() const;
std::shared_ptr<DebugPad> GetDebugPad() const;
std::shared_ptr<Gesture> GetGesture() const;
std::shared_ptr<HomeButton> GetHomeButton() const;
std::shared_ptr<Keyboard> GetKeyboard() const;
std::shared_ptr<Mouse> GetMouse() const;
std::shared_ptr<NPad> GetNpad() const;
std::shared_ptr<Palma> GetPalma() const;
std::shared_ptr<SevenSixAxis> GetSevenSixAxis() const;
std::shared_ptr<SixAxis> GetSixAxis() const;
std::shared_ptr<SleepButton> GetSleepButton() const;
std::shared_ptr<TouchScreen> GetTouchScreen() const;
std::shared_ptr<UniquePad> GetUniquePad() const;
void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
void UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
void UpdateMouseKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateMouseKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
private: private:
template <typename T>
void MakeController(HidController controller, u8* shared_memory) {
if constexpr (std::is_constructible_v<T, Core::System&, u8*>) {
controllers[static_cast<std::size_t>(controller)] =
std::make_unique<T>(system, shared_memory);
} else {
controllers[static_cast<std::size_t>(controller)] =
std::make_unique<T>(system.HIDCore(), shared_memory);
}
}
template <typename T>
void MakeControllerWithServiceContext(HidController controller, u8* shared_memory) {
controllers[static_cast<std::size_t>(controller)] =
std::make_unique<T>(system.HIDCore(), shared_memory, service_context);
}
bool is_initialized{false}; bool is_initialized{false};
std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
controllers{}; std::shared_ptr<CaptureButton> capture_button = nullptr;
std::shared_ptr<ConsoleSixAxis> console_six_axis = nullptr;
std::shared_ptr<DebugMouse> debug_mouse = nullptr;
std::shared_ptr<DebugPad> debug_pad = nullptr;
std::shared_ptr<Gesture> gesture = nullptr;
std::shared_ptr<HomeButton> home_button = nullptr;
std::shared_ptr<Keyboard> keyboard = nullptr;
std::shared_ptr<Mouse> mouse = nullptr;
std::shared_ptr<NPad> npad = nullptr;
std::shared_ptr<Palma> palma = nullptr;
std::shared_ptr<SevenSixAxis> seven_six_axis = nullptr;
std::shared_ptr<SixAxis> six_axis = nullptr;
std::shared_ptr<SleepButton> sleep_button = nullptr;
std::shared_ptr<TouchScreen> touch_screen = nullptr;
std::shared_ptr<UniquePad> unique_pad = nullptr;
std::shared_ptr<XPad> xpad = nullptr;
// TODO: Create these resources
// std::shared_ptr<AudioControl> audio_control = nullptr;
// std::shared_ptr<ButtonConfig> button_config = nullptr;
// std::shared_ptr<Config> config = nullptr;
// std::shared_ptr<Connection> connection = nullptr;
// std::shared_ptr<CustomConfig> custom_config = nullptr;
// std::shared_ptr<Digitizer> digitizer = nullptr;
// std::shared_ptr<Hdls> hdls = nullptr;
// std::shared_ptr<PlayReport> play_report = nullptr;
// std::shared_ptr<Rail> rail = nullptr;
Core::System& system; Core::System& system;
KernelHelpers::ServiceContext service_context; KernelHelpers::ServiceContext service_context;

3
src/core/hle/service/nfc/common/device_manager.cpp
View File

@ -7,6 +7,7 @@
#include "core/core.h" #include "core/core.h"
#include "core/hid/hid_types.h" #include "core/hid/hid_types.h"
#include "core/hle/kernel/k_event.h" #include "core/hle/kernel/k_event.h"
#include "core/hle/service/hid/hid_util.h"
#include "core/hle/service/ipc_helpers.h" #include "core/hle/service/ipc_helpers.h"
#include "core/hle/service/nfc/common/device.h" #include "core/hle/service/nfc/common/device.h"
#include "core/hle/service/nfc/common/device_manager.h" #include "core/hle/service/nfc/common/device_manager.h"
@ -24,7 +25,7 @@ DeviceManager::DeviceManager(Core::System& system_, KernelHelpers::ServiceContex
for (u32 device_index = 0; device_index < devices.size(); device_index++) { for (u32 device_index = 0; device_index < devices.size(); device_index++) {
devices[device_index] = devices[device_index] =
std::make_shared<NfcDevice>(Core::HID::IndexToNpadIdType(device_index), system, std::make_shared<NfcDevice>(HID::IndexToNpadIdType(device_index), system,
service_context, availability_change_event); service_context, availability_change_event);
} }

5
src/core/memory/cheat_engine.cpp
View File

@ -68,10 +68,7 @@ u64 StandardVmCallbacks::HidKeysDown() {
return 0; return 0;
} }
const auto press_state = const auto press_state = applet_resource->GetNpad()->GetAndResetPressState();
applet_resource
->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad)
.GetAndResetPressState();
return static_cast<u64>(press_state & HID::NpadButton::All); return static_cast<u64>(press_state & HID::NpadButton::All);
} }