|
|
@@ -47,34 +47,190 @@
|
|
|
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
#include "../../core/windows/SDL_windows.h"
|
|
|
+typedef struct WindowsGamingInputGamepadState WindowsGamingInputGamepadState;
|
|
|
+#define GamepadButtons_GUIDE 0x40000000
|
|
|
#define COBJMACROS
|
|
|
#include "windows.gaming.input.h"
|
|
|
#endif
|
|
|
|
|
|
+#if defined(SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT) || defined(SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT)
|
|
|
+#define SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+#endif
|
|
|
|
|
|
typedef struct {
|
|
|
Uint8 last_state[USB_PACKET_LENGTH];
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+ Uint32 match_state; /* Low 16 bits for button states, high 16 for 4 4bit axes */
|
|
|
+ Uint32 last_state_packet;
|
|
|
+#endif
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
SDL_bool xinput_enabled;
|
|
|
+ SDL_bool xinput_correlated;
|
|
|
+ Uint8 xinput_correlation_id;
|
|
|
+ Uint8 xinput_correlation_count;
|
|
|
+ Uint8 xinput_uncorrelate_count;
|
|
|
Uint8 xinput_slot;
|
|
|
#endif
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
- SDL_bool coinitialized;
|
|
|
- __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics *gamepad_statics;
|
|
|
- __x_ABI_CWindows_CGaming_CInput_CIGamepad *gamepad;
|
|
|
- struct __x_ABI_CWindows_CGaming_CInput_CGamepadVibration vibration;
|
|
|
+ SDL_bool wgi_correlated;
|
|
|
+ Uint8 wgi_correlation_id;
|
|
|
+ Uint8 wgi_correlation_count;
|
|
|
+ Uint8 wgi_uncorrelate_count;
|
|
|
+ WindowsGamingInputGamepadState *wgi_slot;
|
|
|
#endif
|
|
|
} SDL_DriverXbox360_Context;
|
|
|
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+static struct {
|
|
|
+ Uint32 last_state_packet;
|
|
|
+ SDL_Joystick *joystick;
|
|
|
+ SDL_Joystick *last_joystick;
|
|
|
+} guide_button_candidate;
|
|
|
+
|
|
|
+typedef struct WindowsMatchState {
|
|
|
+ SHORT match_axes[4];
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
+ WORD xinput_buttons;
|
|
|
+#endif
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
+ Uint32 wgi_buttons;
|
|
|
+#endif
|
|
|
+ SDL_bool any_data;
|
|
|
+} WindowsMatchState;
|
|
|
+
|
|
|
+static void HIDAPI_DriverXbox360_FillMatchState(WindowsMatchState *state, Uint32 match_state)
|
|
|
+{
|
|
|
+ int ii;
|
|
|
+ state->any_data = SDL_FALSE;
|
|
|
+ /* SHORT state->match_axes[4] = {
|
|
|
+ (match_state & 0x000F0000) >> 4,
|
|
|
+ (match_state & 0x00F00000) >> 8,
|
|
|
+ (match_state & 0x0F000000) >> 12,
|
|
|
+ (match_state & 0xF0000000) >> 16,
|
|
|
+ }; */
|
|
|
+ for (ii = 0; ii < 4; ii++) {
|
|
|
+ state->match_axes[ii] = (match_state & (0x000F0000 << (ii * 4))) >> (4 + ii * 4);
|
|
|
+ if ((Uint32)(state->match_axes[ii] + 0x1000) > 0x2000) { /* match_state bit is not 0xF, 0x1, or 0x2 */
|
|
|
+ state->any_data = SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
+ /* Match axes by checking if the distance between the high 4 bits of axis and the 4 bits from match_state is 1 or less */
|
|
|
+#define XInputAxesMatch(gamepad) (\
|
|
|
+ (Uint32)(gamepad.sThumbLX - state->match_axes[0] + 0x1000) <= 0x2fff && \
|
|
|
+ (Uint32)(~gamepad.sThumbLY - state->match_axes[1] + 0x1000) <= 0x2fff && \
|
|
|
+ (Uint32)(gamepad.sThumbRX - state->match_axes[2] + 0x1000) <= 0x2fff && \
|
|
|
+ (Uint32)(~gamepad.sThumbRY - state->match_axes[3] + 0x1000) <= 0x2fff)
|
|
|
+ /* Explicit
|
|
|
+#define XInputAxesMatch(gamepad) (\
|
|
|
+ SDL_abs((Sint8)((gamepad.sThumbLX & 0xF000) >> 8) - ((match_state & 0x000F0000) >> 12)) <= 0x10 && \
|
|
|
+ SDL_abs((Sint8)((~gamepad.sThumbLY & 0xF000) >> 8) - ((match_state & 0x00F00000) >> 16)) <= 0x10 && \
|
|
|
+ SDL_abs((Sint8)((gamepad.sThumbRX & 0xF000) >> 8) - ((match_state & 0x0F000000) >> 20)) <= 0x10 && \
|
|
|
+ SDL_abs((Sint8)((~gamepad.sThumbRY & 0xF000) >> 8) - ((match_state & 0xF0000000) >> 24)) <= 0x10) */
|
|
|
+
|
|
|
+
|
|
|
+ state->xinput_buttons =
|
|
|
+ /* Bitwise map .RLDUWVQTS.KYXBA -> YXBA..WVQTKSRLDU */
|
|
|
+ match_state << 12 | (match_state & 0x0780) >> 1 | (match_state & 0x0010) << 1 | (match_state & 0x0040) >> 2 | (match_state & 0x7800) >> 11;
|
|
|
+ /* Explicit
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_A)) ? XINPUT_GAMEPAD_A : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_B)) ? XINPUT_GAMEPAD_B : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_X)) ? XINPUT_GAMEPAD_X : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_Y)) ? XINPUT_GAMEPAD_Y : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_BACK)) ? XINPUT_GAMEPAD_BACK : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_START)) ? XINPUT_GAMEPAD_START : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_LEFTSTICK)) ? XINPUT_GAMEPAD_LEFT_THUMB : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_RIGHTSTICK)) ? XINPUT_GAMEPAD_RIGHT_THUMB: 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_LEFTSHOULDER)) ? XINPUT_GAMEPAD_LEFT_SHOULDER : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_RIGHTSHOULDER)) ? XINPUT_GAMEPAD_RIGHT_SHOULDER : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_UP)) ? XINPUT_GAMEPAD_DPAD_UP : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_DOWN)) ? XINPUT_GAMEPAD_DPAD_DOWN : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_LEFT)) ? XINPUT_GAMEPAD_DPAD_LEFT : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_RIGHT)) ? XINPUT_GAMEPAD_DPAD_RIGHT : 0);
|
|
|
+ */
|
|
|
+
|
|
|
+ if (state->xinput_buttons)
|
|
|
+ state->any_data = SDL_TRUE;
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
+ /* Match axes by checking if the distance between the high 4 bits of axis and the 4 bits from match_state is 1 or less */
|
|
|
+#define WindowsGamingInputAxesMatch(gamepad) (\
|
|
|
+ (Uint16)(((Sint16)(gamepad.LeftThumbstickX * SDL_MAX_SINT16) & 0xF000) - state->match_axes[0] + 0x1000) <= 0x2fff && \
|
|
|
+ (Uint16)((~(Sint16)(gamepad.LeftThumbstickY * SDL_MAX_SINT16) & 0xF000) - state->match_axes[1] + 0x1000) <= 0x2fff && \
|
|
|
+ (Uint16)(((Sint16)(gamepad.RightThumbstickX * SDL_MAX_SINT16) & 0xF000) - state->match_axes[2] + 0x1000) <= 0x2fff && \
|
|
|
+ (Uint16)((~(Sint16)(gamepad.RightThumbstickY * SDL_MAX_SINT16) & 0xF000) - state->match_axes[3] + 0x1000) <= 0x2fff)
|
|
|
+
|
|
|
+
|
|
|
+ state->wgi_buttons =
|
|
|
+ /* Bitwise map .RLD UWVQ TS.K YXBA -> ..QT WVRL DUYX BAKS */
|
|
|
+ /* RStick/LStick (QT) RShould/LShould (WV) DPad R/L/D/U YXBA bac(K) (S)tart */
|
|
|
+ (match_state & 0x0180) << 5 | (match_state & 0x0600) << 1 | (match_state & 0x7800) >> 5 | (match_state & 0x000F) << 2 | (match_state & 0x0010) >> 3 | (match_state & 0x0040) >> 6;
|
|
|
+ /* Explicit
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_A)) ? GamepadButtons_A : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_B)) ? GamepadButtons_B : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_X)) ? GamepadButtons_X : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_Y)) ? GamepadButtons_Y : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_BACK)) ? GamepadButtons_View : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_START)) ? GamepadButtons_Menu : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_LEFTSTICK)) ? GamepadButtons_LeftThumbstick : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_RIGHTSTICK)) ? GamepadButtons_RightThumbstick: 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_LEFTSHOULDER)) ? GamepadButtons_LeftShoulder: 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_RIGHTSHOULDER)) ? GamepadButtons_RightShoulder: 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_UP)) ? GamepadButtons_DPadUp : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_DOWN)) ? GamepadButtons_DPadDown : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_LEFT)) ? GamepadButtons_DPadLeft : 0) |
|
|
|
+ ((match_state & (1<<SDL_CONTROLLER_BUTTON_DPAD_RIGHT)) ? GamepadButtons_DPadRight : 0); */
|
|
|
+
|
|
|
+ if (state->wgi_buttons)
|
|
|
+ state->any_data = SDL_TRUE;
|
|
|
+#endif
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+#endif
|
|
|
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
-static Uint8 xinput_slots;
|
|
|
+static struct {
|
|
|
+ XINPUT_STATE_EX state;
|
|
|
+ SDL_bool connected; /* Currently has an active XInput device */
|
|
|
+ SDL_bool used; /* Is currently mapped to an SDL device */
|
|
|
+ Uint8 correlation_id;
|
|
|
+} xinput_state[XUSER_MAX_COUNT];
|
|
|
+static SDL_bool xinput_device_change = SDL_TRUE;
|
|
|
+static SDL_bool xinput_state_dirty = SDL_TRUE;
|
|
|
+
|
|
|
+static void
|
|
|
+HIDAPI_DriverXbox360_UpdateXInput()
|
|
|
+{
|
|
|
+ DWORD user_index;
|
|
|
+ if (xinput_device_change) {
|
|
|
+ for (user_index = 0; user_index < XUSER_MAX_COUNT; user_index++) {
|
|
|
+ XINPUT_CAPABILITIES capabilities;
|
|
|
+ xinput_state[user_index].connected = XINPUTGETCAPABILITIES(user_index, XINPUT_FLAG_GAMEPAD, &capabilities) == ERROR_SUCCESS;
|
|
|
+ }
|
|
|
+ xinput_device_change = SDL_FALSE;
|
|
|
+ xinput_state_dirty = SDL_TRUE;
|
|
|
+ }
|
|
|
+ if (xinput_state_dirty) {
|
|
|
+ xinput_state_dirty = SDL_FALSE;
|
|
|
+ for (user_index = 0; user_index < SDL_arraysize(xinput_state); ++user_index) {
|
|
|
+ if (xinput_state[user_index].connected) {
|
|
|
+ if (!XINPUTGETSTATE(user_index, &xinput_state[user_index].state) == ERROR_SUCCESS) {
|
|
|
+ xinput_state[user_index].connected = SDL_FALSE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
|
|
|
static void
|
|
|
HIDAPI_DriverXbox360_MarkXInputSlotUsed(Uint8 xinput_slot)
|
|
|
{
|
|
|
if (xinput_slot != XUSER_INDEX_ANY) {
|
|
|
- xinput_slots |= (0x01 << xinput_slot);
|
|
|
+ xinput_state[xinput_slot].used = SDL_TRUE;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -82,58 +238,209 @@ static void
|
|
|
HIDAPI_DriverXbox360_MarkXInputSlotFree(Uint8 xinput_slot)
|
|
|
{
|
|
|
if (xinput_slot != XUSER_INDEX_ANY) {
|
|
|
- xinput_slots &= ~(0x01 << xinput_slot);
|
|
|
+ xinput_state[xinput_slot].used = SDL_FALSE;
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
static SDL_bool
|
|
|
HIDAPI_DriverXbox360_MissingXInputSlot()
|
|
|
{
|
|
|
- return xinput_slots != 0x0F;
|
|
|
+ int ii;
|
|
|
+ for (ii = 0; ii < SDL_arraysize(xinput_state); ii++) {
|
|
|
+ if (xinput_state[ii].connected && !xinput_state[ii].used) {
|
|
|
+ return SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return SDL_FALSE;
|
|
|
}
|
|
|
|
|
|
-static Uint8
|
|
|
-HIDAPI_DriverXbox360_GuessXInputSlot(WORD wButtons)
|
|
|
+static SDL_bool
|
|
|
+HIDAPI_DriverXbox360_XInputSlotMatches(const WindowsMatchState *state, Uint8 slot_idx)
|
|
|
{
|
|
|
- DWORD user_index;
|
|
|
- int match_count;
|
|
|
- Uint8 match_slot;
|
|
|
-
|
|
|
- if (!XINPUTGETSTATE) {
|
|
|
- return XUSER_INDEX_ANY;
|
|
|
+ if (xinput_state[slot_idx].connected) {
|
|
|
+ WORD xinput_buttons = xinput_state[slot_idx].state.Gamepad.wButtons;
|
|
|
+ if ((xinput_buttons & ~XINPUT_GAMEPAD_GUIDE) == state->xinput_buttons && XInputAxesMatch(xinput_state[slot_idx].state.Gamepad)) {
|
|
|
+ return SDL_TRUE;
|
|
|
+ }
|
|
|
}
|
|
|
+ return SDL_FALSE;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+static SDL_bool
|
|
|
+HIDAPI_DriverXbox360_GuessXInputSlot(const WindowsMatchState *state, Uint8 *correlation_id, Uint8 *slot_idx)
|
|
|
+{
|
|
|
+ int user_index;
|
|
|
+ int match_count;
|
|
|
|
|
|
match_count = 0;
|
|
|
for (user_index = 0; user_index < XUSER_MAX_COUNT; ++user_index) {
|
|
|
- XINPUT_STATE_EX xinput_state;
|
|
|
-
|
|
|
- if (XINPUTGETSTATE(user_index, &xinput_state) == ERROR_SUCCESS) {
|
|
|
- if (xinput_state.Gamepad.wButtons == wButtons) {
|
|
|
- ++match_count;
|
|
|
- match_slot = (Uint8)user_index;
|
|
|
- }
|
|
|
+ if (!xinput_state[user_index].used && HIDAPI_DriverXbox360_XInputSlotMatches(state, user_index)) {
|
|
|
+ ++match_count;
|
|
|
+ *slot_idx = (Uint8)user_index;
|
|
|
+ /* Incrementing correlation_id for any match, as negative evidence for others being correlated */
|
|
|
+ *correlation_id = ++xinput_state[user_index].correlation_id;
|
|
|
}
|
|
|
}
|
|
|
- if (match_count == 1) {
|
|
|
- return match_slot;
|
|
|
+ /* Only return a match if we match exactly one, and we have some non-zero data (buttons or axes) that matched.
|
|
|
+ Note that we're still invalidating *other* potential correlations if we have more than one match or we have no
|
|
|
+ data. */
|
|
|
+ if (match_count == 1 && state->any_data) {
|
|
|
+ return SDL_TRUE;
|
|
|
}
|
|
|
- return XUSER_INDEX_ANY;
|
|
|
+ return SDL_FALSE;
|
|
|
}
|
|
|
|
|
|
#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT */
|
|
|
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
|
|
|
+typedef struct WindowsGamingInputGamepadState {
|
|
|
+ __x_ABI_CWindows_CGaming_CInput_CIGamepad *gamepad;
|
|
|
+ struct __x_ABI_CWindows_CGaming_CInput_CGamepadReading state;
|
|
|
+ SDL_DriverXbox360_Context *correlated_context;
|
|
|
+ SDL_bool used; /* Is currently mapped to an SDL device */
|
|
|
+ SDL_bool connected; /* Just used during update to track disconnected */
|
|
|
+ Uint8 correlation_id;
|
|
|
+ struct __x_ABI_CWindows_CGaming_CInput_CGamepadVibration vibration;
|
|
|
+} WindowsGamingInputGamepadState;
|
|
|
+
|
|
|
+static struct {
|
|
|
+ WindowsGamingInputGamepadState **per_gamepad;
|
|
|
+ int per_gamepad_count;
|
|
|
+ SDL_bool initialized;
|
|
|
+ SDL_bool dirty;
|
|
|
+ SDL_bool need_device_list_update;
|
|
|
+ int ref_count;
|
|
|
+ __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics *gamepad_statics;
|
|
|
+} wgi_state;
|
|
|
+
|
|
|
static void
|
|
|
-HIDAPI_DriverXbox360_InitWindowsGamingInput(SDL_DriverXbox360_Context *ctx)
|
|
|
+HIDAPI_DriverXbox360_MarkWindowsGamingInputSlotUsed(WindowsGamingInputGamepadState *wgi_slot, SDL_DriverXbox360_Context *ctx)
|
|
|
+{
|
|
|
+ wgi_slot->used = SDL_TRUE;
|
|
|
+ wgi_slot->correlated_context = ctx;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+HIDAPI_DriverXbox360_MarkWindowsGamingInputSlotFree(WindowsGamingInputGamepadState *wgi_slot)
|
|
|
+{
|
|
|
+ wgi_slot->used = SDL_FALSE;
|
|
|
+ wgi_slot->correlated_context = NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static SDL_bool
|
|
|
+HIDAPI_DriverXbox360_MissingWindowsGamingInputSlot()
|
|
|
+{
|
|
|
+ int ii;
|
|
|
+ for (ii = 0; ii < wgi_state.per_gamepad_count; ii++) {
|
|
|
+ if (!wgi_state.per_gamepad[ii]->used) {
|
|
|
+ return SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return SDL_FALSE;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+HIDAPI_DriverXbox360_UpdateWindowsGamingInput()
|
|
|
{
|
|
|
- /* I think this takes care of RoInitialize() in a way that is compatible with the rest of SDL */
|
|
|
- if (FAILED(WIN_CoInitialize())) {
|
|
|
+ int ii;
|
|
|
+ if (!wgi_state.gamepad_statics)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!wgi_state.dirty)
|
|
|
return;
|
|
|
+ wgi_state.dirty = SDL_FALSE;
|
|
|
+
|
|
|
+ if (wgi_state.need_device_list_update) {
|
|
|
+ wgi_state.need_device_list_update = SDL_FALSE;
|
|
|
+ for (ii = 0; ii < wgi_state.per_gamepad_count; ii++) {
|
|
|
+ wgi_state.per_gamepad[ii]->connected = SDL_FALSE;
|
|
|
+ }
|
|
|
+ HRESULT hr;
|
|
|
+ __FIVectorView_1_Windows__CGaming__CInput__CGamepad *gamepads;
|
|
|
+
|
|
|
+ hr = __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_get_Gamepads(wgi_state.gamepad_statics, &gamepads);
|
|
|
+ if (SUCCEEDED(hr)) {
|
|
|
+ unsigned int num_gamepads;
|
|
|
+
|
|
|
+ hr = __FIVectorView_1_Windows__CGaming__CInput__CGamepad_get_Size(gamepads, &num_gamepads);
|
|
|
+ if (SUCCEEDED(hr)) {
|
|
|
+ unsigned int i;
|
|
|
+ for (i = 0; i < num_gamepads; ++i) {
|
|
|
+ __x_ABI_CWindows_CGaming_CInput_CIGamepad *gamepad;
|
|
|
+
|
|
|
+ hr = __FIVectorView_1_Windows__CGaming__CInput__CGamepad_GetAt(gamepads, i, &gamepad);
|
|
|
+ if (SUCCEEDED(hr)) {
|
|
|
+ SDL_bool found = SDL_FALSE;
|
|
|
+ int jj;
|
|
|
+ for (jj = 0; jj < wgi_state.per_gamepad_count ; jj++) {
|
|
|
+ if (wgi_state.per_gamepad[jj]->gamepad == gamepad) {
|
|
|
+ found = SDL_TRUE;
|
|
|
+ wgi_state.per_gamepad[jj]->connected = SDL_TRUE;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!found) {
|
|
|
+ /* New device, add it */
|
|
|
+ wgi_state.per_gamepad_count++;
|
|
|
+ wgi_state.per_gamepad = SDL_realloc(wgi_state.per_gamepad, sizeof(wgi_state.per_gamepad[0]) * wgi_state.per_gamepad_count);
|
|
|
+ if (!wgi_state.per_gamepad) {
|
|
|
+ SDL_OutOfMemory();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ WindowsGamingInputGamepadState *gamepad_state = SDL_calloc(1, sizeof(*gamepad_state));
|
|
|
+ if (!gamepad_state) {
|
|
|
+ SDL_OutOfMemory();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ wgi_state.per_gamepad[wgi_state.per_gamepad_count - 1] = gamepad_state;
|
|
|
+ gamepad_state->gamepad = gamepad;
|
|
|
+ gamepad_state->connected = SDL_TRUE;
|
|
|
+ } else {
|
|
|
+ /* Already tracked */
|
|
|
+ __x_ABI_CWindows_CGaming_CInput_CIGamepad_Release(gamepad);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (ii = wgi_state.per_gamepad_count - 1; ii >= 0; ii--) {
|
|
|
+ WindowsGamingInputGamepadState *gamepad_state = wgi_state.per_gamepad[ii];
|
|
|
+ if (!gamepad_state->connected) {
|
|
|
+ /* Device missing, must be disconnected */
|
|
|
+ if (gamepad_state->correlated_context) {
|
|
|
+ gamepad_state->correlated_context->wgi_correlated = SDL_FALSE;
|
|
|
+ gamepad_state->correlated_context->wgi_slot = NULL;
|
|
|
+ }
|
|
|
+ __x_ABI_CWindows_CGaming_CInput_CIGamepad_Release(gamepad_state->gamepad);
|
|
|
+ SDL_free(gamepad_state);
|
|
|
+ wgi_state.per_gamepad[ii] = wgi_state.per_gamepad[wgi_state.per_gamepad_count - 1];
|
|
|
+ --wgi_state.per_gamepad_count;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ __FIVectorView_1_Windows__CGaming__CInput__CGamepad_Release(gamepads);
|
|
|
+ }
|
|
|
+ } /* need_device_list_update */
|
|
|
+
|
|
|
+ for (ii = 0; ii < wgi_state.per_gamepad_count; ii++) {
|
|
|
+ HRESULT hr = __x_ABI_CWindows_CGaming_CInput_CIGamepad_GetCurrentReading(wgi_state.per_gamepad[ii]->gamepad, &wgi_state.per_gamepad[ii]->state);
|
|
|
+ if (!SUCCEEDED(hr)) {
|
|
|
+ wgi_state.per_gamepad[ii]->connected = SDL_FALSE; /* Not used by anything, currently */
|
|
|
+ }
|
|
|
}
|
|
|
- ctx->coinitialized = SDL_TRUE;
|
|
|
+}
|
|
|
+static void
|
|
|
+HIDAPI_DriverXbox360_InitWindowsGamingInput(SDL_DriverXbox360_Context *ctx)
|
|
|
+{
|
|
|
+ wgi_state.need_device_list_update = SDL_TRUE;
|
|
|
+ wgi_state.ref_count++;
|
|
|
+ if (!wgi_state.initialized) {
|
|
|
+ /* I think this takes care of RoInitialize() in a way that is compatible with the rest of SDL */
|
|
|
+ if (FAILED(WIN_CoInitialize())) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ wgi_state.initialized = SDL_TRUE;
|
|
|
+ wgi_state.dirty = SDL_TRUE;
|
|
|
|
|
|
- {
|
|
|
static const IID SDL_IID_IGamepadStatics = { 0x8BBCE529, 0xD49C, 0x39E9, { 0x95, 0x60, 0xE4, 0x7D, 0xDE, 0x96, 0xB7, 0xC8 } };
|
|
|
HRESULT hr;
|
|
|
HMODULE hModule = LoadLibraryA("combase.dll");
|
|
|
@@ -151,7 +458,7 @@ HIDAPI_DriverXbox360_InitWindowsGamingInput(SDL_DriverXbox360_Context *ctx)
|
|
|
|
|
|
hr = WindowsCreateStringFunc(pNamespace, SDL_wcslen(pNamespace), &hNamespaceString);
|
|
|
if (SUCCEEDED(hr)) {
|
|
|
- RoGetActivationFactoryFunc(hNamespaceString, &SDL_IID_IGamepadStatics, &ctx->gamepad_statics);
|
|
|
+ RoGetActivationFactoryFunc(hNamespaceString, &SDL_IID_IGamepadStatics, &wgi_state.gamepad_statics);
|
|
|
WindowsDeleteStringFunc(hNamespaceString);
|
|
|
}
|
|
|
}
|
|
|
@@ -160,90 +467,112 @@ HIDAPI_DriverXbox360_InitWindowsGamingInput(SDL_DriverXbox360_Context *ctx)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-static Uint8
|
|
|
-HIDAPI_DriverXbox360_GetGamepadButtonsForMatch(__x_ABI_CWindows_CGaming_CInput_CIGamepad *gamepad)
|
|
|
+static SDL_bool
|
|
|
+HIDAPI_DriverXbox360_WindowsGamingInputSlotMatches(const WindowsMatchState *state, WindowsGamingInputGamepadState *slot)
|
|
|
{
|
|
|
- HRESULT hr;
|
|
|
- struct __x_ABI_CWindows_CGaming_CInput_CGamepadReading state;
|
|
|
- Uint8 buttons = 0;
|
|
|
+ Uint32 wgi_buttons = slot->state.Buttons;
|
|
|
+ if ((wgi_buttons & 0x3FFF) == state->wgi_buttons && WindowsGamingInputAxesMatch(slot->state)) {
|
|
|
+ return SDL_TRUE;
|
|
|
+ }
|
|
|
+ return SDL_FALSE;
|
|
|
+}
|
|
|
+
|
|
|
+static SDL_bool
|
|
|
+HIDAPI_DriverXbox360_GuessWindowsGamingInputSlot(const WindowsMatchState *state, Uint8 *correlation_id, WindowsGamingInputGamepadState **slot)
|
|
|
+{
|
|
|
+ int match_count;
|
|
|
|
|
|
- hr = __x_ABI_CWindows_CGaming_CInput_CIGamepad_GetCurrentReading(gamepad, &state);
|
|
|
- if (SUCCEEDED(hr)) {
|
|
|
- if (state.Buttons & GamepadButtons_A) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_A);
|
|
|
+ match_count = 0;
|
|
|
+ for (int user_index = 0; user_index < wgi_state.per_gamepad_count; ++user_index) {
|
|
|
+ WindowsGamingInputGamepadState *gamepad_state = wgi_state.per_gamepad[user_index];
|
|
|
+ if (HIDAPI_DriverXbox360_WindowsGamingInputSlotMatches(state, gamepad_state)) {
|
|
|
+ ++match_count;
|
|
|
+ *slot = gamepad_state;
|
|
|
+ /* Incrementing correlation_id for any match, as negative evidence for others being correlated */
|
|
|
+ *correlation_id = ++gamepad_state->correlation_id;
|
|
|
}
|
|
|
- if (state.Buttons & GamepadButtons_B) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_B);
|
|
|
+ }
|
|
|
+ /* Only return a match if we match exactly one, and we have some non-zero data (buttons or axes) that matched.
|
|
|
+ Note that we're still invalidating *other* potential correlations if we have more than one match or we have no
|
|
|
+ data. */
|
|
|
+ if (match_count == 1 && state->any_data) {
|
|
|
+ return SDL_TRUE;
|
|
|
+ }
|
|
|
+ return SDL_FALSE;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+HIDAPI_DriverXbox360_QuitWindowsGamingInput(SDL_DriverXbox360_Context *ctx)
|
|
|
+{
|
|
|
+ wgi_state.need_device_list_update = SDL_TRUE;
|
|
|
+ --wgi_state.ref_count;
|
|
|
+ if (!wgi_state.ref_count && wgi_state.initialized) {
|
|
|
+ for (int ii = 0; ii < wgi_state.per_gamepad_count; ii++) {
|
|
|
+ __x_ABI_CWindows_CGaming_CInput_CIGamepad_Release(wgi_state.per_gamepad[ii]->gamepad);
|
|
|
}
|
|
|
- if (state.Buttons & GamepadButtons_X) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_X);
|
|
|
+ if (wgi_state.per_gamepad) {
|
|
|
+ SDL_free(wgi_state.per_gamepad);
|
|
|
+ wgi_state.per_gamepad = NULL;
|
|
|
}
|
|
|
- if (state.Buttons & GamepadButtons_Y) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_Y);
|
|
|
+ wgi_state.per_gamepad_count = 0;
|
|
|
+ if (wgi_state.gamepad_statics) {
|
|
|
+ __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_Release(wgi_state.gamepad_statics);
|
|
|
+ wgi_state.gamepad_statics = NULL;
|
|
|
}
|
|
|
+ WIN_CoUninitialize();
|
|
|
+ wgi_state.initialized = SDL_FALSE;
|
|
|
}
|
|
|
- return buttons;
|
|
|
}
|
|
|
|
|
|
+#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT */
|
|
|
+
|
|
|
static void
|
|
|
-HIDAPI_DriverXbox360_GuessGamepad(SDL_DriverXbox360_Context *ctx, Uint8 buttons)
|
|
|
+HIDAPI_DriverXbox360_PostUpdate(void)
|
|
|
{
|
|
|
- HRESULT hr;
|
|
|
- __FIVectorView_1_Windows__CGaming__CInput__CGamepad *gamepads;
|
|
|
-
|
|
|
- hr = __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_get_Gamepads(ctx->gamepad_statics, &gamepads);
|
|
|
- if (SUCCEEDED(hr)) {
|
|
|
- unsigned int i, num_gamepads;
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+ SDL_bool unmapped_guide_pressed = SDL_FALSE;
|
|
|
|
|
|
- hr = __FIVectorView_1_Windows__CGaming__CInput__CGamepad_get_Size(gamepads, &num_gamepads);
|
|
|
- if (SUCCEEDED(hr)) {
|
|
|
- int match_count;
|
|
|
- unsigned int match_slot;
|
|
|
-
|
|
|
- match_count = 0;
|
|
|
- for (i = 0; i < num_gamepads; ++i) {
|
|
|
- __x_ABI_CWindows_CGaming_CInput_CIGamepad *gamepad;
|
|
|
-
|
|
|
- hr = __FIVectorView_1_Windows__CGaming__CInput__CGamepad_GetAt(gamepads, i, &gamepad);
|
|
|
- if (SUCCEEDED(hr)) {
|
|
|
- Uint8 gamepad_buttons = HIDAPI_DriverXbox360_GetGamepadButtonsForMatch(gamepad);
|
|
|
- if (buttons == gamepad_buttons) {
|
|
|
- ++match_count;
|
|
|
- match_slot = i;
|
|
|
- }
|
|
|
- __x_ABI_CWindows_CGaming_CInput_CIGamepad_Release(gamepad);
|
|
|
- }
|
|
|
- }
|
|
|
- if (match_count == 1) {
|
|
|
- hr = __FIVectorView_1_Windows__CGaming__CInput__CGamepad_GetAt(gamepads, match_slot, &ctx->gamepad);
|
|
|
- if (SUCCEEDED(hr)) {
|
|
|
- }
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
+ if (!wgi_state.dirty) {
|
|
|
+ int ii;
|
|
|
+ for (ii = 0; ii < wgi_state.per_gamepad_count; ii++) {
|
|
|
+ WindowsGamingInputGamepadState *gamepad_state = wgi_state.per_gamepad[ii];
|
|
|
+ if (!gamepad_state->used && (gamepad_state->state.Buttons & GamepadButtons_GUIDE)) {
|
|
|
+ unmapped_guide_pressed = SDL_TRUE;
|
|
|
+ break;
|
|
|
}
|
|
|
}
|
|
|
- __FIVectorView_1_Windows__CGaming__CInput__CGamepad_Release(gamepads);
|
|
|
}
|
|
|
-}
|
|
|
+ wgi_state.dirty = SDL_TRUE;
|
|
|
+#endif
|
|
|
|
|
|
-static void
|
|
|
-HIDAPI_DriverXbox360_QuitWindowsGamingInput(SDL_DriverXbox360_Context *ctx)
|
|
|
-{
|
|
|
- if (ctx->gamepad_statics) {
|
|
|
- __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_Release(ctx->gamepad_statics);
|
|
|
- ctx->gamepad_statics = NULL;
|
|
|
- }
|
|
|
- if (ctx->gamepad) {
|
|
|
- __x_ABI_CWindows_CGaming_CInput_CIGamepad_Release(ctx->gamepad);
|
|
|
- ctx->gamepad = NULL;
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
+ if (!xinput_state_dirty) {
|
|
|
+ int ii;
|
|
|
+ for (ii = 0; ii < SDL_arraysize(xinput_state); ii++) {
|
|
|
+ if (xinput_state[ii].connected && !xinput_state[ii].used && (xinput_state[ii].state.Gamepad.wButtons & XINPUT_GAMEPAD_GUIDE)) {
|
|
|
+ unmapped_guide_pressed = SDL_TRUE;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
+ xinput_state_dirty = SDL_TRUE;
|
|
|
+#endif
|
|
|
|
|
|
- if (ctx->coinitialized) {
|
|
|
- WIN_CoUninitialize();
|
|
|
- ctx->coinitialized = SDL_FALSE;
|
|
|
+ if (unmapped_guide_pressed) {
|
|
|
+ if (guide_button_candidate.joystick && !guide_button_candidate.last_joystick) {
|
|
|
+ SDL_PrivateJoystickButton(guide_button_candidate.joystick, SDL_CONTROLLER_BUTTON_GUIDE, SDL_PRESSED);
|
|
|
+ guide_button_candidate.last_joystick = guide_button_candidate.joystick;
|
|
|
+ }
|
|
|
+ } else if (guide_button_candidate.last_joystick) {
|
|
|
+ SDL_PrivateJoystickButton(guide_button_candidate.last_joystick, SDL_CONTROLLER_BUTTON_GUIDE, SDL_RELEASED);
|
|
|
+ guide_button_candidate.last_joystick = NULL;
|
|
|
}
|
|
|
+ guide_button_candidate.joystick = NULL;
|
|
|
+#endif
|
|
|
}
|
|
|
|
|
|
-#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT */
|
|
|
-
|
|
|
#if defined(__MACOSX__)
|
|
|
static SDL_bool
|
|
|
IsBluetoothXboxOneController(Uint16 vendor_id, Uint16 product_id)
|
|
|
@@ -320,7 +649,7 @@ static SDL_bool SetSlotLED(hid_device *dev, Uint8 slot)
|
|
|
static SDL_bool
|
|
|
HIDAPI_DriverXbox360_InitDevice(SDL_HIDAPI_Device *device)
|
|
|
{
|
|
|
- return HIDAPI_JoystickConnected(device, NULL);
|
|
|
+ return HIDAPI_JoystickConnected(device, NULL, SDL_FALSE);
|
|
|
}
|
|
|
|
|
|
static int
|
|
|
@@ -349,17 +678,20 @@ HIDAPI_DriverXbox360_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joyst
|
|
|
return SDL_FALSE;
|
|
|
}
|
|
|
|
|
|
- device->dev = hid_open_path(device->path, 0);
|
|
|
- if (!device->dev) {
|
|
|
- SDL_free(ctx);
|
|
|
- SDL_SetError("Couldn't open %s", device->path);
|
|
|
- return SDL_FALSE;
|
|
|
+ if (device->path) { /* else opened for RAWINPUT driver */
|
|
|
+ device->dev = hid_open_path(device->path, 0);
|
|
|
+ if (!device->dev) {
|
|
|
+ SDL_SetError("Couldn't open %s", device->path);
|
|
|
+ SDL_free(ctx);
|
|
|
+ return SDL_FALSE;
|
|
|
+ }
|
|
|
}
|
|
|
device->context = ctx;
|
|
|
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
- ctx->xinput_enabled = SDL_GetHintBoolean(SDL_HINT_XINPUT_ENABLED, SDL_TRUE);
|
|
|
- if (ctx->xinput_enabled && WIN_LoadXInputDLL() < 0) {
|
|
|
+ xinput_device_change = SDL_TRUE;
|
|
|
+ ctx->xinput_enabled = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT, SDL_TRUE);
|
|
|
+ if (ctx->xinput_enabled && (WIN_LoadXInputDLL() < 0 || !XINPUTGETSTATE)) {
|
|
|
ctx->xinput_enabled = SDL_FALSE;
|
|
|
}
|
|
|
ctx->xinput_slot = XUSER_INDEX_ANY;
|
|
|
@@ -370,7 +702,7 @@ HIDAPI_DriverXbox360_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joyst
|
|
|
|
|
|
/* Set the controller LED */
|
|
|
player_index = SDL_JoystickGetPlayerIndex(joystick);
|
|
|
- if (player_index >= 0) {
|
|
|
+ if (player_index >= 0 && device->dev) {
|
|
|
SetSlotLED(device->dev, (player_index % 4));
|
|
|
}
|
|
|
|
|
|
@@ -393,12 +725,12 @@ HIDAPI_DriverXbox360_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joy
|
|
|
SDL_bool rumbled = SDL_FALSE;
|
|
|
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
- if (!rumbled && ctx->gamepad) {
|
|
|
+ if (!rumbled && ctx->wgi_correlated) {
|
|
|
+ WindowsGamingInputGamepadState *gamepad_state = ctx->wgi_slot;
|
|
|
HRESULT hr;
|
|
|
-
|
|
|
- ctx->vibration.LeftMotor = (DOUBLE)low_frequency_rumble / SDL_MAX_UINT16;
|
|
|
- ctx->vibration.RightMotor = (DOUBLE)high_frequency_rumble / SDL_MAX_UINT16;
|
|
|
- hr = __x_ABI_CWindows_CGaming_CInput_CIGamepad_put_Vibration(ctx->gamepad, ctx->vibration);
|
|
|
+ gamepad_state->vibration.LeftMotor = (DOUBLE)low_frequency_rumble / SDL_MAX_UINT16;
|
|
|
+ gamepad_state->vibration.RightMotor = (DOUBLE)high_frequency_rumble / SDL_MAX_UINT16;
|
|
|
+ hr = __x_ABI_CWindows_CGaming_CInput_CIGamepad_put_Vibration(gamepad_state->gamepad, gamepad_state->vibration);
|
|
|
if (SUCCEEDED(hr)) {
|
|
|
rumbled = SDL_TRUE;
|
|
|
}
|
|
|
@@ -406,7 +738,7 @@ HIDAPI_DriverXbox360_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joy
|
|
|
#endif
|
|
|
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
- if (!rumbled && ctx->xinput_slot != XUSER_INDEX_ANY) {
|
|
|
+ if (!rumbled && ctx->xinput_correlated) {
|
|
|
XINPUT_VIBRATION XVibration;
|
|
|
|
|
|
if (!XINPUTSETSTATE) {
|
|
|
@@ -473,6 +805,13 @@ HIDAPI_DriverXbox360_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joy
|
|
|
static void
|
|
|
HIDAPI_DriverXbox360_HandleStatePacket(SDL_Joystick *joystick, hid_device *dev, SDL_DriverXbox360_Context *ctx, Uint8 *data, int size)
|
|
|
{
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+ Uint32 match_state = ctx->match_state;
|
|
|
+ /* Update match_state with button bit, then fall through */
|
|
|
+# define SDL_PrivateJoystickButton(joystick, button, state) if (state) match_state |= 1 << (button); else match_state &=~(1<<(button)); SDL_PrivateJoystickButton(joystick, button, state)
|
|
|
+ /* Grab high 4 bits of value, then fall through */
|
|
|
+# define SDL_PrivateJoystickAxis(joystick, axis, value) if (axis < 4) match_state = (match_state & ~(0xF << (4 * axis + 16))) | ((value) & 0xF000) << (4 * axis + 4); SDL_PrivateJoystickAxis(joystick, axis, value)
|
|
|
+#endif
|
|
|
Sint16 axis;
|
|
|
SDL_bool has_trigger_data = SDL_FALSE;
|
|
|
|
|
|
@@ -543,96 +882,56 @@ HIDAPI_DriverXbox360_HandleStatePacket(SDL_Joystick *joystick, hid_device *dev,
|
|
|
axis = (int)*(Uint16*)(&data[6]) - 0x8000;
|
|
|
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
|
|
|
|
|
|
-#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
- if (ctx->gamepad_statics && !ctx->gamepad) {
|
|
|
- Uint8 buttons = 0;
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+#undef SDL_PrivateJoystickAxis
|
|
|
+#endif
|
|
|
|
|
|
- if (data[10] & 0x01) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_A);
|
|
|
- }
|
|
|
- if (data[10] & 0x02) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_B);
|
|
|
- }
|
|
|
- if (data[10] & 0x04) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_X);
|
|
|
- }
|
|
|
- if (data[10] & 0x08) {
|
|
|
- buttons |= (1 << SDL_CONTROLLER_BUTTON_Y);
|
|
|
- }
|
|
|
- if (buttons != 0) {
|
|
|
- HIDAPI_DriverXbox360_GuessGamepad(ctx, buttons);
|
|
|
- }
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
+ /* Prefer XInput over WindowsGamingInput, it continues to provide data in the background */
|
|
|
+ if (!has_trigger_data && ctx->xinput_enabled && ctx->xinput_correlated) {
|
|
|
+ has_trigger_data = SDL_TRUE;
|
|
|
}
|
|
|
+#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT */
|
|
|
|
|
|
- if (ctx->gamepad) {
|
|
|
- HRESULT hr;
|
|
|
- struct __x_ABI_CWindows_CGaming_CInput_CGamepadReading state;
|
|
|
-
|
|
|
- hr = __x_ABI_CWindows_CGaming_CInput_CIGamepad_GetCurrentReading(ctx->gamepad, &state);
|
|
|
- if (SUCCEEDED(hr)) {
|
|
|
- SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (state.Buttons & 0x40000000) ? SDL_PRESSED : SDL_RELEASED);
|
|
|
- SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, ((int)(state.LeftTrigger * SDL_MAX_UINT16)) - 32768);
|
|
|
- SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, ((int)(state.RightTrigger * SDL_MAX_UINT16)) - 32768);
|
|
|
- has_trigger_data = SDL_TRUE;
|
|
|
- }
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
+ if (!has_trigger_data && ctx->wgi_correlated) {
|
|
|
+ has_trigger_data = SDL_TRUE;
|
|
|
}
|
|
|
#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT */
|
|
|
|
|
|
-#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
- if (ctx->xinput_enabled) {
|
|
|
- if (ctx->xinput_slot == XUSER_INDEX_ANY && HIDAPI_DriverXbox360_MissingXInputSlot()) {
|
|
|
- WORD wButtons = 0;
|
|
|
-
|
|
|
- if (data[10] & 0x01) {
|
|
|
- wButtons |= XINPUT_GAMEPAD_A;
|
|
|
- }
|
|
|
- if (data[10] & 0x02) {
|
|
|
- wButtons |= XINPUT_GAMEPAD_B;
|
|
|
- }
|
|
|
- if (data[10] & 0x04) {
|
|
|
- wButtons |= XINPUT_GAMEPAD_X;
|
|
|
- }
|
|
|
- if (data[10] & 0x08) {
|
|
|
- wButtons |= XINPUT_GAMEPAD_Y;
|
|
|
- }
|
|
|
- if (wButtons != 0) {
|
|
|
- Uint8 xinput_slot = HIDAPI_DriverXbox360_GuessXInputSlot(wButtons);
|
|
|
- if (xinput_slot != XUSER_INDEX_ANY) {
|
|
|
- HIDAPI_DriverXbox360_MarkXInputSlotUsed(xinput_slot);
|
|
|
- ctx->xinput_slot = xinput_slot;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!has_trigger_data && ctx->xinput_slot != XUSER_INDEX_ANY) {
|
|
|
- XINPUT_STATE_EX xinput_state;
|
|
|
-
|
|
|
- if (XINPUTGETSTATE(ctx->xinput_slot, &xinput_state) == ERROR_SUCCESS) {
|
|
|
- SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (xinput_state.Gamepad.wButtons & XINPUT_GAMEPAD_GUIDE) ? SDL_PRESSED : SDL_RELEASED);
|
|
|
- SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, ((int)xinput_state.Gamepad.bLeftTrigger * 257) - 32768);
|
|
|
- SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, ((int)xinput_state.Gamepad.bRightTrigger * 257) - 32768);
|
|
|
- has_trigger_data = SDL_TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT */
|
|
|
-
|
|
|
if (!has_trigger_data) {
|
|
|
axis = (data[9] * 257) - 32768;
|
|
|
if (data[9] < 0x80) {
|
|
|
axis = -axis * 2 - 32769;
|
|
|
+ SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, SDL_MIN_SINT16);
|
|
|
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, axis);
|
|
|
} else if (data[9] > 0x80) {
|
|
|
axis = axis * 2 - 32767;
|
|
|
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, axis);
|
|
|
+ SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, SDL_MIN_SINT16);
|
|
|
} else {
|
|
|
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, SDL_MIN_SINT16);
|
|
|
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, SDL_MIN_SINT16);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+ ctx->match_state = match_state;
|
|
|
+ ctx->last_state_packet = SDL_GetTicks();
|
|
|
+#undef SDL_PrivateJoystickButton
|
|
|
+#endif
|
|
|
SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
|
|
|
}
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_RAWINPUT
|
|
|
+static void
|
|
|
+HIDAPI_DriverXbox360_HandleStatePacketFromRAWINPUT(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 *data, int size)
|
|
|
+{
|
|
|
+ SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
|
|
|
+ HIDAPI_DriverXbox360_HandleStatePacket(joystick, NULL, ctx, data, size);
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
#else
|
|
|
|
|
|
static void
|
|
|
@@ -689,13 +988,243 @@ HIDAPI_DriverXbox360_HandleStatePacket(SDL_Joystick *joystick, hid_device *dev,
|
|
|
}
|
|
|
#endif /* __WIN32__ */
|
|
|
|
|
|
+static void
|
|
|
+HIDAPI_DriverXbox360_UpdateOtherAPIs(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
|
|
|
+{
|
|
|
+ SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
|
|
|
+ SDL_bool has_trigger_data = SDL_FALSE;
|
|
|
+ SDL_bool correlated = SDL_FALSE;
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+ WindowsMatchState match_state_xinput;
|
|
|
+#endif
|
|
|
+
|
|
|
+ /* Poll for trigger data once (not per-state-packet) */
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
+ /* Prefer XInput over WindowsGamingInput, it continues to provide data in the background */
|
|
|
+ if (!has_trigger_data && ctx->xinput_enabled && ctx->xinput_correlated) {
|
|
|
+ HIDAPI_DriverXbox360_UpdateXInput();
|
|
|
+ if (xinput_state[ctx->xinput_slot].connected) {
|
|
|
+ SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (xinput_state[ctx->xinput_slot].state.Gamepad.wButtons & XINPUT_GAMEPAD_GUIDE) ? SDL_PRESSED : SDL_RELEASED);
|
|
|
+ SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, ((int)xinput_state[ctx->xinput_slot].state.Gamepad.bLeftTrigger * 257) - 32768);
|
|
|
+ SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, ((int)xinput_state[ctx->xinput_slot].state.Gamepad.bRightTrigger * 257) - 32768);
|
|
|
+ has_trigger_data = SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT */
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
+ if (!has_trigger_data && ctx->wgi_correlated) {
|
|
|
+ HIDAPI_DriverXbox360_UpdateWindowsGamingInput(); /* May detect disconnect / cause uncorrelation */
|
|
|
+ if (ctx->wgi_correlated) { /* Still connected */
|
|
|
+ struct __x_ABI_CWindows_CGaming_CInput_CGamepadReading *state = &ctx->wgi_slot->state;
|
|
|
+ SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (state->Buttons & GamepadButtons_GUIDE) ? SDL_PRESSED : SDL_RELEASED);
|
|
|
+ SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, ((int)(state->LeftTrigger * SDL_MAX_UINT16)) - 32768);
|
|
|
+ SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, ((int)(state->RightTrigger * SDL_MAX_UINT16)) - 32768);
|
|
|
+ has_trigger_data = SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif /* SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT */
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+ HIDAPI_DriverXbox360_FillMatchState(&match_state_xinput, ctx->match_state);
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT
|
|
|
+ /* Parallel logic to WINDOWS_XINPUT below */
|
|
|
+ HIDAPI_DriverXbox360_UpdateWindowsGamingInput();
|
|
|
+ if (ctx->wgi_correlated) {
|
|
|
+ /* We have been previously correlated, ensure we are still matching, see comments in XINPUT section */
|
|
|
+ if (HIDAPI_DriverXbox360_WindowsGamingInputSlotMatches(&match_state_xinput, ctx->wgi_slot)) {
|
|
|
+ ctx->wgi_uncorrelate_count = 0;
|
|
|
+ } else {
|
|
|
+ ++ctx->wgi_uncorrelate_count;
|
|
|
+ /* Only un-correlate if this is consistent over multiple Update() calls - the timing of polling/event
|
|
|
+ pumping can easily cause this to uncorrelate for a frame. 2 seemed reliable in my testing, but
|
|
|
+ let's set it to 3 to be safe. An incorrect un-correlation will simply result in lower precision
|
|
|
+ triggers for a frame. */
|
|
|
+ if (ctx->wgi_uncorrelate_count >= 3) {
|
|
|
+#ifdef DEBUG_JOYSTICK
|
|
|
+ SDL_Log("UN-Correlated joystick %d to WindowsGamingInput device #%d\n", joystick->instance_id, ctx->wgi_slot);
|
|
|
+#endif
|
|
|
+ HIDAPI_DriverXbox360_MarkWindowsGamingInputSlotFree(ctx->wgi_slot);
|
|
|
+ ctx->wgi_correlated = SDL_FALSE;
|
|
|
+ ctx->wgi_correlation_count = 0;
|
|
|
+ /* Force immediate update of triggers */
|
|
|
+ HIDAPI_DriverXbox360_HandleStatePacket(joystick, NULL, ctx, ctx->last_state, sizeof(ctx->last_state));
|
|
|
+ /* Force release of Guide button, it can't possibly be down on this device now. */
|
|
|
+ /* It gets left down if we were actually correlated incorrectly and it was released on the WindowsGamingInput
|
|
|
+ device but we didn't get a state packet. */
|
|
|
+ SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, SDL_RELEASED);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!ctx->wgi_correlated) {
|
|
|
+ SDL_bool new_correlation_count = 0;
|
|
|
+ if (HIDAPI_DriverXbox360_MissingWindowsGamingInputSlot()) {
|
|
|
+ Uint8 correlation_id;
|
|
|
+ WindowsGamingInputGamepadState *slot_idx;
|
|
|
+ if (HIDAPI_DriverXbox360_GuessWindowsGamingInputSlot(&match_state_xinput, &correlation_id, &slot_idx)) {
|
|
|
+ /* we match exactly one WindowsGamingInput device */
|
|
|
+ /* Probably can do without wgi_correlation_count, just check and clear wgi_slot to NULL, unless we need
|
|
|
+ even more frames to be sure. */
|
|
|
+ if (ctx->wgi_correlation_count && ctx->wgi_slot == slot_idx) {
|
|
|
+ /* was correlated previously, and still the same device */
|
|
|
+ if (ctx->wgi_correlation_id + 1 == correlation_id) {
|
|
|
+ /* no one else was correlated in the meantime */
|
|
|
+ new_correlation_count = ctx->wgi_correlation_count + 1;
|
|
|
+ if (new_correlation_count == 2) {
|
|
|
+ /* correlation stayed steady and uncontested across multiple frames, guaranteed match */
|
|
|
+ ctx->wgi_correlated = SDL_TRUE;
|
|
|
+#ifdef DEBUG_JOYSTICK
|
|
|
+ SDL_Log("Correlated joystick %d to WindowsGamingInput device #%d\n", joystick->instance_id, slot_idx);
|
|
|
+#endif
|
|
|
+ correlated = SDL_TRUE;
|
|
|
+ HIDAPI_DriverXbox360_MarkWindowsGamingInputSlotUsed(ctx->wgi_slot, ctx);
|
|
|
+ /* If the generalized Guide button was using us, it doesn't need to anymore */
|
|
|
+ if (guide_button_candidate.joystick == joystick)
|
|
|
+ guide_button_candidate.joystick = NULL;
|
|
|
+ if (guide_button_candidate.last_joystick == joystick)
|
|
|
+ guide_button_candidate.last_joystick = NULL;
|
|
|
+ /* Force immediate update of guide button / triggers */
|
|
|
+ HIDAPI_DriverXbox360_HandleStatePacket(joystick, NULL, ctx, ctx->last_state, sizeof(ctx->last_state));
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* someone else also possibly correlated to this device, start over */
|
|
|
+ new_correlation_count = 1;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* new possible correlation */
|
|
|
+ new_correlation_count = 1;
|
|
|
+ ctx->wgi_slot = slot_idx;
|
|
|
+ }
|
|
|
+ ctx->wgi_correlation_id = correlation_id;
|
|
|
+ } else {
|
|
|
+ /* Match multiple WindowsGamingInput devices, or none (possibly due to no buttons pressed) */
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ctx->wgi_correlation_count = new_correlation_count;
|
|
|
+ } else {
|
|
|
+ correlated = SDL_TRUE;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
+ /* Parallel logic to WINDOWS_GAMING_INPUT above */
|
|
|
+ if (ctx->xinput_enabled) {
|
|
|
+ HIDAPI_DriverXbox360_UpdateXInput();
|
|
|
+ if (ctx->xinput_correlated) {
|
|
|
+ /* We have been previously correlated, ensure we are still matching */
|
|
|
+ /* This is required to deal with two (mostly) un-preventable mis-correlation situations:
|
|
|
+ A) Since the HID data stream does not provide an initial state (but polling XInput does), if we open
|
|
|
+ 5 controllers (#1-4 XInput mapped, #5 is not), and controller 1 had the A button down (and we don't
|
|
|
+ know), and the user presses A on controller #5, we'll see exactly 1 controller with A down (#5) and
|
|
|
+ exactly 1 XInput device with A down (#1), and incorrectly correlate. This code will then un-correlate
|
|
|
+ when A is released from either controller #1 or #5.
|
|
|
+ B) Since the app may not open all controllers, we could have a similar situation where only controller #5
|
|
|
+ is opened, and the user holds A on controllers #1 and #5 simultaneously - again we see only 1 controller
|
|
|
+ with A down and 1 XInput device with A down, and incorrectly correlate. This should be very unusual
|
|
|
+ (only when apps do not open all controllers, yet are listening to Guide button presses, yet
|
|
|
+ for some reason want to ignore guide button presses on the un-opened controllers, yet users are
|
|
|
+ pressing buttons on the unopened controllers), and will resolve itself when either button is released
|
|
|
+ and we un-correlate. We could prevent this by processing the state packets for *all* controllers,
|
|
|
+ even un-opened ones, as that would allow more precise correlation.
|
|
|
+ */
|
|
|
+ if (HIDAPI_DriverXbox360_XInputSlotMatches(&match_state_xinput, ctx->xinput_slot)) {
|
|
|
+ ctx->xinput_uncorrelate_count = 0;
|
|
|
+ } else {
|
|
|
+ ++ctx->xinput_uncorrelate_count;
|
|
|
+ /* Only un-correlate if this is consistent over multiple Update() calls - the timing of polling/event
|
|
|
+ pumping can easily cause this to uncorrelate for a frame. 2 seemed reliable in my testing, but
|
|
|
+ let's set it to 3 to be safe. An incorrect un-correlation will simply result in lower precision
|
|
|
+ triggers for a frame. */
|
|
|
+ if (ctx->xinput_uncorrelate_count >= 3) {
|
|
|
+#ifdef DEBUG_JOYSTICK
|
|
|
+ SDL_Log("UN-Correlated joystick %d to XInput device #%d\n", joystick->instance_id, ctx->xinput_slot);
|
|
|
+#endif
|
|
|
+ HIDAPI_DriverXbox360_MarkXInputSlotFree(ctx->xinput_slot);
|
|
|
+ ctx->xinput_correlated = SDL_FALSE;
|
|
|
+ ctx->xinput_correlation_count = 0;
|
|
|
+ /* Force immediate update of triggers */
|
|
|
+ HIDAPI_DriverXbox360_HandleStatePacket(joystick, NULL, ctx, ctx->last_state, sizeof(ctx->last_state));
|
|
|
+ /* Force release of Guide button, it can't possibly be down on this device now. */
|
|
|
+ /* It gets left down if we were actually correlated incorrectly and it was released on the XInput
|
|
|
+ device but we didn't get a state packet. */
|
|
|
+ SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, SDL_RELEASED);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!ctx->xinput_correlated) {
|
|
|
+ SDL_bool new_correlation_count = 0;
|
|
|
+ if (HIDAPI_DriverXbox360_MissingXInputSlot()) {
|
|
|
+ Uint8 correlation_id;
|
|
|
+ Uint8 slot_idx;
|
|
|
+ if (HIDAPI_DriverXbox360_GuessXInputSlot(&match_state_xinput, &correlation_id, &slot_idx)) {
|
|
|
+ /* we match exactly one XInput device */
|
|
|
+ /* Probably can do without xinput_correlation_count, just check and clear xinput_slot to ANY, unless
|
|
|
+ we need even more frames to be sure */
|
|
|
+ if (ctx->xinput_correlation_count && ctx->xinput_slot == slot_idx) {
|
|
|
+ /* was correlated previously, and still the same device */
|
|
|
+ if (ctx->xinput_correlation_id + 1 == correlation_id) {
|
|
|
+ /* no one else was correlated in the meantime */
|
|
|
+ new_correlation_count = ctx->xinput_correlation_count + 1;
|
|
|
+ if (new_correlation_count == 2) {
|
|
|
+ /* correlation stayed steady and uncontested across multiple frames, guaranteed match */
|
|
|
+ ctx->xinput_correlated = SDL_TRUE;
|
|
|
+#ifdef DEBUG_JOYSTICK
|
|
|
+ SDL_Log("Correlated joystick %d to XInput device #%d\n", joystick->instance_id, slot_idx);
|
|
|
+#endif
|
|
|
+ correlated = SDL_TRUE;
|
|
|
+ HIDAPI_DriverXbox360_MarkXInputSlotUsed(ctx->xinput_slot);
|
|
|
+ /* If the generalized Guide button was using us, it doesn't need to anymore */
|
|
|
+ if (guide_button_candidate.joystick == joystick)
|
|
|
+ guide_button_candidate.joystick = NULL;
|
|
|
+ if (guide_button_candidate.last_joystick == joystick)
|
|
|
+ guide_button_candidate.last_joystick = NULL;
|
|
|
+ /* Force immediate update of guide button / triggers */
|
|
|
+ HIDAPI_DriverXbox360_HandleStatePacket(joystick, NULL, ctx, ctx->last_state, sizeof(ctx->last_state));
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* someone else also possibly correlated to this device, start over */
|
|
|
+ new_correlation_count = 1;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* new possible correlation */
|
|
|
+ new_correlation_count = 1;
|
|
|
+ ctx->xinput_slot = slot_idx;
|
|
|
+ }
|
|
|
+ ctx->xinput_correlation_id = correlation_id;
|
|
|
+ } else {
|
|
|
+ /* Match multiple XInput devices, or none (possibly due to no buttons pressed) */
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ctx->xinput_correlation_count = new_correlation_count;
|
|
|
+ } else {
|
|
|
+ correlated = SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ if (!correlated) {
|
|
|
+ if (!guide_button_candidate.joystick ||
|
|
|
+ (ctx->last_state_packet && (
|
|
|
+ !guide_button_candidate.last_state_packet ||
|
|
|
+ SDL_TICKS_PASSED(ctx->last_state_packet, guide_button_candidate.last_state_packet)
|
|
|
+ ))
|
|
|
+ ) {
|
|
|
+ guide_button_candidate.joystick = joystick;
|
|
|
+ guide_button_candidate.last_state_packet = ctx->last_state_packet;
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
static SDL_bool
|
|
|
HIDAPI_DriverXbox360_UpdateDevice(SDL_HIDAPI_Device *device)
|
|
|
{
|
|
|
SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
|
|
|
SDL_Joystick *joystick = NULL;
|
|
|
Uint8 data[USB_PACKET_LENGTH];
|
|
|
- int size;
|
|
|
+ int size = 0;
|
|
|
|
|
|
if (device->num_joysticks > 0) {
|
|
|
joystick = SDL_JoystickFromInstanceID(device->joysticks[0]);
|
|
|
@@ -704,14 +1233,17 @@ HIDAPI_DriverXbox360_UpdateDevice(SDL_HIDAPI_Device *device)
|
|
|
return SDL_FALSE;
|
|
|
}
|
|
|
|
|
|
- while ((size = hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
|
|
|
+ while (device->dev && (size = hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
|
|
|
HIDAPI_DriverXbox360_HandleStatePacket(joystick, device->dev, ctx, data, size);
|
|
|
}
|
|
|
|
|
|
if (size < 0) {
|
|
|
/* Read error, device is disconnected */
|
|
|
- HIDAPI_JoystickDisconnected(device, joystick->instance_id);
|
|
|
+ HIDAPI_JoystickDisconnected(device, joystick->instance_id, SDL_FALSE);
|
|
|
+ } else {
|
|
|
+ HIDAPI_DriverXbox360_UpdateOtherAPIs(device, joystick);
|
|
|
}
|
|
|
+
|
|
|
return (size >= 0);
|
|
|
}
|
|
|
|
|
|
@@ -721,10 +1253,20 @@ HIDAPI_DriverXbox360_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joys
|
|
|
#if defined(SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT) || defined(SDL_JOYSTICK_HIDAPI_WINDOWS_GAMING_INPUT)
|
|
|
SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
|
|
|
#endif
|
|
|
+
|
|
|
+#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_MATCHING
|
|
|
+ if (guide_button_candidate.joystick == joystick)
|
|
|
+ guide_button_candidate.joystick = NULL;
|
|
|
+ if (guide_button_candidate.last_joystick == joystick)
|
|
|
+ guide_button_candidate.last_joystick = NULL;
|
|
|
+#endif
|
|
|
|
|
|
#ifdef SDL_JOYSTICK_HIDAPI_WINDOWS_XINPUT
|
|
|
+ xinput_device_change = SDL_TRUE;
|
|
|
if (ctx->xinput_enabled) {
|
|
|
- HIDAPI_DriverXbox360_MarkXInputSlotFree(ctx->xinput_slot);
|
|
|
+ if (ctx->xinput_correlated) {
|
|
|
+ HIDAPI_DriverXbox360_MarkXInputSlotFree(ctx->xinput_slot);
|
|
|
+ }
|
|
|
WIN_UnloadXInputDLL();
|
|
|
}
|
|
|
#endif
|
|
|
@@ -732,8 +1274,10 @@ HIDAPI_DriverXbox360_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joys
|
|
|
HIDAPI_DriverXbox360_QuitWindowsGamingInput(ctx);
|
|
|
#endif
|
|
|
|
|
|
- hid_close(device->dev);
|
|
|
- device->dev = NULL;
|
|
|
+ if (device->dev) {
|
|
|
+ hid_close(device->dev);
|
|
|
+ device->dev = NULL;
|
|
|
+ }
|
|
|
|
|
|
SDL_free(device->context);
|
|
|
device->context = NULL;
|
|
|
@@ -757,7 +1301,11 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360 =
|
|
|
HIDAPI_DriverXbox360_OpenJoystick,
|
|
|
HIDAPI_DriverXbox360_RumbleJoystick,
|
|
|
HIDAPI_DriverXbox360_CloseJoystick,
|
|
|
- HIDAPI_DriverXbox360_FreeDevice
|
|
|
+ HIDAPI_DriverXbox360_FreeDevice,
|
|
|
+ HIDAPI_DriverXbox360_PostUpdate,
|
|
|
+#ifdef SDL_JOYSTICK_RAWINPUT
|
|
|
+ HIDAPI_DriverXbox360_HandleStatePacketFromRAWINPUT,
|
|
|
+#endif
|
|
|
};
|
|
|
|
|
|
#endif /* SDL_JOYSTICK_HIDAPI_XBOX360 */
|
Sam Lantinga