mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-04-20 19:44:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

switched gamepad buttons and axis to event gbutton/gaxis instead and moved it to WindowSDL::waitEvent() (just testing for now)

Browse source
This commit is contained in:
raziel1000 2024-06-24 09:31:55 -06:00
parent 241c8e0077
commit 3b36fdc3d2
5 changed files with 116 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

52
src/core/libraries/pad/pad.cpp
View file

@ -252,25 +252,13 @@ int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) {
}
bool kb = (Config::getControllerType() == 0);
for (int i = 0; i < ret_num; i++) {
pData[i].buttons = kb ? states[i].buttonsState : controller->GetGamepadButtons();
pData[i].leftStick.x =
kb ? states[i].axes[static_cast<int>(Input::Axis::LeftX)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::LeftX)];
pData[i].leftStick.y =
kb ? states[i].axes[static_cast<int>(Input::Axis::LeftY)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::LeftY)];
pData[i].rightStick.x =
kb ? states[i].axes[static_cast<int>(Input::Axis::RightX)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::RightX)];
pData[i].rightStick.y =
kb ? states[i].axes[static_cast<int>(Input::Axis::RightY)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::RightY)];
pData[i].analogButtons.l2 =
kb ? states[i].axes[static_cast<int>(Input::Axis::TriggerLeft)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::TriggerLeft)];
pData[i].analogButtons.r2 =
kb ? states[i].axes[static_cast<int>(Input::Axis::TriggerRight)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::TriggerRight)];
pData[i].buttons = states[i].buttonsState;
pData[i].leftStick.x = states[i].axes[static_cast<int>(Input::Axis::LeftX)];
pData[i].leftStick.y = states[i].axes[static_cast<int>(Input::Axis::LeftY)];
pData[i].rightStick.x = states[i].axes[static_cast<int>(Input::Axis::RightX)];
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.r2 = states[i].axes[static_cast<int>(Input::Axis::TriggerRight)];
pData[i].orientation.x = 0.0f;
pData[i].orientation.y = 0.0f;
pData[i].orientation.z = 0.0f;
@ -325,25 +313,13 @@ int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) {
Input::State state;
bool kb = (Config::getControllerType() == 0);
controller->ReadState(&state, &isConnected, &connectedCount);
pData->buttons = kb ? state.buttonsState : controller->GetGamepadButtons();
pData->leftStick.x =
kb ? state.axes[static_cast<int>(Input::Axis::LeftX)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::LeftX)];
pData->leftStick.y =
kb ? state.axes[static_cast<int>(Input::Axis::LeftY)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::LeftY)];
pData->rightStick.x =
kb ? state.axes[static_cast<int>(Input::Axis::RightX)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::RightX)];
pData->rightStick.y =
kb ? state.axes[static_cast<int>(Input::Axis::RightY)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::RightY)];
pData->analogButtons.l2 =
kb ? state.axes[static_cast<int>(Input::Axis::TriggerLeft)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::TriggerLeft)];
pData->analogButtons.r2 =
kb ? state.axes[static_cast<int>(Input::Axis::TriggerRight)]
: controller->GetGamePadAxis().axes[static_cast<int>(Input::Axis::TriggerRight)];
pData->buttons = state.buttonsState;
pData->leftStick.x = state.axes[static_cast<int>(Input::Axis::LeftX)];
pData->leftStick.y = state.axes[static_cast<int>(Input::Axis::LeftY)];
pData->rightStick.x = state.axes[static_cast<int>(Input::Axis::RightX)];
pData->rightStick.y = state.axes[static_cast<int>(Input::Axis::RightY)];
pData->analogButtons.l2 = state.axes[static_cast<int>(Input::Axis::TriggerLeft)];
pData->analogButtons.r2 = state.axes[static_cast<int>(Input::Axis::TriggerRight)];
pData->orientation.x = 0;
pData->orientation.y = 0;
pData->orientation.z = 0;

62
src/input/controller.cpp
View file

@ -123,68 +123,6 @@ void GameController::InitGamePad() {
gamepad = SDL_OpenGamepad(instance_id);
}
u32 GameController::GetGamepadButtons() {
u32 buttons = 0;
if (gamepad) {
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_LEFT_STICK) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_L3)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_RIGHT_STICK) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_R3)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_START) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_OPTIONS)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_DPAD_UP) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_UP)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_DPAD_RIGHT) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_RIGHT)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_DPAD_DOWN) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_DOWN)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_DPAD_LEFT) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_LEFT)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_L1)
: 0;
buttons |= SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFT_TRIGGER)
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_L2)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_R1)
: 0;
buttons |= SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER)
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_R2)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_NORTH) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_TRIANGLE)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_EAST) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_CIRCLE)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_SOUTH) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_CROSS)
: 0;
buttons |= SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_WEST) == SDL_PRESSED
? (Libraries::Pad::OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_SQUARE)
: 0;
}
return buttons;
}
State GameController::GetGamePadAxis() {
u8 lx = static_cast<u8>((SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTX) + 32768) / 257);
u8 ly = static_cast<u8>((SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTY) + 32768) / 257);
u8 rx = static_cast<u8>((SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_RIGHTX) + 32768) / 257);
u8 ry = static_cast<u8>((SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_RIGHTY) + 32768) / 257);
u8 lt = static_cast<u8>(SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFT_TRIGGER));
u8 rt = static_cast<u8>(SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER));
return {0, 0, {lx, ly, rx, ry, lt, rt}};
}
int GameController::GetRumble(u16 smallFreq, u16 bigFreq) {
return SDL_RumbleGamepad(gamepad, smallFreq, bigFreq, -1);
}

2
src/input/controller.h
View file

@ -47,8 +47,6 @@ public:
void Axis(int id, Input::Axis axis, int value);
void InitGamePad();
u32 GetGamepadButtons();
State GetGamePadAxis();
int GetRumble(u16 smallFreq, u16 bigFreq);
private:

100
src/sdl_window.cpp
View file

@ -82,6 +82,15 @@ void WindowSDL::waitEvent() {
case SDL_EVENT_KEY_UP:
onKeyPress(&event);
break;
case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
case SDL_EVENT_GAMEPAD_BUTTON_UP: {
onGamePadPress(&event);
break;
}
case SDL_EVENT_GAMEPAD_AXIS_MOTION: {
onGamePadAxisMotion(&event);
break;
}
case SDL_EVENT_QUIT:
is_open = false;
break;
@ -247,4 +256,95 @@ void WindowSDL::onKeyPress(const SDL_Event* event) {
}
}
void WindowSDL::onGamePadPress(const SDL_Event* event) {
using Libraries::Pad::OrbisPadButtonDataOffset;
u32 button = 0;
switch (event->gbutton.button) {
case SDL_GAMEPAD_BUTTON_DPAD_UP:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_UP;
break;
case SDL_GAMEPAD_BUTTON_DPAD_DOWN:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_DOWN;
break;
case SDL_GAMEPAD_BUTTON_DPAD_LEFT:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_LEFT;
break;
case SDL_GAMEPAD_BUTTON_DPAD_RIGHT:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_RIGHT;
break;
case SDL_GAMEPAD_BUTTON_NORTH:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_TRIANGLE;
break;
case SDL_GAMEPAD_BUTTON_SOUTH:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_CROSS;
break;
case SDL_GAMEPAD_BUTTON_EAST:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_CIRCLE;
break;
case SDL_GAMEPAD_BUTTON_WEST:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_SQUARE;
break;
case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_L1;
break;
case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_R1;
break;
case SDL_GAMEPAD_BUTTON_LEFT_STICK:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_L3;
break;
case SDL_GAMEPAD_BUTTON_RIGHT_STICK:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_R3;
break;
}
if (button != 0) {
controller->CheckButton(0, button, event->type == SDL_EVENT_GAMEPAD_BUTTON_DOWN);
}
}
void WindowSDL::onGamePadAxisMotion(const SDL_Event* event) {
using Libraries::Pad::OrbisPadButtonDataOffset;
u32 button = 0;
Input::Axis axis = Input::Axis::AxisMax;
int ax = 0;
switch (event->gaxis.axis) {
case SDL_GAMEPAD_AXIS_LEFTX:
axis = Input::Axis::LeftX;
ax = ((event->gaxis.value + 32768) / 257);
break;
case SDL_GAMEPAD_AXIS_LEFTY:
axis = Input::Axis::LeftY;
ax = ((event->gaxis.value + 32768) / 257);
break;
case SDL_GAMEPAD_AXIS_RIGHTX:
axis = Input::Axis::RightX;
ax = ((event->gaxis.value + 32768) / 257);
break;
case SDL_GAMEPAD_AXIS_RIGHTY:
axis = Input::Axis::RightY;
ax = ((event->gaxis.value + 32768) / 257);
break;
case SDL_GAMEPAD_AXIS_LEFT_TRIGGER:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_L2;
axis = Input::Axis::TriggerLeft;
ax = ((event->gaxis.value + 32768) / 257);
break;
case SDL_GAMEPAD_AXIS_RIGHT_TRIGGER:
button = OrbisPadButtonDataOffset::ORBIS_PAD_BUTTON_L2;
axis = Input::Axis::TriggerRight;
ax = ((event->gaxis.value + 32768) / 257);
break;
}
if (axis != Input::Axis::AxisMax) {
controller->Axis(0, axis, ax);
}
if (button != 0) {
controller->CheckButton(0, button, event->type == SDL_EVENT_GAMEPAD_AXIS_MOTION);
}
}
} // namespace Frontend

2
src/sdl_window.h
View file

@ -63,6 +63,8 @@ public:
private:
void onResize();
void onKeyPress(const SDL_Event* event);
void onGamePadPress(const SDL_Event* event);
void onGamePadAxisMotion(const SDL_Event* event);
private:
s32 width;