src/joystick/winrt/SDL_xinputjoystick.c

/*
  Simple DirectMedia Layer
  Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/
#include "../../SDL_internal.h"

#if SDL_JOYSTICK_XINPUT

/* SDL_xinputjoystick.c implements an XInput-only joystick and game controller
   backend that is suitable for use on WinRT.  SDL's DirectInput backend, also
   XInput-capable, was not used as DirectInput is not available on WinRT (or,
   at least, it isn't a public API).  Some portions of this XInput backend
   may copy parts of the XInput-using code from the DirectInput backend.
   Refactoring the common parts into one location may be good to-do at some
   point.

   TODO, WinRT: add hotplug support for XInput based game controllers
*/

#include "SDL_joystick.h"
#include "../SDL_sysjoystick.h"
#include "../SDL_joystick_c.h"
#include "SDL_events.h"
#include "../../events/SDL_events_c.h"
#include "SDL_timer.h"

#include <Windows.h>
#include <Xinput.h>

#ifndef XINPUT_GAMEPAD_GUIDE
#define XINPUT_GAMEPAD_GUIDE 0x0400
#endif

struct joystick_hwdata {
    //Uint8 bXInputHaptic; // Supports force feedback via XInput.
    DWORD userIndex;    // The XInput device index, in the range [0, XUSER_MAX_COUNT-1] (probably [0,3]).
    XINPUT_STATE XInputState;   // the last-read in XInputState, kept around to compare old and new values
    SDL_bool isDeviceConnected; // was the device connected (on the last detection-polling, or during backend-initialization)?
    SDL_bool isDeviceConnectionEventPending;    // was a device added, and is the associated add-event pending?
    SDL_bool isDeviceRemovalEventPending;   // was the device removed, and is the associated remove-event pending?
};

/* Keep track of data on all XInput devices, regardless of whether or not
   they've been opened (via SDL_JoystickOpen).
 */
static struct joystick_hwdata g_XInputData[XUSER_MAX_COUNT];

/* Device detection can be extremely costly performance-wise, in some cases.
   In particular, if no devices are connected, calls to detect a single device,
   via either XInputGetState() or XInputGetCapabilities(), can take upwards of
   20 ms on a 1st generation Surface RT, more if devices are detected across
   all of of XInput's four device slots.  WinRT and XInput do not appear to
   have callback-based APIs to notify an app when a device is connected, at
   least as of Windows 8.1.  The synchronous XInput calls must be used.

   Once a device is connected, calling XInputGetState() is a much less costly
   operation, with individual calls costing well under 1 ms, and often under
   0.1 ms [on a 1st gen Surface RT].

   With XInput's performance limitations in mind, a separate device-detection
   thread will be utilized (by SDL) to try to move costly XInput calls off the
   main thread.  Polling of active devices still, however, occurs on the main
   thread.
 */
static SDL_Thread * g_DeviceDetectionThread = NULL;
static SDL_mutex * g_DeviceInfoLock = NULL;
static SDL_bool g_DeviceDetectionQuit = SDL_FALSE;

/* Main function for the device-detection thread.
 */
static int
DeviceDetectionThreadMain(void * _data)
{
    DWORD result;
    XINPUT_CAPABILITIES tempXInputCaps;
    int i;

    while (1) {
        /* See if the device-detection thread is being asked to shutdown.
         */
        SDL_LockMutex(g_DeviceInfoLock);
        if (g_DeviceDetectionQuit) {
            SDL_UnlockMutex(g_DeviceInfoLock);
            break;
        }
        SDL_UnlockMutex(g_DeviceInfoLock);

        /* Add a short delay to prevent the device-detection thread from eating
           up too much CPU time:
         */
        SDL_Delay(300);

        /* TODO, WinRT: try making the device-detection thread wakeup sooner from its CPU-preserving SDL_Delay, if the thread was asked to quit.
         */

        /* See if any new devices are connected. */
        SDL_LockMutex(g_DeviceInfoLock);
        for (i = 0; i < XUSER_MAX_COUNT; ++i) {
            if (!g_XInputData[i].isDeviceConnected &&
                !g_XInputData[i].isDeviceConnectionEventPending &&
                !g_XInputData[i].isDeviceRemovalEventPending)
            {
                SDL_UnlockMutex(g_DeviceInfoLock);
                result = XInputGetCapabilities(i, 0, &tempXInputCaps);
                SDL_LockMutex(g_DeviceInfoLock);
                if (result == ERROR_SUCCESS) {
                    /* Yes, a device is connected.  Mark it as such.
                       Others will be told about this (via an
                       SDL_JOYDEVICEADDED event) in the next call to
                       SDL_SYS_JoystickDetect.
                     */
                    g_XInputData[i].isDeviceConnected = SDL_TRUE;
                    g_XInputData[i].isDeviceConnectionEventPending = SDL_TRUE;
                }
            }
        }
        SDL_UnlockMutex(g_DeviceInfoLock);
    }

    return 0;
}

/* Function to scan the system for joysticks.
 * It should return 0, or -1 on an unrecoverable fatal error.
 */
int
SDL_SYS_JoystickInit(void)
{
    HRESULT result = S_OK;
    XINPUT_STATE tempXInputState;
    int i;

    SDL_zero(g_XInputData);

    /* Make initial notes on whether or not devices are connected (or not).
     */
    for (i = 0; i < XUSER_MAX_COUNT; ++i) {
        result = XInputGetState(i, &tempXInputState);
        if (result == ERROR_SUCCESS) {
            g_XInputData[i].isDeviceConnected = SDL_TRUE;
        }
    }

    /* Start up the device-detection thread.
     */
    g_DeviceDetectionQuit = SDL_FALSE;
    g_DeviceInfoLock = SDL_CreateMutex();
    g_DeviceDetectionThread = SDL_CreateThread(DeviceDetectionThreadMain, "SDL_joystick", NULL);

    return (0);
}

int SDL_SYS_NumJoysticks()
{
    int joystickCount = 0;
    DWORD i;

    /* Iterate through each possible XInput device and see if something
       was connected (at joystick init, or during the last polling).
     */
    SDL_LockMutex(g_DeviceInfoLock);
    for (i = 0; i < XUSER_MAX_COUNT; ++i) {
        if (g_XInputData[i].isDeviceConnected) {
            ++joystickCount;
        }
    }
    SDL_UnlockMutex(g_DeviceInfoLock);

    return joystickCount;
}

void SDL_SYS_JoystickDetect()
{
    DWORD i;
    SDL_Event event;

    /* Iterate through each possible XInput device, seeing if any devices
       have been connected, or if they were removed.
     */
    SDL_LockMutex(g_DeviceInfoLock);
    for (i = 0; i < XUSER_MAX_COUNT; ++i) {
        /* See if any new devices are connected. */
        if (g_XInputData[i].isDeviceConnectionEventPending) {
#if !SDL_EVENTS_DISABLED
            SDL_zero(event);
            event.type = SDL_JOYDEVICEADDED;
                
            if (SDL_GetEventState(event.type) == SDL_ENABLE) {
                event.jdevice.which = i;
                if ((SDL_EventOK == NULL)
                    || (*SDL_EventOK) (SDL_EventOKParam, &event)) {
                    SDL_PushEvent(&event);
                }
            }
#endif
            g_XInputData[i].isDeviceConnectionEventPending = SDL_FALSE;
        } else if (g_XInputData[i].isDeviceRemovalEventPending) {
            /* A device was previously marked as removed (by
               SDL_SYS_JoystickUpdate).  Tell others about the device removal.
            */

            g_XInputData[i].isDeviceRemovalEventPending = SDL_FALSE;

#if !SDL_EVENTS_DISABLED
            SDL_zero(event);
            event.type = SDL_JOYDEVICEREMOVED;
                
            if (SDL_GetEventState(event.type) == SDL_ENABLE) {
                event.jdevice.which = i; //joystick->hwdata->userIndex;
                if ((SDL_EventOK == NULL)
                    || (*SDL_EventOK) (SDL_EventOKParam, &event)) {
                    SDL_PushEvent(&event);
                }
            }
#endif
        }
    }
    SDL_UnlockMutex(g_DeviceInfoLock);
}


/* Internal function to retreive device capabilities.
   This function will return an SDL-standard value of 0 on success
   (a device is connected, and data on it was retrieved), or -1
   on failure (no device was connected, or some other error
   occurred.  SDL_SetError() will be invoked to set an appropriate
   error message.
 */
static int
SDL_XInput_GetDeviceCapabilities(int device_index, XINPUT_CAPABILITIES * pDeviceCaps)
{
    HRESULT dwResult;

    /* Make sure that the device index is a valid one.  If not, return to the
       caller with an error.
     */
    if (device_index < 0 || device_index >= XUSER_MAX_COUNT) {
        return SDL_SetError("invalid/unavailable device index");
    }

    /* See if a device exists, and if so, what its capabilities are.  If a
       device is not available, return to the caller with an error.
     */
    switch ((dwResult = XInputGetCapabilities(device_index, 0, pDeviceCaps))) {
        case ERROR_SUCCESS:
            /* A device is available, and its capabilities were retrieved! */
            return 0;
        case ERROR_DEVICE_NOT_CONNECTED:
            return SDL_SetError("no device is connected at joystick index, %d", device_index);
        default:
            return SDL_SetError("an unknown error occurred when retrieving info on a device at joystick index, %d", device_index);
    }
}

/* Function to get the device-dependent name of a joystick */
const char *
SDL_SYS_JoystickNameForDeviceIndex(int device_index)
{
    XINPUT_CAPABILITIES deviceCaps;

    if (SDL_XInput_GetDeviceCapabilities(device_index, &deviceCaps) != 0) {
        /* Uh oh.  Device capabilities couldn't be retrieved.  Return to the
           caller.  SDL_SetError() has already been invoked (with relevant
           information).
         */
        return NULL;
    }

    switch (deviceCaps.SubType) {
        default:
            if (deviceCaps.Type == XINPUT_DEVTYPE_GAMEPAD) {
                return "Undefined game controller";
            } else {
                return "Undefined controller";
            }
        case XINPUT_DEVSUBTYPE_UNKNOWN:
            if (deviceCaps.Type == XINPUT_DEVTYPE_GAMEPAD) {
                return "Unknown game controller";
            } else {
                return "Unknown controller";
            }
        case XINPUT_DEVSUBTYPE_GAMEPAD:
            return "Gamepad controller";
        case XINPUT_DEVSUBTYPE_WHEEL:
            return "Racing wheel controller";
        case XINPUT_DEVSUBTYPE_ARCADE_STICK:
            return "Arcade stick controller";
        case XINPUT_DEVSUBTYPE_FLIGHT_STICK:
            return "Flight stick controller";
        case XINPUT_DEVSUBTYPE_DANCE_PAD:
            return "Dance pad controller";
        case XINPUT_DEVSUBTYPE_GUITAR:
            return "Guitar controller";
        case XINPUT_DEVSUBTYPE_GUITAR_ALTERNATE:
            return "Guitar controller, Alternate";
        case XINPUT_DEVSUBTYPE_GUITAR_BASS:
            return "Guitar controller, Bass";
        case XINPUT_DEVSUBTYPE_DRUM_KIT:
            return "Drum controller";
        case XINPUT_DEVSUBTYPE_ARCADE_PAD:
            return "Arcade pad controller";
    }
}

/* Function to perform the mapping from device index to the instance id for this index */
SDL_JoystickID SDL_SYS_GetInstanceIdOfDeviceIndex(int device_index)
{
    return device_index;
}

/* Function to open a joystick for use.
   The joystick to open is specified by the index field of the joystick.
   This should fill the nbuttons and naxes fields of the joystick structure.
   It returns 0, or -1 if there is an error.
 */
int
SDL_SYS_JoystickOpen(SDL_Joystick * joystick, int device_index)
{
    XINPUT_CAPABILITIES deviceCaps;

    if (SDL_XInput_GetDeviceCapabilities(device_index, &deviceCaps) != 0) {
        /* Uh oh.  Device capabilities couldn't be retrieved.  Return to the
           caller.  SDL_SetError() has already been invoked (with relevant
           information).
         */
        return -1;
    }

    /* For now, only game pads are supported.  If the device is something other
       than that, return an error to the caller.
     */
    if (deviceCaps.Type != XINPUT_DEVTYPE_GAMEPAD) {
        return SDL_SetError("a device is connected (at joystick index, %d), but it is of an unknown device type (deviceCaps.Flags=%ul)",
            device_index, (unsigned int)deviceCaps.Flags);
    }

    /* Create the joystick data structure */
    joystick->instance_id = device_index;
    joystick->hwdata = &g_XInputData[device_index];

    // The XInput API has a hard coded button/axis mapping, so we just match it
    joystick->naxes = 6;
    joystick->nbuttons = 15;
    joystick->nballs = 0;
    joystick->nhats = 0;

    /* We're done! */
    return (0);
}

/* Function to determine is this joystick is attached to the system right now */
SDL_bool SDL_SYS_JoystickAttached(SDL_Joystick *joystick)
{
    SDL_bool isDeviceConnected;
    SDL_LockMutex(g_DeviceInfoLock);
    isDeviceConnected = joystick->hwdata->isDeviceConnected;
    SDL_UnlockMutex(g_DeviceInfoLock);
    return isDeviceConnected;
}

/* Function to return > 0 if a bit array of buttons differs after applying a mask
*/
static int ButtonChanged( int ButtonsNow, int ButtonsPrev, int ButtonMask )
{
    return ( ButtonsNow & ButtonMask ) != ( ButtonsPrev & ButtonMask );
}

/* This is an almost-identical copy of UpdateXInputJoystickState from the
   DirectInput + XInput backend.

   TODO, WinRT: look into making the DirectInput+Xinput and WinRT/XInput joystick backends share more code, without duplication
   TODO, WinRT: consider adding support for the "old" XInput controller mapping (via SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING)
*/
static void
UpdateXInputJoystickState(SDL_Joystick * joystick, XINPUT_STATE *pXInputState)
{
    static WORD s_XInputButtons[] = {
        XINPUT_GAMEPAD_A, XINPUT_GAMEPAD_B, XINPUT_GAMEPAD_X, XINPUT_GAMEPAD_Y,
        XINPUT_GAMEPAD_LEFT_SHOULDER, XINPUT_GAMEPAD_RIGHT_SHOULDER, XINPUT_GAMEPAD_BACK, XINPUT_GAMEPAD_START,
        XINPUT_GAMEPAD_LEFT_THUMB, XINPUT_GAMEPAD_RIGHT_THUMB,
        XINPUT_GAMEPAD_GUIDE
    };
    WORD wButtons = pXInputState->Gamepad.wButtons;
    Uint8 button;
    Uint8 hat = SDL_HAT_CENTERED;

    SDL_PrivateJoystickAxis(joystick, 0, (Sint16)pXInputState->Gamepad.sThumbLX);
    SDL_PrivateJoystickAxis(joystick, 1, (Sint16)(-SDL_max(-32767, pXInputState->Gamepad.sThumbLY)));
    SDL_PrivateJoystickAxis(joystick, 2, (Sint16)(((int)pXInputState->Gamepad.bLeftTrigger * 65535 / 255) - 32768));
    SDL_PrivateJoystickAxis(joystick, 3, (Sint16)pXInputState->Gamepad.sThumbRX);
    SDL_PrivateJoystickAxis(joystick, 4, (Sint16)(-SDL_max(-32767, pXInputState->Gamepad.sThumbRY)));
    SDL_PrivateJoystickAxis(joystick, 5, (Sint16)(((int)pXInputState->Gamepad.bRightTrigger * 65535 / 255) - 32768));

    for (button = 0; button < SDL_arraysize(s_XInputButtons); ++button) {
        SDL_PrivateJoystickButton(joystick, button, (wButtons & s_XInputButtons[button]) ? SDL_PRESSED : SDL_RELEASED);
    }

    if (wButtons & XINPUT_GAMEPAD_DPAD_UP) {
        hat |= SDL_HAT_UP;
    }
    if (wButtons & XINPUT_GAMEPAD_DPAD_DOWN) {
        hat |= SDL_HAT_DOWN;
    }
    if (wButtons & XINPUT_GAMEPAD_DPAD_LEFT) {
        hat |= SDL_HAT_LEFT;
    }
    if (wButtons & XINPUT_GAMEPAD_DPAD_RIGHT) {
        hat |= SDL_HAT_RIGHT;
    }
    SDL_PrivateJoystickHat(joystick, 0, hat);
}

/* Function to update the state of a joystick - called as a device poll.
 * This function shouldn't update the joystick structure directly,
 * but instead should call SDL_PrivateJoystick*() to deliver events
 * and update joystick device state.
 */
void
SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)
{
    HRESULT result;
    XINPUT_STATE prevXInputState;

    SDL_LockMutex(g_DeviceInfoLock);

    /* Before polling for new data, make note of the old data */
    prevXInputState = joystick->hwdata->XInputState;

    /* Poll for new data */
    result = XInputGetState(joystick->hwdata->userIndex, &joystick->hwdata->XInputState);
    if (result == ERROR_DEVICE_NOT_CONNECTED) {
        if (joystick->hwdata->isDeviceConnected) {
            joystick->hwdata->isDeviceConnected = SDL_FALSE;
            joystick->hwdata->isDeviceRemovalEventPending = SDL_TRUE;
            /* TODO, WinRT: make sure isDeviceRemovalEventPending gets cleared as appropriate, and that quick re-plugs don't cause trouble */
        }
        SDL_UnlockMutex(g_DeviceInfoLock);
        return;
    }

    /* Make sure the device is marked as connected */
    joystick->hwdata->isDeviceConnected = SDL_TRUE;

    // only fire events if the data changed from last time
    if ( joystick->hwdata->XInputState.dwPacketNumber != 0 
        && joystick->hwdata->XInputState.dwPacketNumber != prevXInputState.dwPacketNumber )
    {
        XINPUT_STATE *pXInputState = &joystick->hwdata->XInputState;
        UpdateXInputJoystickState(joystick, pXInputState);
    }

    SDL_UnlockMutex(g_DeviceInfoLock);
}

/* Function to close a joystick after use */
void
SDL_SYS_JoystickClose(SDL_Joystick * joystick)
{
    /* Clear cached button data on the joystick */
    SDL_LockMutex(g_DeviceInfoLock);
    SDL_zero(joystick->hwdata->XInputState);
    SDL_UnlockMutex(g_DeviceInfoLock);

    /* There's need to free 'hwdata', as it's a pointer to a global array.
       The field will be cleared anyways, just to indicate that it's not
       currently needed.
     */
    joystick->hwdata = NULL;
}

/* Function to perform any system-specific joystick related cleanup */
void
SDL_SYS_JoystickQuit(void)
{
    /* Tell the joystick detection thread to stop, then wait for it to finish */
    SDL_LockMutex(g_DeviceInfoLock);
    g_DeviceDetectionQuit = SDL_TRUE;
    SDL_UnlockMutex(g_DeviceInfoLock);
    SDL_WaitThread(g_DeviceDetectionThread, NULL);

    /* Clean up device-detection stuff */
    SDL_DestroyMutex(g_DeviceInfoLock);
    g_DeviceInfoLock = NULL;
    g_DeviceDetectionThread = NULL;
    g_DeviceDetectionQuit = SDL_FALSE;

    return;
}

SDL_JoystickGUID SDL_SYS_JoystickGetDeviceGUID( int device_index )
{
    SDL_JoystickGUID guid;
    // the GUID is just the first 16 chars of the name for now
    const char *name = SDL_SYS_JoystickNameForDeviceIndex( device_index );
    SDL_zero( guid );
    SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) );
    return guid;
}


SDL_JoystickGUID SDL_SYS_JoystickGetGUID(SDL_Joystick * joystick)
{
    SDL_JoystickGUID guid;
    // the GUID is just the first 16 chars of the name for now
    const char *name = joystick->name;
    SDL_zero( guid );
    SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) );
    return guid;
}

SDL_bool SDL_SYS_IsXInputDeviceIndex(int device_index)
{
    /* The XInput-capable DirectInput joystick backend implements the same
       function (SDL_SYS_IsXInputDeviceIndex), however in that case, not all
       joystick devices are XInput devices.  In this case, with the
       WinRT-enabled XInput-only backend, all "joystick" devices are XInput
       devices.
     */
    return SDL_TRUE;
}

SDL_bool SDL_SYS_IsXInputGamepad_DeviceIndex(int device_index)
{
    XINPUT_CAPABILITIES deviceCaps;

    if (SDL_XInput_GetDeviceCapabilities(device_index, &deviceCaps) != 0) {
        return SDL_FALSE;
    }

    return (deviceCaps.SubType == XINPUT_DEVSUBTYPE_GAMEPAD);
}

#endif /* SDL_JOYSTICK_XINPUT */

/* vi: set ts=4 sw=4 expandtab: */