mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-08-06 17:32:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Code cleanup & clang

Browse Source
This commit is contained in:
kalaposfos13 2024-12-31 14:03:43 +01:00
parent 3f0b5b86b0
commit d76531847d
3 changed files with 49 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/core/libraries/pad/pad.cpp
View File

@ -285,21 +285,8 @@ int PS4_SYSV_ABI scePadOutputReport() {
return ORBIS_OK; return ORBIS_OK;
} }
void CalculateOrientation(const OrbisFVector3& acceleration, const OrbisFVector3& angularVelocity,
float deltaTime, OrbisFQuaternion& orientation) {
float acceleration_vec_len =
sqrt(acceleration.x * acceleration.x + acceleration.y * acceleration.y +
acceleration.z * acceleration.z);
orientation.x = acceleration.x / acceleration_vec_len;
orientation.y = acceleration.y / acceleration_vec_len;
orientation.z = acceleration.z / acceleration_vec_len;
orientation.w = 0.0f;
LOG_DEBUG(Lib_Pad, "Calculated orientation: {:2f} {:2f} {:2f} {:2f}", orientation.x,
orientation.y, orientation.z, orientation.w);
}
int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) { int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) {
LOG_DEBUG(Lib_Pad, "called"); LOG_TRACE(Lib_Pad, "called");
int connected_count = 0; int connected_count = 0;
bool connected = false; bool connected = false;
Input::State states[64]; Input::State states[64];
@ -318,15 +305,15 @@ int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) {
pData[i].rightStick.y = states[i].axes[static_cast<int>(Input::Axis::RightY)]; pData[i].rightStick.y = states[i].axes[static_cast<int>(Input::Axis::RightY)];
pData[i].analogButtons.l2 = states[i].axes[static_cast<int>(Input::Axis::TriggerLeft)]; pData[i].analogButtons.l2 = states[i].axes[static_cast<int>(Input::Axis::TriggerLeft)];
pData[i].analogButtons.r2 = states[i].axes[static_cast<int>(Input::Axis::TriggerRight)]; pData[i].analogButtons.r2 = states[i].axes[static_cast<int>(Input::Axis::TriggerRight)];
pData[i].acceleration.x = states[i].acceleration[0]; pData[i].acceleration.x = states[i].acceleration.x;
pData[i].acceleration.y = states[i].acceleration[1]; pData[i].acceleration.y = states[i].acceleration.y;
pData[i].acceleration.z = states[i].acceleration[2]; pData[i].acceleration.z = states[i].acceleration.z;
pData[i].angularVelocity.x = states[i].angularVelocity[0]; pData[i].angularVelocity.x = states[i].angularVelocity.x;
pData[i].angularVelocity.y = states[i].angularVelocity[1]; pData[i].angularVelocity.y = states[i].angularVelocity.y;
pData[i].angularVelocity.z = states[i].angularVelocity[2]; pData[i].angularVelocity.z = states[i].angularVelocity.z;
CalculateOrientation(pData[i].acceleration, pData[i].angularVelocity, Input::GameController::CalculateOrientation(pData[i].acceleration, pData[i].angularVelocity,
1.0f / controller->accel_poll_rate, 1.0f / controller->accel_poll_rate,
pData[i].orientation); pData[i].orientation);
pData[i].touchData.touchNum = pData[i].touchData.touchNum =
(states[i].touchpad[0].state ? 1 : 0) + (states[i].touchpad[1].state ? 1 : 0); (states[i].touchpad[0].state ? 1 : 0) + (states[i].touchpad[1].state ? 1 : 0);
pData[i].touchData.touch[0].x = states[i].touchpad[0].x; pData[i].touchData.touch[0].x = states[i].touchpad[0].x;
@ -365,7 +352,7 @@ int PS4_SYSV_ABI scePadReadHistory() {
} }
int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) { int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) {
LOG_DEBUG(Lib_Pad, "called"); LOG_TRACE(Lib_Pad, "called");
if (handle == ORBIS_PAD_ERROR_DEVICE_NO_HANDLE) { if (handle == ORBIS_PAD_ERROR_DEVICE_NO_HANDLE) {
return ORBIS_PAD_ERROR_INVALID_HANDLE; return ORBIS_PAD_ERROR_INVALID_HANDLE;
} }
@ -381,13 +368,15 @@ int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) {
pData->rightStick.y = state.axes[static_cast<int>(Input::Axis::RightY)]; pData->rightStick.y = state.axes[static_cast<int>(Input::Axis::RightY)];
pData->analogButtons.l2 = state.axes[static_cast<int>(Input::Axis::TriggerLeft)]; pData->analogButtons.l2 = state.axes[static_cast<int>(Input::Axis::TriggerLeft)];
pData->analogButtons.r2 = state.axes[static_cast<int>(Input::Axis::TriggerRight)]; pData->analogButtons.r2 = state.axes[static_cast<int>(Input::Axis::TriggerRight)];
pData->acceleration.x = state.acceleration[0]; pData->acceleration.x = state.acceleration.x;
pData->acceleration.y = state.acceleration[1]; pData->acceleration.y = state.acceleration.y;
pData->acceleration.z = state.acceleration[2]; pData->acceleration.z = state.acceleration.z;
pData->angularVelocity.x = state.angularVelocity[0]; pData->angularVelocity.x = state.angularVelocity.x;
pData->angularVelocity.y = state.angularVelocity[1]; pData->angularVelocity.y = state.angularVelocity.y;
pData->angularVelocity.z = state.angularVelocity[2]; pData->angularVelocity.z = state.angularVelocity.z;
CalculateOrientation(pData->acceleration, pData->angularVelocity, 1.0f / controller->accel_poll_rate, pData->orientation); Input::GameController::CalculateOrientation(pData->acceleration, pData->angularVelocity,
1.0f / controller->accel_poll_rate,
pData->orientation);
pData->touchData.touchNum = pData->touchData.touchNum =
(state.touchpad[0].state ? 1 : 0) + (state.touchpad[1].state ? 1 : 0); (state.touchpad[0].state ? 1 : 0) + (state.touchpad[1].state ? 1 : 0);
pData->touchData.touch[0].x = state.touchpad[0].x; pData->touchData.touch[0].x = state.touchpad[0].x;
@ -508,7 +497,7 @@ int PS4_SYSV_ABI scePadSetLoginUserNumber() {
int PS4_SYSV_ABI scePadSetMotionSensorState(s32 handle, bool bEnable) { int PS4_SYSV_ABI scePadSetMotionSensorState(s32 handle, bool bEnable) {
LOG_ERROR(Lib_Pad, "(STUBBED) called"); LOG_ERROR(Lib_Pad, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
// it's already handled by the SDL backend and will be on no matter what // it's already handled by the SDL backend and will be on no matter what
// (assuming the controller supports it) // (assuming the controller supports it)
} }

28
src/input/controller.cpp
View File

@ -118,31 +118,43 @@ void GameController::Axis(int id, Input::Axis axis, int value) {
} }
void GameController::Gyro(int id, const float gyro[3]) { void GameController::Gyro(int id, const float gyro[3]) {
//LOG_DEBUG(Lib_Pad, "Gyro update: {} {} {}", gyro[0], gyro[1], gyro[2]);
std::scoped_lock lock{m_mutex}; std::scoped_lock lock{m_mutex};
auto state = GetLastState(); auto state = GetLastState();
state.time = Libraries::Kernel::sceKernelGetProcessTime(); state.time = Libraries::Kernel::sceKernelGetProcessTime();
// Update the angular velocity (gyro data) // Update the angular velocity (gyro data)
state.angularVelocity[0] = gyro[0]; // X-axis state.angularVelocity.x = gyro[0]; // X-axis
state.angularVelocity[1] = gyro[1]; // Y-axis state.angularVelocity.y = gyro[1]; // Y-axis
state.angularVelocity[2] = gyro[2]; // Z-axis state.angularVelocity.z = gyro[2]; // Z-axis
AddState(state); AddState(state);
} }
void GameController::Acceleration(int id, const float acceleration[3]) { void GameController::Acceleration(int id, const float acceleration[3]) {
//LOG_DEBUG(Lib_Pad, "Accel update: {} {} {}", acceleration[0], acceleration[1], acceleration[2]);
std::scoped_lock lock{m_mutex}; std::scoped_lock lock{m_mutex};
auto state = GetLastState(); auto state = GetLastState();
state.time = Libraries::Kernel::sceKernelGetProcessTime(); state.time = Libraries::Kernel::sceKernelGetProcessTime();
// Update the acceleration values // Update the acceleration values
state.acceleration[0] = acceleration[0]; // X-axis state.acceleration.x = acceleration[0]; // X-axis
state.acceleration[1] = acceleration[1]; // Y-axis state.acceleration.y = acceleration[1]; // Y-axis
state.acceleration[2] = acceleration[2]; // Z-axis state.acceleration.z = acceleration[2]; // Z-axis
AddState(state); AddState(state);
} }
void GameController::CalculateOrientation(Libraries::Pad::OrbisFVector3& acceleration,
Libraries::Pad::OrbisFVector3& angularVelocity,
float deltaTime,
Libraries::Pad::OrbisFQuaternion& orientation) {
float acceleration_vec_len =
sqrt(acceleration.x * acceleration.x + acceleration.y * acceleration.y +
acceleration.z * acceleration.z);
orientation.x = acceleration.x / acceleration_vec_len;
orientation.y = acceleration.y / acceleration_vec_len;
orientation.z = acceleration.z / acceleration_vec_len;
orientation.w = 0.0f;
LOG_DEBUG(Lib_Pad, "Calculated orientation: {:2f} {:2f} {:2f} {:2f}", orientation.x,
orientation.y, orientation.z, orientation.w);
}
void GameController::SetLightBarRGB(u8 r, u8 g, u8 b) { void GameController::SetLightBarRGB(u8 r, u8 g, u8 b) {
if (m_sdl_gamepad != nullptr) { if (m_sdl_gamepad != nullptr) {

10
src/input/controller.h
View File

@ -28,13 +28,15 @@ struct TouchpadEntry {
u16 y{}; u16 y{};
}; };
struct State { struct State {
Libraries::Pad::OrbisPadButtonDataOffset buttonsState{}; Libraries::Pad::OrbisPadButtonDataOffset buttonsState{};
u64 time = 0; u64 time = 0;
int axes[static_cast<int>(Axis::AxisMax)] = {128, 128, 128, 128, 0, 0}; int axes[static_cast<int>(Axis::AxisMax)] = {128, 128, 128, 128, 0, 0};
TouchpadEntry touchpad[2] = {{false, 0, 0}, {false, 0, 0}}; TouchpadEntry touchpad[2] = {{false, 0, 0}, {false, 0, 0}};
float acceleration[3] = {0.0f, 0.0f, 0.0f}; Libraries::Pad::OrbisFVector3 acceleration = {0.0f, 0.0f, 0.0f};
float angularVelocity[3] = {0.0f, 0.0f, 0.0f}; Libraries::Pad::OrbisFVector3 angularVelocity = {0.0f, 0.0f, 0.0f};
Libraries::Pad::OrbisFQuaternion orientation = {0.0f, 0.0f, 0.0f, 1.0f};
}; };
inline int GetAxis(int min, int max, int value) { inline int GetAxis(int min, int max, int value) {
@ -65,6 +67,10 @@ public:
float gyro_poll_rate; float gyro_poll_rate;
float accel_poll_rate; float accel_poll_rate;
static void CalculateOrientation(Libraries::Pad::OrbisFVector3& acceleration,
Libraries::Pad::OrbisFVector3& angularVelocity,
float deltaTime,
Libraries::Pad::OrbisFQuaternion& orientation);
private: private:
struct StateInternal { struct StateInternal {