diff --git a/src/core/hle/service/hid/hid_server.cpp b/src/core/hle/service/hid/hid_server.cpp index b2f863177..8bc1b1b16 100644 --- a/src/core/hle/service/hid/hid_server.cpp +++ b/src/core/hle/service/hid/hid_server.cpp @@ -1679,7 +1679,7 @@ void IHidServer::SetNpadJoyAssignmentModeSingleWithDestination(HLERequestContext void IHidServer::SetNpadAnalogStickUseCenterClamp(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; struct Parameters { - bool analog_stick_use_center_clamp; + bool use_center_clamp; INSERT_PADDING_BYTES_NOINIT(7); u64 applet_resource_user_id; }; @@ -1688,11 +1688,11 @@ void IHidServer::SetNpadAnalogStickUseCenterClamp(HLERequestContext& ctx) { const auto parameters{rp.PopRaw()}; LOG_WARNING(Service_HID, - "(STUBBED) called, analog_stick_use_center_clamp={}, applet_resource_user_id={}", - parameters.analog_stick_use_center_clamp, parameters.applet_resource_user_id); + "(STUBBED) called, use_center_clamp={}, applet_resource_user_id={}", + parameters.use_center_clamp, parameters.applet_resource_user_id); GetResourceManager()->GetNpad()->SetNpadAnalogStickUseCenterClamp( - parameters.applet_resource_user_id, parameters.analog_stick_use_center_clamp); + parameters.applet_resource_user_id, parameters.use_center_clamp); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(ResultSuccess); @@ -1730,7 +1730,7 @@ void IHidServer::ClearNpadCaptureButtonAssignment(HLERequestContext& ctx) { applet_resource_user_id); const auto npad = GetResourceManager()->GetNpad(); - const auto result = npad->ClearNpadCaptureButtonAssignment(parameters.applet_resource_user_id); + const auto result = npad->ClearNpadCaptureButtonAssignment(applet_resource_user_id); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(result); diff --git a/src/core/hle/service/hid/resource_manager/npad.cpp b/src/core/hle/service/hid/resource_manager/npad.cpp index 89ac96073..a29a6eb55 100644 --- a/src/core/hle/service/hid/resource_manager/npad.cpp +++ b/src/core/hle/service/hid/resource_manager/npad.cpp @@ -40,7 +40,7 @@ u32 NpadControllerState::GetConnectedControllerIndex() { u32 connected_controllers = 0; u32 connected_index = 0; - u32 index = 0; + // u32 index = 0; if (connected_controllers == 0) { return 0; @@ -75,7 +75,7 @@ void NpadState::SetNpadJoyHoldType(const NpadJoyHoldType hold_type) { npad_hold_type = hold_type; } -NpadJoyHoldType NpadState::GetNpadJoyHoldType() { +NpadJoyHoldType NpadState::GetNpadJoyHoldType() const { return npad_hold_type; } @@ -96,10 +96,34 @@ void NpadState::SetSupportedNpadStyleSet(const NpadStyleSet supported_style_set) supported_npad_style_set = supported_style_set; } -NpadStyleSet NpadState::GetSupportedNpadStyleSet() { +NpadStyleSet NpadState::GetSupportedNpadStyleSet() const { return supported_npad_style_set; } +void NpadState::SetLrAssignmentMode(const bool is_enabled) { + status.lr_assignment_mode.Assign(is_enabled); +} + +bool NpadState::GetLrAssignmentMode() const { + return status.lr_assignment_mode != 0; +} + +void NpadState::SetNpadHandheldActivationMode(const NpadHandheldActivationMode mode) { + handheld_activation_mode = mode; +} + +NpadHandheldActivationMode NpadState::GetNpadHandheldActivationMode() const { + return handheld_activation_mode; +} + +bool NpadState::IsUnintendedHomeButtonInputProtectionEnabled() const { + return unintended_home_button_input_proptection; +} + +void NpadState::SetNpadAnalogStickUseCenterClampImpl(const bool is_enabled) { + status.use_center_clamp.Assign(is_enabled); +} + Npad::Npad() { for (auto& npad : npad_state) { npad = std::make_shared(); @@ -153,7 +177,7 @@ Result Npad::SetNpadJoyHoldType(const u64 aruid, const NpadJoyHoldType hold_type return ResultSuccess; } -Result Npad::GetNpadJoyHoldType(const u64 aruid, NpadJoyHoldType& hold_type) { +Result Npad::GetNpadJoyHoldType(const u64 aruid, NpadJoyHoldType& out_hold_type) const { const auto index = GetIndexFromAruid(aruid); if (index >= ARUID_MAX) { @@ -161,9 +185,9 @@ Result Npad::GetNpadJoyHoldType(const u64 aruid, NpadJoyHoldType& hold_type) { } const auto state = npad_state[index]; - hold_type = state->GetNpadJoyHoldType(); + out_hold_type = state->GetNpadJoyHoldType(); if ((state->status.raw & 0x30) != 0) { - hold_type = active_npad_state->GetNpadJoyHoldType(); + out_hold_type = active_npad_state->GetNpadJoyHoldType(); } return ResultSuccess; @@ -231,18 +255,20 @@ Result Npad::SetSupportedNpadStyleSetImpl(const u64 aruid, const NpadStyleSet su return ResultSuccess; } -Result Npad::GetSupportedNpadStyleSet(const u64 aruid, NpadStyleSet& supported_style_set) { - const Result result = GetSupportedNpadStyleSetImpl(aruid, supported_style_set); +Result Npad::GetSupportedNpadStyleSet(const u64 aruid, + NpadStyleSet& out_supported_style_set) const { + const Result result = GetSupportedNpadStyleSetImpl(aruid, out_supported_style_set); if (result == ResultNpadNotConnected) { - supported_style_set = NpadStyleSet::None; + out_supported_style_set = NpadStyleSet::None; return ResultSuccess; } return result; } -Result Npad::GetSupportedNpadStyleSetImpl(const u64 aruid, NpadStyleSet& supported_style_set) { +Result Npad::GetSupportedNpadStyleSetImpl(const u64 aruid, + NpadStyleSet& out_supported_style_set) const { const auto index = GetIndexFromAruid(aruid); if (index >= ARUID_MAX) { @@ -253,12 +279,12 @@ Result Npad::GetSupportedNpadStyleSetImpl(const u64 aruid, NpadStyleSet& support return ResultUndefinedStyleSet; } - supported_style_set = npad_state[index]->GetSupportedNpadStyleSet(); + out_supported_style_set = npad_state[index]->GetSupportedNpadStyleSet(); return ResultSuccess; } -bool Npad::IsFirmwareUpdateAvailableForSixAxisSensor(const SixAxisSensorHandle& handle) { +bool Npad::IsFirmwareUpdateAvailableForSixAxisSensor(const SixAxisSensorHandle& handle) const { // Not implemented return false; } @@ -391,6 +417,145 @@ Result Npad::SwapNpadAssignment(const u64 aruid, const NpadIdType npad_id_1, if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) { return ResultSuccess; } + return ResultSuccess; +} + +Result Npad::StartLrAssignmentMode(const u64 aruid) { + bool is_enabled{}; + Result result = GetLrAssignmentMode(is_enabled, aruid); + + if (result.IsSuccess() && !is_enabled) { + result = SetLrAssignmentMode(aruid, true); + } + + return result; +} + +Result Npad::StopLrAssignmentMode(const u64 aruid) { + bool is_enabled{}; + Result result = GetLrAssignmentMode(is_enabled, aruid); + + if (result.IsSuccess() && is_enabled) { + result = SetLrAssignmentMode(aruid, false); + } + + return result; +} + +Result Npad::SetLrAssignmentMode(const u64 aruid, const bool is_enabled) { + const auto index = GetIndexFromAruid(aruid); + + if (index >= ARUID_MAX) { + return ResultNpadNotConnected; + } + + npad_state[index]->SetLrAssignmentMode(is_enabled); + if (active_aruid == aruid) { + active_npad_state->SetLrAssignmentMode(is_enabled); + } + + return ResultSuccess; +} + +Result Npad::GetLrAssignmentMode(bool& out_is_enabled, const u64 aruid) const { + const auto index = GetIndexFromAruid(aruid); + + if (index >= ARUID_MAX) { + return ResultNpadNotConnected; + } + + out_is_enabled = npad_state[index]->GetLrAssignmentMode(); + + return ResultSuccess; +} + +Result Npad::SetNpadHandheldActivationMode(const u64 aruid, const NpadHandheldActivationMode mode) { + const Result result = SetNpadHandheldActivationModeImpl(aruid, mode); + + if (result.IsSuccess()) { + active_npad_state->GetControllerState(NpadIdType::Handheld)->Update(); + } + + return result; +} + +Result Npad::SetNpadHandheldActivationModeImpl(const u64 aruid, + const NpadHandheldActivationMode mode) { + const auto index = GetIndexFromAruid(aruid); + + if (index >= ARUID_MAX) { + return ResultNpadNotConnected; + } + + npad_state[index]->SetNpadHandheldActivationMode(mode); + if (active_aruid == aruid) { + active_npad_state->SetNpadHandheldActivationMode(mode); + } + + return ResultSuccess; +} + +Result Npad::GetNpadHandheldActivationMode(const u64 aruid, + NpadHandheldActivationMode& out_mode) const { + const auto index = GetIndexFromAruid(aruid); + + if (index >= ARUID_MAX) { + return ResultNpadNotConnected; + } + + out_mode = npad_state[index]->GetNpadHandheldActivationMode(); + + return ResultSuccess; +} + +Result Npad::IsUnintendedHomeButtonInputProtectionEnabled(bool& out_is_enabled, const u64 aruid, + const NpadIdType npad_id) const { + const auto index = GetIndexFromAruid(aruid); + + if (index >= ARUID_MAX) { + return ResultNpadNotConnected; + } + + out_is_enabled = npad_state[index]->IsUnintendedHomeButtonInputProtectionEnabled(); + + return ResultSuccess; +} + +Result Npad::EnableUnintendedHomeButtonInputProtection(const u64 aruid, const NpadIdType npad_id, + const bool is_enabled) { + // tooo complicated + return ResultSuccess; +} + +void Npad::SetNpadAnalogStickUseCenterClamp(const u64 aruid, const bool use_center_clamp) { + SetNpadAnalogStickUseCenterClampImpl(aruid, use_center_clamp); +} + +Result Npad::SetNpadAnalogStickUseCenterClampImpl(const u64 aruid, const bool use_center_clamp) { + const auto index = GetIndexFromAruid(aruid); + + if (index >= ARUID_MAX) { + return ResultNpadNotConnected; + } + + npad_state[index]->SetNpadAnalogStickUseCenterClampImpl(use_center_clamp); + if (active_aruid == aruid) { + active_npad_state->SetNpadAnalogStickUseCenterClampImpl(use_center_clamp); + } + + return ResultSuccess; +} + +Result Npad::SetNpadCaptureButtonAssignment(const u64 aruid, const NpadStyleSet npad_styleset, + const NpadButton buttons) { + // tooo complicated + + return ResultSuccess; +} + +Result Npad::ClearNpadCaptureButtonAssignment(const u64 aruid) { + + return ResultSuccess; } Result Npad::AcquireNpadStyleSetUpdateEventHandle(const u64 aruid, diff --git a/src/core/hle/service/hid/resource_manager/npad.h b/src/core/hle/service/hid/resource_manager/npad.h index 900ed796c..99ba866aa 100644 --- a/src/core/hle/service/hid/resource_manager/npad.h +++ b/src/core/hle/service/hid/resource_manager/npad.h @@ -17,8 +17,12 @@ class KReadableEvent; namespace Service::HID { enum class NpadIdType : u32; +enum class NpadJoyAssignmentMode : u32; +enum class NpadHandheldActivationMode : u64; +enum class NpadJoyDeviceType : s64; enum class NpadStyleSet : u32; enum class NpadJoyHoldType : u64; +enum class NpadButton : u64; struct SixAxisSensorHandle; } // namespace Service::HID @@ -56,6 +60,8 @@ public: BitField<0, 1, u32> is_supported_style_set; BitField<1, 1, u32> is_hold_type_set; + BitField<2, 1, u32> lr_assignment_mode; + BitField<7, 1, u32> use_center_clamp; }; }; static_assert(sizeof(NpadStatus) == 4, "NpadStatus is an invalid size"); @@ -66,18 +72,29 @@ public: std::shared_ptr GetControllerState(const NpadIdType& npad_id) const; void SetNpadJoyHoldType(const NpadJoyHoldType hold_type); - NpadJoyHoldType GetNpadJoyHoldType(); + NpadJoyHoldType GetNpadJoyHoldType() const; Result SetSupportedNpadIdType(std::span list); void SetSupportedNpadStyleSet(const NpadStyleSet supported_style_set); - NpadStyleSet GetSupportedNpadStyleSet(); + NpadStyleSet GetSupportedNpadStyleSet() const; + + void SetLrAssignmentMode(const bool is_enabled); + bool GetLrAssignmentMode() const; + + void SetNpadHandheldActivationMode(const NpadHandheldActivationMode mode); + NpadHandheldActivationMode GetNpadHandheldActivationMode() const; + + bool IsUnintendedHomeButtonInputProtectionEnabled() const; + void SetNpadAnalogStickUseCenterClampImpl(const bool is_enabled); NpadStatus status{}; private: NpadJoyHoldType npad_hold_type{}; NpadStyleSet supported_npad_style_set{}; + NpadHandheldActivationMode handheld_activation_mode{}; + bool unintended_home_button_input_proptection{}; std::size_t supported_npad_id_types_count{}; std::array supported_npad_id_types{}; @@ -98,28 +115,43 @@ public: // Config Result SetNpadJoyHoldType(const u64 aruid, const NpadJoyHoldType hold_type); - Result GetNpadJoyHoldType(const u64 aruid, NpadJoyHoldType& hold_type); + Result GetNpadJoyHoldType(const u64 aruid, NpadJoyHoldType& out_hold_type) const; Result SetSupportedNpadIdType(const u64 aruid, std::span list); Result SetSupportedNpadStyleSet(const u64 aruid, const NpadStyleSet supported_style_set); - Result GetSupportedNpadStyleSet(const u64 aruid, NpadStyleSet& supported_style_set); + Result GetSupportedNpadStyleSet(const u64 aruid, NpadStyleSet& out_supported_style_set) const; // Sixaxis - bool IsFirmwareUpdateAvailableForSixAxisSensor(const SixAxisSensorHandle& handle); + bool IsFirmwareUpdateAvailableForSixAxisSensor(const SixAxisSensorHandle& handle) const; Result ResetIsSixAxisSensorDeviceNewlyAssigned(const u64 aruid, const SixAxisSensorHandle& handle); - // Merge, swap or split npad + // Assignment, merge, swap or split npad void SetNpadJoyAssignmentModeSingleByDefault(const u64 aruid, const NpadIdType npad_id); void SetNpadJoyAssignmentModeSingle(const u64 aruid, const NpadIdType npad_id, const NpadJoyDeviceType npad_joy_device_type); bool SetNpadJoyAssignmentModeSingleWithDestination( NpadIdType& out_npad_id, const u64 aruid, const NpadIdType npad_id, - const NpadJoyDeviceType npad_joy_device_type); + const NpadJoyDeviceType npad_joy_device_type); void SetNpadJoyAssignmentModeDual(const u64 aruid, const NpadIdType npad_id); Result MergeSingleJoyAsDualJoy(const u64 aruid, const NpadIdType npad_id_1, const NpadIdType npad_id_2); Result SwapNpadAssignment(const u64 aruid, const NpadIdType npad_id_1, - const NpadIdType npad_id_2); + const NpadIdType npad_id_2); + Result StartLrAssignmentMode(const u64 aruid); + Result StopLrAssignmentMode(const u64 aruid); + Result SetNpadHandheldActivationMode(const u64 aruid, const NpadHandheldActivationMode mode); + Result GetNpadHandheldActivationMode(const u64 aruid, + NpadHandheldActivationMode& out_mode) const; + + // Sticks and Button + Result IsUnintendedHomeButtonInputProtectionEnabled(bool& out_is_enabled, const u64 aruid, + const NpadIdType npad_id) const; + Result EnableUnintendedHomeButtonInputProtection(const u64 aruid, const NpadIdType npad_id, + const bool is_enabled); + void SetNpadAnalogStickUseCenterClamp(const u64 aruid, const bool use_center_clamp); + Result SetNpadCaptureButtonAssignment(const u64 aruid, const NpadStyleSet npad_styleset, + const NpadButton buttons); + Result ClearNpadCaptureButtonAssignment(const u64 aruid); // Events Result AcquireNpadStyleSetUpdateEventHandle(const u64 aruid, Kernel::KReadableEvent** out_event, @@ -129,10 +161,16 @@ private: // Interface implementations Result SetSupportedNpadIdTypeImpl(const u64 aruid, std::span list); Result SetSupportedNpadStyleSetImpl(const u64 aruid, const NpadStyleSet supported_style_set); - Result GetSupportedNpadStyleSetImpl(const u64 aruid, NpadStyleSet& supported_style_set); - bool SetNpadJoyAssignmentMode(NpadIdType* out_npad_id, const u64 aruid, const NpadIdType npad_id, - const NpadJoyDeviceType npad_joy_device_type); - + Result GetSupportedNpadStyleSetImpl(const u64 aruid, + NpadStyleSet& out_supported_style_set) const; + bool SetNpadJoyAssignmentMode(NpadIdType* out_npad_id, const u64 aruid, + const NpadIdType npad_id, + const NpadJoyDeviceType npad_joy_device_type); + Result SetLrAssignmentMode(const u64 aruid, const bool is_enabled); + Result GetLrAssignmentMode(bool& out_is_enabled, const u64 aruid) const; + Result SetNpadHandheldActivationModeImpl(const u64 aruid, + const NpadHandheldActivationMode mode); + Result SetNpadAnalogStickUseCenterClampImpl(const u64 aruid, const bool use_center_clamp); // Update state void UpdateSupportedNpadIdType(); diff --git a/src/core/hle/service/hid/resource_manager/sixaxis.cpp b/src/core/hle/service/hid/resource_manager/sixaxis.cpp index c40f9fafe..536e762ee 100644 --- a/src/core/hle/service/hid/resource_manager/sixaxis.cpp +++ b/src/core/hle/service/hid/resource_manager/sixaxis.cpp @@ -13,6 +13,7 @@ SixAxis::~SixAxis() = default; Result SixAxis::GetSensorState(std::shared_ptr& out_state, u64 aruid, const SixAxisSensorHandle& handle) { + std::scoped_lock lock{mutex}; const auto state = GetStateFromAruid(aruid); if (state == nullptr) { @@ -71,119 +72,169 @@ std::shared_ptr SixAxisState::GetSensorState( } SixAxisSensorState::SixAxisSensorState() { - ResetFusionParameters(); - ResetAccelerometerParameters(); - ResetAccelerometerPlayMode(); - ResetGyroscopeZeroDriftMode(); + Initialize(); } SixAxisSensorState::~SixAxisSensorState() = default; void SixAxisSensorState::SetRunningState(const bool state) { - is_running = state; + sensor_state.sensor.is_running = state; } void SixAxisSensorState::SetUnalteredPassthrough(const bool is_enabled) { - is_passthrough_enabled = is_enabled; + sensor_state.sensor.is_passthrough_enabled = is_enabled; } bool SixAxisSensorState::GetUnalteredPassthrough() { - return is_passthrough_enabled; + return sensor_state.sensor.is_passthrough_enabled; } bool SixAxisSensorState::IsFusionEnabled() const { - return is_fusion_enabled; + return sensor_state.accel.is_fusion_enabled; } void SixAxisSensorState::ResetFusionParameters() { - is_fusion_enabled = true; - fusion_parameter_1 = 0.03f; - fusion_parameter_2 = 0.4f; + sensor_state.accel.is_fusion_enabled = true; + sensor_state.accel.fusion_parameter_1 = 0.03f; + sensor_state.accel.fusion_parameter_2 = 0.4f; } void SixAxisSensorState::SetFusionState(const bool is_enabled) { - is_fusion_enabled = is_enabled; + sensor_state.accel.is_fusion_enabled = is_enabled; } void SixAxisSensorState::SetFusionParameters(const SixAxisSensorFusionParameters& parameters) { - fusion_parameter_1 = parameters.parameter1; - fusion_parameter_2 = parameters.parameter2; + sensor_state.accel.fusion_parameter_1 = parameters.parameter1; + sensor_state.accel.fusion_parameter_2 = parameters.parameter2; } SixAxisSensorFusionParameters SixAxisSensorState::GetFusionParameters() const { return { - .parameter1 = fusion_parameter_1, - .parameter2 = fusion_parameter_2, + .parameter1 = sensor_state.accel.fusion_parameter_1, + .parameter2 = sensor_state.accel.fusion_parameter_2, }; } void SixAxisSensorState::ResetAccelerometerParameters() { - accelerometer_parameter_1 = 0.0f; - accelerometer_parameter_2 = 1.0f; + sensor_state.accel.accelerometer_parameter_1 = 0.0f; + sensor_state.accel.accelerometer_parameter_2 = 1.0f; } void SixAxisSensorState::SetAccelerometerParameters( const SixAxisAccelerometerParameters& parameters) { - accelerometer_parameter_1 = parameters.parameter1; - accelerometer_parameter_2 = parameters.parameter2; + sensor_state.accel.accelerometer_parameter_1 = parameters.parameter1; + sensor_state.accel.accelerometer_parameter_2 = parameters.parameter2; } SixAxisAccelerometerParameters SixAxisSensorState::GetAccelerometerParameters() const { return { - .parameter1 = accelerometer_parameter_1, - .parameter2 = accelerometer_parameter_2, + .parameter1 = sensor_state.accel.accelerometer_parameter_1, + .parameter2 = sensor_state.accel.accelerometer_parameter_2, }; } void SixAxisSensorState::SetShiftAccelerometerCalibrationValue( const SixAxisSensorShiftAccelerometerCalibration& calibration) { - shift_accelerometer_calibration_1 = calibration.calibration1; - shift_accelerometer_calibration_2 = calibration.calibration1; + sensor_state.accel.shift_calibration_1 = calibration.calibration1; + sensor_state.accel.shift_calibration_2 = calibration.calibration1; } SixAxisSensorShiftAccelerometerCalibration SixAxisSensorState::GetShiftAccelerometerCalibrationValue() const { return { - .calibration1 = shift_accelerometer_calibration_1, - .calibration2 = shift_accelerometer_calibration_2, + .calibration1 = sensor_state.accel.shift_calibration_1, + .calibration2 = sensor_state.accel.shift_calibration_2, }; } void SixAxisSensorState::ResetAccelerometerPlayMode() { - play_mode = AccelerometerPlayMode::Tight; + sensor_state.accel.play_mode = AccelerometerPlayMode::Tight; } void SixAxisSensorState::SetAccelerometerPlayMode(const AccelerometerPlayMode mode) { - play_mode = mode; + sensor_state.accel.play_mode = mode; } AccelerometerPlayMode SixAxisSensorState::GetAccelerometerPlayMode() const { - return play_mode; + return sensor_state.accel.play_mode; } void SixAxisSensorState::ResetGyroscopeZeroDriftMode() { - zero_drift_mode = GyroscopeZeroDriftMode::Standard; + sensor_state.gyro.zero_drift_mode = GyroscopeZeroDriftMode::Standard; } void SixAxisSensorState::SetGyroscopeZeroDriftMode(const GyroscopeZeroDriftMode mode) { - zero_drift_mode = mode; + sensor_state.gyro.zero_drift_mode = mode; } GyroscopeZeroDriftMode SixAxisSensorState::GetGyroscopeZeroDriftMode() const { - return zero_drift_mode; + return sensor_state.gyro.zero_drift_mode; } void SixAxisSensorState::SetShiftGyroscopeCalibrationValue( const SixAxisSensorShiftGyroscopeCalibration& calibration) { - shift_gyroscope_calibration_1 = calibration.calibration1; - shift_gyroscope_calibration_2 = calibration.calibration1; + sensor_state.gyro.shift_calibration_1 = calibration.calibration1; + sensor_state.gyro.shift_calibration_2 = calibration.calibration1; } SixAxisSensorShiftGyroscopeCalibration SixAxisSensorState::GetShiftGyroscopeCalibrationValue() const { return { - .calibration1 = shift_gyroscope_calibration_1, - .calibration2 = shift_gyroscope_calibration_2, + .calibration1 = sensor_state.gyro.shift_calibration_1, + .calibration2 = sensor_state.gyro.shift_calibration_2, }; } +void SixAxisSensorState::Initialize() { + InitializeAccelerometerValues(true); + InitializeGyroValues(true); + InitializeSensorValues(); +} + +void SixAxisSensorState::InitializeAccelerometerValues(const bool is_enabled) { + sensor_state.accel.play_mode = AccelerometerPlayMode::Tight; + sensor_state.accel.is_fusion_enabled = true; + sensor_state.accel.unknown_value = 8; + sensor_state.accel.accelerometer_parameter_1 = 0.0f; + sensor_state.accel.accelerometer_parameter_2 = 1.0f; + sensor_state.accel.fusion_parameter_1 = 0.03f; + sensor_state.accel.fusion_parameter_2 = 0.4f; + if (is_enabled) { + sensor_state.accel.shift_calibration_1 = 0.0f; + sensor_state.accel.shift_calibration_2 = 1.0f; + } +} + +void SixAxisSensorState::InitializeGyroValues(const bool is_enabled) { + sensor_state.gyro.shift_calibration_1 = 9.463809e-41f; + sensor_state.gyro.shift_calibration_2 = 0.0f; + sensor_state.gyro.zero_drift_mode = GyroscopeZeroDriftMode::Standard; + sensor_state.gyro.unknown_gyro[0] = 1.0f; + sensor_state.gyro.unknown_gyro[1] = 1.0f; + sensor_state.gyro.unknown_gyro[2] = 1.0f; + sensor_state.gyro.unknown_gyro[3] = 1.0f; + sensor_state.gyro.unknown_gyro[4] = 1.0f; + sensor_state.gyro.unknown_gyro[5] = 1.0f; + if (is_enabled) { + sensor_state.gyro.unknown_gyro[6] = 0.0f; + sensor_state.gyro.unknown_gyro[7] = 1.0f; + } +} + +void SixAxisSensorState::InitializeSensorValues() { + sensor_state.sensor.is_running = false; + sensor_state.sensor.unknown_bool = false; + sensor_state.sensor.is_passthrough_enabled = false; + // This pretty much looks like an identity matrix + sensor_state.sensor.unknown_sensor[0] = 1.0f; + sensor_state.sensor.unknown_sensor[1] = 0.0f; + sensor_state.sensor.unknown_sensor[2] = 0.0f; + sensor_state.sensor.unknown_sensor[3] = 0.0f; + sensor_state.sensor.unknown_sensor[4] = 1.0f; + sensor_state.sensor.unknown_sensor[5] = 0.0f; + sensor_state.sensor.unknown_sensor[6] = 0.0f; + sensor_state.sensor.unknown_sensor[7] = 0.0f; + sensor_state.sensor.unknown_sensor[8] = 1.0f; + sensor_state.sensor.unknown_sensor[9] = 0.0f; +} + } // namespace Service::HID diff --git a/src/core/hle/service/hid/resource_manager/sixaxis.h b/src/core/hle/service/hid/resource_manager/sixaxis.h index 00d88bed4..dc905b9f3 100644 --- a/src/core/hle/service/hid/resource_manager/sixaxis.h +++ b/src/core/hle/service/hid/resource_manager/sixaxis.h @@ -4,6 +4,7 @@ #pragma once #include +#include #include "core/hle/service/hid/resource_manager/base_resource.h" @@ -63,25 +64,51 @@ public: SixAxisSensorShiftGyroscopeCalibration GetShiftGyroscopeCalibrationValue() const; private: - bool is_running{}; - bool is_passthrough_enabled{}; + void Initialize(); + void InitializeAccelerometerValues(const bool is_enabled); + void InitializeGyroValues(const bool is_enabled); + void InitializeSensorValues(); - // Sensor fusion - bool is_fusion_enabled{}; - float fusion_parameter_1{}; - float fusion_parameter_2{}; + struct AccelerometerParams { + u32 unknown_value{}; + AccelerometerPlayMode play_mode{}; + float accelerometer_parameter_1{}; + float accelerometer_parameter_2{}; + bool is_fusion_enabled{}; + INSERT_PADDING_BYTES(0x3); + float fusion_parameter_1{}; + float fusion_parameter_2{}; + float shift_calibration_1{}; + float shift_calibration_2{}; + }; + static_assert(sizeof(AccelerometerParams) == 0x24, "AccelerometerParams is an invalid size"); - // Accelerometer - float accelerometer_parameter_1{}; - float accelerometer_parameter_2{}; - float shift_accelerometer_calibration_1{}; - float shift_accelerometer_calibration_2{}; - AccelerometerPlayMode play_mode{}; + struct GyroscopeParams { + float shift_calibration_1{}; + float shift_calibration_2{}; + GyroscopeZeroDriftMode zero_drift_mode{}; + std::array unknown_gyro{}; + }; + static_assert(sizeof(GyroscopeParams) == 0x2c, "GyroscopeParams is an invalid size"); - // Gyroscope - float shift_gyroscope_calibration_1{}; - float shift_gyroscope_calibration_2{}; - GyroscopeZeroDriftMode zero_drift_mode{}; + struct SensorParams { + bool is_running{}; + bool unknown_bool{}; + INSERT_PADDING_BYTES(0x2); + std::array unknown_sensor{}; + bool is_passthrough_enabled{}; + INSERT_PADDING_BYTES(0x3); + }; + static_assert(sizeof(SensorParams) == 0x30, "SensorParams is an invalid size"); + + struct SensorState { + AccelerometerParams accel; + GyroscopeParams gyro; + SensorParams sensor; + }; + static_assert(sizeof(SensorState) == 0x80, "SensorState is an invalid size"); + + SensorState sensor_state{}; }; class SixAxisState { @@ -116,6 +143,7 @@ public: private: std::shared_ptr GetStateFromAruid(const u64 aruid) const; + mutable std::mutex mutex; std::shared_ptr active_sixaxis_state = nullptr; std::array, ARUID_MAX> sixaxis_state{}; };