Fixed crash if initialization of EGL failed but was tried again later.

The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly
uninitialized data structure if loading the library first failed. A later try to
use EGL then skipped initialization and assumed it was previously successful
because the data structure now already existed. This led to at least one crash
in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was
dereferenced to make a call to eglBindAPI().

src/haptic/SDL_haptic.c

@@ -0,0 +1,848 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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"
+
+#include "SDL_syshaptic.h"
+#include "SDL_haptic_c.h"
+#include "../joystick/SDL_joystick_c.h" /* For SDL_PrivateJoystickValid */
+#include "SDL_assert.h"
+
+SDL_Haptic *SDL_haptics = NULL;
+
+
+/*
+ * Initializes the Haptic devices.
+ */
+int
+SDL_HapticInit(void)
+{
+    int status;
+
+    status = SDL_SYS_HapticInit();
+    if (status >= 0) {
+        status = 0;
+    }
+
+    return status;
+}
+
+
+/*
+ * Checks to see if the haptic device is valid
+ */
+static int
+ValidHaptic(SDL_Haptic * haptic)
+{
+    int valid;
+    SDL_Haptic *hapticlist;
+
+    valid = 0;
+    if (haptic != NULL) {
+        hapticlist = SDL_haptics;
+        while ( hapticlist )
+        {
+            if (hapticlist == haptic) {
+                valid = 1;
+                break;
+            }
+            hapticlist = hapticlist->next;
+        }
+    }
+
+    /* Create the error here. */
+    if (valid == 0) {
+        SDL_SetError("Haptic: Invalid haptic device identifier");
+    }
+
+    return valid;
+}
+
+
+/*
+ * Returns the number of available devices.
+ */
+int
+SDL_NumHaptics(void)
+{
+    return SDL_SYS_NumHaptics();
+}
+
+
+/*
+ * Gets the name of a Haptic device by index.
+ */
+const char *
+SDL_HapticName(int device_index)
+{
+    if ((device_index < 0) || (device_index >= SDL_NumHaptics())) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_NumHaptics());
+        return NULL;
+    }
+    return SDL_SYS_HapticName(device_index);
+}
+
+
+/*
+ * Opens a Haptic device.
+ */
+SDL_Haptic *
+SDL_HapticOpen(int device_index)
+{
+    SDL_Haptic *haptic;
+    SDL_Haptic *hapticlist;
+
+    if ((device_index < 0) || (device_index >= SDL_NumHaptics())) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_NumHaptics());
+        return NULL;
+    }
+
+    hapticlist = SDL_haptics;
+    /* If the haptic is already open, return it
+    * TODO: Should we create haptic instance IDs like the Joystick API?
+    */
+    while ( hapticlist )
+    {
+        if (device_index == hapticlist->index) {
+            haptic = hapticlist;
+            ++haptic->ref_count;
+            return haptic;
+        }
+        hapticlist = hapticlist->next;
+    }
+
+    /* Create the haptic device */
+    haptic = (SDL_Haptic *) SDL_malloc((sizeof *haptic));
+    if (haptic == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize the haptic device */
+    SDL_memset(haptic, 0, (sizeof *haptic));
+    haptic->rumble_id = -1;
+    haptic->index = device_index;
+    if (SDL_SYS_HapticOpen(haptic) < 0) {
+        SDL_free(haptic);
+        return NULL;
+    }
+
+    /* Add haptic to list */
+    ++haptic->ref_count;
+    /* Link the haptic in the list */
+    haptic->next = SDL_haptics;
+    SDL_haptics = haptic;
+
+    /* Disable autocenter and set gain to max. */
+    if (haptic->supported & SDL_HAPTIC_GAIN)
+        SDL_HapticSetGain(haptic, 100);
+    if (haptic->supported & SDL_HAPTIC_AUTOCENTER)
+        SDL_HapticSetAutocenter(haptic, 0);
+
+    return haptic;
+}
+
+
+/*
+ * Returns 1 if the device has been opened.
+ */
+int
+SDL_HapticOpened(int device_index)
+{
+    int opened;
+    SDL_Haptic *hapticlist;
+
+    /* Make sure it's valid. */
+    if ((device_index < 0) || (device_index >= SDL_NumHaptics())) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_NumHaptics());
+        return 0;
+    }
+
+    opened = 0;
+    hapticlist = SDL_haptics;
+    /* TODO Should this use an instance ID? */
+    while ( hapticlist )
+    {
+        if (hapticlist->index == (Uint8) device_index) {
+            opened = 1;
+            break;
+        }
+        hapticlist = hapticlist->next;
+    }
+    return opened;
+}
+
+
+/*
+ * Returns the index to a haptic device.
+ */
+int
+SDL_HapticIndex(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->index;
+}
+
+
+/*
+ * Returns SDL_TRUE if mouse is haptic, SDL_FALSE if it isn't.
+ */
+int
+SDL_MouseIsHaptic(void)
+{
+    if (SDL_SYS_HapticMouse() < 0)
+        return SDL_FALSE;
+    return SDL_TRUE;
+}
+
+
+/*
+ * Returns the haptic device if mouse is haptic or NULL elsewise.
+ */
+SDL_Haptic *
+SDL_HapticOpenFromMouse(void)
+{
+    int device_index;
+
+    device_index = SDL_SYS_HapticMouse();
+
+    if (device_index < 0) {
+        SDL_SetError("Haptic: Mouse isn't a haptic device.");
+        return NULL;
+    }
+
+    return SDL_HapticOpen(device_index);
+}
+
+
+/*
+ * Returns SDL_TRUE if joystick has haptic features.
+ */
+int
+SDL_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    int ret;
+
+    /* Must be a valid joystick */
+    if (!SDL_PrivateJoystickValid(joystick)) {
+        return -1;
+    }
+
+    ret = SDL_SYS_JoystickIsHaptic(joystick);
+
+    if (ret > 0)
+        return SDL_TRUE;
+    else if (ret == 0)
+        return SDL_FALSE;
+    else
+        return -1;
+}
+
+
+/*
+ * Opens a haptic device from a joystick.
+ */
+SDL_Haptic *
+SDL_HapticOpenFromJoystick(SDL_Joystick * joystick)
+{
+    SDL_Haptic *haptic;
+    SDL_Haptic *hapticlist;
+
+    /* Make sure there is room. */
+    if (SDL_NumHaptics() <= 0) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_NumHaptics());
+        return NULL;
+    }
+
+    /* Must be a valid joystick */
+    if (!SDL_PrivateJoystickValid(joystick)) {
+        SDL_SetError("Haptic: Joystick isn't valid.");
+        return NULL;
+    }
+
+    /* Joystick must be haptic */
+    if (SDL_SYS_JoystickIsHaptic(joystick) <= 0) {
+        SDL_SetError("Haptic: Joystick isn't a haptic device.");
+        return NULL;
+    }
+
+    hapticlist = SDL_haptics;
+    /* Check to see if joystick's haptic is already open */
+    while ( hapticlist )
+    {
+        if (SDL_SYS_JoystickSameHaptic(hapticlist, joystick)) {
+            haptic = hapticlist;
+            ++haptic->ref_count;
+            return haptic;
+        }
+        hapticlist = hapticlist->next;
+    }
+
+    /* Create the haptic device */
+    haptic = (SDL_Haptic *) SDL_malloc((sizeof *haptic));
+    if (haptic == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize the haptic device */
+    SDL_memset(haptic, 0, sizeof(SDL_Haptic));
+    haptic->rumble_id = -1;
+    if (SDL_SYS_HapticOpenFromJoystick(haptic, joystick) < 0) {
+        SDL_free(haptic);
+        return NULL;
+    }
+
+    /* Add haptic to list */
+    ++haptic->ref_count;
+    /* Link the haptic in the list */
+    haptic->next = SDL_haptics;
+    SDL_haptics = haptic;
+
+    return haptic;
+}
+
+
+/*
+ * Closes a SDL_Haptic device.
+ */
+void
+SDL_HapticClose(SDL_Haptic * haptic)
+{
+    int i;
+    SDL_Haptic *hapticlist;
+    SDL_Haptic *hapticlistprev;
+
+    /* Must be valid */
+    if (!ValidHaptic(haptic)) {
+        return;
+    }
+
+    /* Check if it's still in use */
+    if (--haptic->ref_count > 0) {
+        return;
+    }
+
+    /* Close it, properly removing effects if needed */
+    for (i = 0; i < haptic->neffects; i++) {
+        if (haptic->effects[i].hweffect != NULL) {
+            SDL_HapticDestroyEffect(haptic, i);
+        }
+    }
+    SDL_SYS_HapticClose(haptic);
+
+    /* Remove from the list */
+    hapticlist = SDL_haptics;
+    hapticlistprev = NULL;
+    while ( hapticlist )
+    {
+        if (haptic == hapticlist)
+        {
+            if ( hapticlistprev )
+            {
+                /* unlink this entry */
+                hapticlistprev->next = hapticlist->next;
+            }
+            else
+            {
+                SDL_haptics = haptic->next;
+            }
+
+            break;
+        }
+        hapticlistprev = hapticlist;
+        hapticlist = hapticlist->next;
+    }
+
+    /* Free */
+    SDL_free(haptic);
+}
+
+/*
+ * Cleans up after the subsystem.
+ */
+void
+SDL_HapticQuit(void)
+{
+    SDL_SYS_HapticQuit();
+    SDL_assert(SDL_haptics == NULL);
+    SDL_haptics = NULL;
+}
+
+/*
+ * Returns the number of effects a haptic device has.
+ */
+int
+SDL_HapticNumEffects(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->neffects;
+}
+
+
+/*
+ * Returns the number of effects a haptic device can play.
+ */
+int
+SDL_HapticNumEffectsPlaying(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->nplaying;
+}
+
+
+/*
+ * Returns supported effects by the device.
+ */
+unsigned int
+SDL_HapticQuery(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return 0; /* same as if no effects were supported */
+    }
+
+    return haptic->supported;
+}
+
+
+/*
+ * Returns the number of axis on the device.
+ */
+int
+SDL_HapticNumAxes(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->naxes;
+}
+
+/*
+ * Checks to see if the device can support the effect.
+ */
+int
+SDL_HapticEffectSupported(SDL_Haptic * haptic, SDL_HapticEffect * effect)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & effect->type) != 0)
+        return SDL_TRUE;
+    return SDL_FALSE;
+}
+
+/*
+ * Creates a new haptic effect.
+ */
+int
+SDL_HapticNewEffect(SDL_Haptic * haptic, SDL_HapticEffect * effect)
+{
+    int i;
+
+    /* Check for device validity. */
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    /* Check to see if effect is supported */
+    if (SDL_HapticEffectSupported(haptic, effect) == SDL_FALSE) {
+        return SDL_SetError("Haptic: Effect not supported by haptic device.");
+    }
+
+    /* See if there's a free slot */
+    for (i = 0; i < haptic->neffects; i++) {
+        if (haptic->effects[i].hweffect == NULL) {
+
+            /* Now let the backend create the real effect */
+            if (SDL_SYS_HapticNewEffect(haptic, &haptic->effects[i], effect)
+                != 0) {
+                return -1;      /* Backend failed to create effect */
+            }
+
+            SDL_memcpy(&haptic->effects[i].effect, effect,
+                       sizeof(SDL_HapticEffect));
+            return i;
+        }
+    }
+
+    return SDL_SetError("Haptic: Device has no free space left.");
+}
+
+/*
+ * Checks to see if an effect is valid.
+ */
+static int
+ValidEffect(SDL_Haptic * haptic, int effect)
+{
+    if ((effect < 0) || (effect >= haptic->neffects)) {
+        SDL_SetError("Haptic: Invalid effect identifier.");
+        return 0;
+    }
+    return 1;
+}
+
+/*
+ * Updates an effect.
+ */
+int
+SDL_HapticUpdateEffect(SDL_Haptic * haptic, int effect,
+                       SDL_HapticEffect * data)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Can't change type dynamically. */
+    if (data->type != haptic->effects[effect].effect.type) {
+        return SDL_SetError("Haptic: Updating effect type is illegal.");
+    }
+
+    /* Updates the effect */
+    if (SDL_SYS_HapticUpdateEffect(haptic, &haptic->effects[effect], data) <
+        0) {
+        return -1;
+    }
+
+    SDL_memcpy(&haptic->effects[effect].effect, data,
+               sizeof(SDL_HapticEffect));
+    return 0;
+}
+
+
+/*
+ * Runs the haptic effect on the device.
+ */
+int
+SDL_HapticRunEffect(SDL_Haptic * haptic, int effect, Uint32 iterations)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Run the effect */
+    if (SDL_SYS_HapticRunEffect(haptic, &haptic->effects[effect], iterations)
+        < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Stops the haptic effect on the device.
+ */
+int
+SDL_HapticStopEffect(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Stop the effect */
+    if (SDL_SYS_HapticStopEffect(haptic, &haptic->effects[effect]) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Gets rid of a haptic effect.
+ */
+void
+SDL_HapticDestroyEffect(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return;
+    }
+
+    /* Not allocated */
+    if (haptic->effects[effect].hweffect == NULL) {
+        return;
+    }
+
+    SDL_SYS_HapticDestroyEffect(haptic, &haptic->effects[effect]);
+}
+
+/*
+ * Gets the status of a haptic effect.
+ */
+int
+SDL_HapticGetEffectStatus(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_STATUS) == 0) {
+        return SDL_SetError("Haptic: Device does not support status queries.");
+    }
+
+    return SDL_SYS_HapticGetEffectStatus(haptic, &haptic->effects[effect]);
+}
+
+/*
+ * Sets the global gain of the device.
+ */
+int
+SDL_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    const char *env;
+    int real_gain, max_gain;
+
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_GAIN) == 0) {
+        return SDL_SetError("Haptic: Device does not support setting gain.");
+    }
+
+    if ((gain < 0) || (gain > 100)) {
+        return SDL_SetError("Haptic: Gain must be between 0 and 100.");
+    }
+
+    /* We use the envvar to get the maximum gain. */
+    env = SDL_getenv("SDL_HAPTIC_GAIN_MAX");
+    if (env != NULL) {
+        max_gain = SDL_atoi(env);
+
+        /* Check for sanity. */
+        if (max_gain < 0)
+            max_gain = 0;
+        else if (max_gain > 100)
+            max_gain = 100;
+
+        /* We'll scale it linearly with SDL_HAPTIC_GAIN_MAX */
+        real_gain = (gain * max_gain) / 100;
+    } else {
+        real_gain = gain;
+    }
+
+    if (SDL_SYS_HapticSetGain(haptic, real_gain) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Makes the device autocenter, 0 disables.
+ */
+int
+SDL_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_AUTOCENTER) == 0) {
+        return SDL_SetError("Haptic: Device does not support setting autocenter.");
+    }
+
+    if ((autocenter < 0) || (autocenter > 100)) {
+        return SDL_SetError("Haptic: Autocenter must be between 0 and 100.");
+    }
+
+    if (SDL_SYS_HapticSetAutocenter(haptic, autocenter) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Pauses the haptic device.
+ */
+int
+SDL_HapticPause(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_PAUSE) == 0) {
+        return SDL_SetError("Haptic: Device does not support setting pausing.");
+    }
+
+    return SDL_SYS_HapticPause(haptic);
+}
+
+/*
+ * Unpauses the haptic device.
+ */
+int
+SDL_HapticUnpause(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_PAUSE) == 0) {
+        return 0;               /* Not going to be paused, so we pretend it's unpaused. */
+    }
+
+    return SDL_SYS_HapticUnpause(haptic);
+}
+
+/*
+ * Stops all the currently playing effects.
+ */
+int
+SDL_HapticStopAll(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return SDL_SYS_HapticStopAll(haptic);
+}
+
+/*
+ * Checks to see if rumble is supported.
+ */
+int
+SDL_HapticRumbleSupported(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    /* Most things can use SINE, but XInput only has LEFTRIGHT. */
+    return ((haptic->supported & (SDL_HAPTIC_SINE|SDL_HAPTIC_LEFTRIGHT)) != 0);
+}
+
+/*
+ * Initializes the haptic device for simple rumble playback.
+ */
+int
+SDL_HapticRumbleInit(SDL_Haptic * haptic)
+{
+    SDL_HapticEffect *efx = &haptic->rumble_effect;
+
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    /* Already allocated. */
+    if (haptic->rumble_id >= 0) {
+        return 0;
+    }
+
+    SDL_zerop(efx);
+    if (haptic->supported & SDL_HAPTIC_SINE) {
+        efx->type = SDL_HAPTIC_SINE;
+        efx->periodic.period = 1000;
+        efx->periodic.magnitude = 0x4000;
+        efx->periodic.length = 5000;
+        efx->periodic.attack_length = 0;
+        efx->periodic.fade_length = 0;
+    } else if (haptic->supported & SDL_HAPTIC_LEFTRIGHT) {  /* XInput? */
+        efx->type = SDL_HAPTIC_LEFTRIGHT;
+        efx->leftright.length = 5000;
+        efx->leftright.large_magnitude = 0x4000;
+        efx->leftright.small_magnitude = 0x4000;
+    } else {
+        return SDL_SetError("Device doesn't support rumble");
+    }
+
+    haptic->rumble_id = SDL_HapticNewEffect(haptic, &haptic->rumble_effect);
+    if (haptic->rumble_id >= 0) {
+        return 0;
+    }
+    return -1;
+}
+
+/*
+ * Runs simple rumble on a haptic device
+ */
+int
+SDL_HapticRumblePlay(SDL_Haptic * haptic, float strength, Uint32 length)
+{
+    SDL_HapticEffect *efx;
+    Sint16 magnitude;
+
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if (haptic->rumble_id < 0) {
+        return SDL_SetError("Haptic: Rumble effect not initialized on haptic device");
+    }
+
+    /* Clamp strength. */
+    if (strength > 1.0f) {
+        strength = 1.0f;
+    } else if (strength < 0.0f) {
+        strength = 0.0f;
+    }
+    magnitude = (Sint16)(32767.0f*strength);
+
+    efx = &haptic->rumble_effect;
+    if (efx->type == SDL_HAPTIC_SINE) {
+        efx->periodic.magnitude = magnitude;
+        efx->periodic.length = length;
+    } else if (efx->type == SDL_HAPTIC_LEFTRIGHT) {
+        efx->leftright.small_magnitude = efx->leftright.large_magnitude = magnitude;
+        efx->leftright.length = length;
+    } else {
+        SDL_assert(0 && "This should have been caught elsewhere");
+    }
+
+    if (SDL_HapticUpdateEffect(haptic, haptic->rumble_id, &haptic->rumble_effect) < 0) {
+        return -1;
+    }
+
+    return SDL_HapticRunEffect(haptic, haptic->rumble_id, 1);
+}
+
+/*
+ * Stops the simple rumble on a haptic device.
+ */
+int
+SDL_HapticRumbleStop(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if (haptic->rumble_id < 0) {
+        return SDL_SetError("Haptic: Rumble effect not initialized on haptic device");
+    }
+
+    return SDL_HapticStopEffect(haptic, haptic->rumble_id);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

src/haptic/SDL_haptic_c.h

@@ -0,0 +1,25 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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.
+*/
+
+extern int SDL_HapticInit(void);
+extern void SDL_HapticQuit(void);
+
+/* vi: set ts=4 sw=4 expandtab: */

src/haptic/SDL_syshaptic.h

@@ -0,0 +1,208 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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"
+
+#ifndef _SDL_syshaptic_h
+#define _SDL_syshaptic_h
+
+#include "SDL_haptic.h"
+
+
+struct haptic_effect
+{
+    SDL_HapticEffect effect;    /* The current event */
+    struct haptic_hweffect *hweffect;   /* The hardware behind the event */
+};
+
+/*
+ * The real SDL_Haptic struct.
+ */
+struct _SDL_Haptic
+{
+    Uint8 index;                /* Stores index it is attached to */
+
+    struct haptic_effect *effects;      /* Allocated effects */
+    int neffects;               /* Maximum amount of effects */
+    int nplaying;               /* Maximum amount of effects to play at the same time */
+    unsigned int supported;     /* Supported effects */
+    int naxes;                  /* Number of axes on the device. */
+
+    struct haptic_hwdata *hwdata;       /* Driver dependent */
+    int ref_count;              /* Count for multiple opens */
+
+    int rumble_id;              /* ID of rumble effect for simple rumble API. */
+    SDL_HapticEffect rumble_effect; /* Rumble effect. */
+    struct _SDL_Haptic *next; /* pointer to next haptic we have allocated */
+};
+
+/*
+ * Scans the system for haptic devices.
+ *
+ * Returns number of devices on success, -1 on error.
+ */
+extern int SDL_SYS_HapticInit(void);
+
+/* Function to return the number of haptic devices plugged in right now */
+extern int SDL_SYS_NumHaptics();
+
+/*
+ * Gets the device dependent name of the haptic device
+ */
+extern const char *SDL_SYS_HapticName(int index);
+
+/*
+ * Opens the haptic device for usage.  The haptic device should have
+ * the index value set previously.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticOpen(SDL_Haptic * haptic);
+
+/*
+ * Returns the index of the haptic core pointer or -1 if none is found.
+ */
+int SDL_SYS_HapticMouse(void);
+
+/*
+ * Checks to see if the joystick has haptic capabilities.
+ *
+ * Returns >0 if haptic capabilities are detected, 0 if haptic
+ * capabilities aren't detected and -1 on error.
+ */
+extern int SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick);
+
+/*
+ * Opens the haptic device for usage using the same device as
+ * the joystick.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic,
+                                          SDL_Joystick * joystick);
+/*
+ * Checks to see if haptic device and joystick device are the same.
+ *
+ * Returns 1 if they are the same, 0 if they aren't.
+ */
+extern int SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic,
+                                      SDL_Joystick * joystick);
+
+/*
+ * Closes a haptic device after usage.
+ */
+extern void SDL_SYS_HapticClose(SDL_Haptic * haptic);
+
+/*
+ * Performs a cleanup on the haptic subsystem.
+ */
+extern void SDL_SYS_HapticQuit(void);
+
+/*
+ * Creates a new haptic effect on the haptic device using base
+ * as a template for the effect.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticNewEffect(SDL_Haptic * haptic,
+                                   struct haptic_effect *effect,
+                                   SDL_HapticEffect * base);
+
+/*
+ * Updates the haptic effect on the haptic device using data
+ * as a template.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                                      struct haptic_effect *effect,
+                                      SDL_HapticEffect * data);
+
+/*
+ * Runs the effect on the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticRunEffect(SDL_Haptic * haptic,
+                                   struct haptic_effect *effect,
+                                   Uint32 iterations);
+
+/*
+ * Stops the effect on the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticStopEffect(SDL_Haptic * haptic,
+                                    struct haptic_effect *effect);
+
+/*
+ * Cleanups up the effect on the haptic device.
+ */
+extern void SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic,
+                                        struct haptic_effect *effect);
+
+/*
+ * Queries the device for the status of effect.
+ *
+ * Returns 0 if device is stopped, >0 if device is playing and
+ * -1 on error.
+ */
+extern int SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                                         struct haptic_effect *effect);
+
+/*
+ * Sets the global gain of the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain);
+
+/*
+ * Sets the autocenter feature of the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter);
+
+/*
+ * Pauses the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticPause(SDL_Haptic * haptic);
+
+/*
+ * Unpauses the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticUnpause(SDL_Haptic * haptic);
+
+/*
+ * Stops all the currently playing haptic effects on the device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticStopAll(SDL_Haptic * haptic);
+
+#endif /* _SDL_syshaptic_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/haptic/darwin/SDL_syshaptic_c.h

@@ -0,0 +1,26 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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.
+*/
+
+extern int MacHaptic_MaybeAddDevice( io_object_t device );
+extern int MacHaptic_MaybeRemoveDevice( io_object_t device );
+
+/* vi: set ts=4 sw=4 expandtab: */
+

src/haptic/dummy/SDL_syshaptic.c

@@ -0,0 +1,186 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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 defined(SDL_HAPTIC_DUMMY) || defined(SDL_HAPTIC_DISABLED)
+
+#include "SDL_haptic.h"
+#include "../SDL_syshaptic.h"
+
+
+static int
+SDL_SYS_LogicError(void)
+{
+    return SDL_SetError("Logic error: No haptic devices available.");
+}
+
+
+int
+SDL_SYS_HapticInit(void)
+{
+    return 0;
+}
+
+int
+SDL_SYS_NumHaptics(void)
+{
+    return 0;
+}
+
+const char *
+SDL_SYS_HapticName(int index)
+{
+    SDL_SYS_LogicError();
+    return NULL;
+}
+
+
+int
+SDL_SYS_HapticOpen(SDL_Haptic * haptic)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+int
+SDL_SYS_HapticMouse(void)
+{
+    return -1;
+}
+
+
+int
+SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    return 0;
+}
+
+
+int
+SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+int
+SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return 0;
+}
+
+
+void
+SDL_SYS_HapticClose(SDL_Haptic * haptic)
+{
+    return;
+}
+
+
+void
+SDL_SYS_HapticQuit(void)
+{
+    return;
+}
+
+
+int
+SDL_SYS_HapticNewEffect(SDL_Haptic * haptic,
+                        struct haptic_effect *effect, SDL_HapticEffect * base)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+int
+SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                           struct haptic_effect *effect,
+                           SDL_HapticEffect * data)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+int
+SDL_SYS_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        Uint32 iterations)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+int
+SDL_SYS_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+void
+SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    SDL_SYS_LogicError();
+    return;
+}
+
+
+int
+SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                              struct haptic_effect *effect)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+int
+SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    return SDL_SYS_LogicError();
+}
+
+
+int
+SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    return SDL_SYS_LogicError();
+}
+
+int
+SDL_SYS_HapticPause(SDL_Haptic * haptic)
+{
+    return SDL_SYS_LogicError();
+}
+
+int
+SDL_SYS_HapticUnpause(SDL_Haptic * haptic)
+{
+    return SDL_SYS_LogicError();
+}
+
+int
+SDL_SYS_HapticStopAll(SDL_Haptic * haptic)
+{
+    return SDL_SYS_LogicError();
+}
+
+#endif /* SDL_HAPTIC_DUMMY || SDL_HAPTIC_DISABLED */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/haptic/windows/SDL_dinputhaptic_c.h

@@ -0,0 +1,47 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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"
+
+#include "SDL_haptic.h"
+#include "SDL_windowshaptic_c.h"
+
+
+extern int SDL_DINPUT_HapticInit(void);
+extern int SDL_DINPUT_MaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance);
+extern int SDL_DINPUT_MaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance);
+extern int SDL_DINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item);
+extern int SDL_DINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick);
+extern int SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick);
+extern void SDL_DINPUT_HapticClose(SDL_Haptic * haptic);
+extern void SDL_DINPUT_HapticQuit(void);
+extern int SDL_DINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base);
+extern int SDL_DINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data);
+extern int SDL_DINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations);
+extern int SDL_DINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect);
+extern void SDL_DINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect);
+extern int SDL_DINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect);
+extern int SDL_DINPUT_HapticSetGain(SDL_Haptic * haptic, int gain);
+extern int SDL_DINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter);
+extern int SDL_DINPUT_HapticPause(SDL_Haptic * haptic);
+extern int SDL_DINPUT_HapticUnpause(SDL_Haptic * haptic);
+extern int SDL_DINPUT_HapticStopAll(SDL_Haptic * haptic);
+
+/* vi: set ts=4 sw=4 expandtab: */

src/haptic/windows/SDL_windowshaptic.c

@@ -0,0 +1,449 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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_HAPTIC_DINPUT || SDL_HAPTIC_XINPUT
+
+#include "SDL_assert.h"
+#include "SDL_thread.h"
+#include "SDL_mutex.h"
+#include "SDL_timer.h"
+#include "SDL_hints.h"
+#include "SDL_haptic.h"
+#include "../SDL_syshaptic.h"
+#include "SDL_joystick.h"
+#include "../../joystick/SDL_sysjoystick.h"     /* For the real SDL_Joystick */
+#include "../../joystick/windows/SDL_windowsjoystick_c.h"      /* For joystick hwdata */
+#include "../../joystick/windows/SDL_xinputjoystick_c.h"      /* For xinput rumble */
+
+#include "SDL_windowshaptic_c.h"
+#include "SDL_dinputhaptic_c.h"
+#include "SDL_xinputhaptic_c.h"
+
+
+/*
+ * Internal stuff.
+ */
+SDL_hapticlist_item *SDL_hapticlist = NULL;
+static SDL_hapticlist_item *SDL_hapticlist_tail = NULL;
+static int numhaptics = 0;
+
+
+/*
+ * Initializes the haptic subsystem.
+ */
+int
+SDL_SYS_HapticInit(void)
+{
+    if (SDL_DINPUT_HapticInit() < 0) {
+        return -1;
+    }
+    if (SDL_XINPUT_HapticInit() < 0) {
+        return -1;
+    }
+    return numhaptics;
+}
+
+int
+SDL_SYS_AddHapticDevice(SDL_hapticlist_item *item)
+{
+    if (SDL_hapticlist_tail == NULL) {
+        SDL_hapticlist = SDL_hapticlist_tail = item;
+    } else {
+        SDL_hapticlist_tail->next = item;
+        SDL_hapticlist_tail = item;
+    }
+
+    /* Device has been added. */
+    ++numhaptics;
+
+    return numhaptics;
+}
+
+int
+SDL_SYS_RemoveHapticDevice(SDL_hapticlist_item *prev, SDL_hapticlist_item *item)
+{
+    const int retval = item->haptic ? item->haptic->index : -1;
+    if (prev != NULL) {
+        prev->next = item->next;
+    } else {
+        SDL_assert(SDL_hapticlist == item);
+        SDL_hapticlist = item->next;
+    }
+    if (item == SDL_hapticlist_tail) {
+        SDL_hapticlist_tail = prev;
+    }
+    --numhaptics;
+    /* !!! TODO: Send a haptic remove event? */
+    SDL_free(item);
+    return retval;
+}
+
+int
+SDL_SYS_NumHaptics()
+{
+    return numhaptics;
+}
+
+static SDL_hapticlist_item *
+HapticByDevIndex(int device_index)
+{
+    SDL_hapticlist_item *item = SDL_hapticlist;
+
+    if ((device_index < 0) || (device_index >= numhaptics)) {
+        return NULL;
+    }
+
+    while (device_index > 0) {
+        SDL_assert(item != NULL);
+        --device_index;
+        item = item->next;
+    }
+    return item;
+}
+
+/*
+ * Return the name of a haptic device, does not need to be opened.
+ */
+const char *
+SDL_SYS_HapticName(int index)
+{
+    SDL_hapticlist_item *item = HapticByDevIndex(index);
+    return item->name;
+}
+
+/*
+ * Opens a haptic device for usage.
+ */
+int
+SDL_SYS_HapticOpen(SDL_Haptic * haptic)
+{
+    SDL_hapticlist_item *item = HapticByDevIndex(haptic->index);
+    if (item->bXInputHaptic) {
+        return SDL_XINPUT_HapticOpen(haptic, item);
+    } else {
+        return SDL_DINPUT_HapticOpen(haptic, item);
+    }
+}
+
+
+/*
+ * Opens a haptic device from first mouse it finds for usage.
+ */
+int
+SDL_SYS_HapticMouse(void)
+{
+#if SDL_HAPTIC_DINPUT
+    SDL_hapticlist_item *item;
+    int index = 0;
+
+    /* Grab the first mouse haptic device we find. */
+    for (item = SDL_hapticlist; item != NULL; item = item->next) {
+        if (item->capabilities.dwDevType == DI8DEVCLASS_POINTER ) {
+            return index;
+        }
+        ++index;
+    }
+#endif /* SDL_HAPTIC_DINPUT */
+    return -1;
+}
+
+
+/*
+ * Checks to see if a joystick has haptic features.
+ */
+int
+SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    const struct joystick_hwdata *hwdata = joystick->hwdata;
+#if SDL_HAPTIC_XINPUT
+    if (hwdata->bXInputHaptic) {
+        return 1;
+    }
+#endif
+#if SDL_HAPTIC_DINPUT
+    if (hwdata->Capabilities.dwFlags & DIDC_FORCEFEEDBACK) {
+        return 1;
+    }
+#endif
+    return 0;
+}
+
+/*
+ * Checks to see if the haptic device and joystick are in reality the same.
+ */
+int
+SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    if (joystick->hwdata->bXInputHaptic != haptic->hwdata->bXInputHaptic) {
+        return 0;  /* one is XInput, one is not; not the same device. */
+    } else if (joystick->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_JoystickSameHaptic(haptic, joystick);
+    } else {
+        return SDL_DINPUT_JoystickSameHaptic(haptic, joystick);
+    }
+}
+
+/*
+ * Opens a SDL_Haptic from a SDL_Joystick.
+ */
+int
+SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    if (joystick->hwdata->bXInputDevice) {
+        return SDL_XINPUT_HapticOpenFromJoystick(haptic, joystick);
+    } else {
+        return SDL_DINPUT_HapticOpenFromJoystick(haptic, joystick);
+    }
+}
+
+/*
+ * Closes the haptic device.
+ */
+void
+SDL_SYS_HapticClose(SDL_Haptic * haptic)
+{
+    if (haptic->hwdata) {
+
+        /* Free effects. */
+        SDL_free(haptic->effects);
+        haptic->effects = NULL;
+        haptic->neffects = 0;
+
+        /* Clean up */
+        if (haptic->hwdata->bXInputHaptic) {
+            SDL_XINPUT_HapticClose(haptic);
+        } else {
+            SDL_DINPUT_HapticClose(haptic);
+        }
+
+        /* Free */
+        SDL_free(haptic->hwdata);
+        haptic->hwdata = NULL;
+    }
+}
+
+/*
+ * Clean up after system specific haptic stuff
+ */
+void
+SDL_SYS_HapticQuit(void)
+{
+    SDL_hapticlist_item *item;
+    SDL_hapticlist_item *next = NULL;
+    SDL_Haptic *hapticitem = NULL;
+
+    extern SDL_Haptic *SDL_haptics;
+    for (hapticitem = SDL_haptics; hapticitem; hapticitem = hapticitem->next) {
+        if ((hapticitem->hwdata->bXInputHaptic) && (hapticitem->hwdata->thread)) {
+            /* we _have_ to stop the thread before we free the XInput DLL! */
+            hapticitem->hwdata->stopThread = 1;
+            SDL_WaitThread(hapticitem->hwdata->thread, NULL);
+            hapticitem->hwdata->thread = NULL;
+        }
+    }
+
+    for (item = SDL_hapticlist; item; item = next) {
+        /* Opened and not closed haptics are leaked, this is on purpose.
+         * Close your haptic devices after usage. */
+        /* !!! FIXME: (...is leaking on purpose a good idea?) - No, of course not. */
+        next = item->next;
+        SDL_free(item->name);
+        SDL_free(item);
+    }
+
+    SDL_XINPUT_HapticQuit();
+    SDL_DINPUT_HapticQuit();
+
+    numhaptics = 0;
+    SDL_hapticlist = NULL;
+    SDL_hapticlist_tail = NULL;
+}
+
+/*
+ * Creates a new haptic effect.
+ */
+int
+SDL_SYS_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        SDL_HapticEffect * base)
+{
+    int result;
+
+    /* Alloc the effect. */
+    effect->hweffect = (struct haptic_hweffect *)
+        SDL_malloc(sizeof(struct haptic_hweffect));
+    if (effect->hweffect == NULL) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+    SDL_zerop(effect->hweffect);
+
+    if (haptic->hwdata->bXInputHaptic) {
+        result = SDL_XINPUT_HapticNewEffect(haptic, effect, base);
+    } else {
+        result = SDL_DINPUT_HapticNewEffect(haptic, effect, base);
+    }
+    if (result < 0) {
+        SDL_free(effect->hweffect);
+        effect->hweffect = NULL;
+    }
+    return result;
+}
+
+/*
+ * Updates an effect.
+ */
+int
+SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                           struct haptic_effect *effect,
+                           SDL_HapticEffect * data)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticUpdateEffect(haptic, effect, data);
+    } else {
+        return SDL_DINPUT_HapticUpdateEffect(haptic, effect, data);
+    }
+}
+
+/*
+ * Runs an effect.
+ */
+int
+SDL_SYS_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        Uint32 iterations)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticRunEffect(haptic, effect, iterations);
+    } else {
+        return SDL_DINPUT_HapticRunEffect(haptic, effect, iterations);
+    }
+}
+
+/*
+ * Stops an effect.
+ */
+int
+SDL_SYS_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticStopEffect(haptic, effect);
+    } else {
+        return SDL_DINPUT_HapticStopEffect(haptic, effect);
+    }
+}
+
+/*
+ * Frees the effect.
+ */
+void
+SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        SDL_XINPUT_HapticDestroyEffect(haptic, effect);
+    } else {
+        SDL_DINPUT_HapticDestroyEffect(haptic, effect);
+    }
+    SDL_free(effect->hweffect);
+    effect->hweffect = NULL;
+}
+
+/*
+ * Gets the status of a haptic effect.
+ */
+int
+SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                              struct haptic_effect *effect)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticGetEffectStatus(haptic, effect);
+    } else {
+        return SDL_DINPUT_HapticGetEffectStatus(haptic, effect);
+    }
+}
+
+/*
+ * Sets the gain.
+ */
+int
+SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticSetGain(haptic, gain);
+    } else {
+        return SDL_DINPUT_HapticSetGain(haptic, gain);
+    }
+}
+
+/*
+ * Sets the autocentering.
+ */
+int
+SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticSetAutocenter(haptic, autocenter);
+    } else {
+        return SDL_DINPUT_HapticSetAutocenter(haptic, autocenter);
+    }
+}
+
+/*
+ * Pauses the device.
+ */
+int
+SDL_SYS_HapticPause(SDL_Haptic * haptic)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticPause(haptic);
+    } else {
+        return SDL_DINPUT_HapticPause(haptic);
+    }
+}
+
+/*
+ * Pauses the device.
+ */
+int
+SDL_SYS_HapticUnpause(SDL_Haptic * haptic)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticUnpause(haptic);
+    } else {
+        return SDL_DINPUT_HapticUnpause(haptic);
+    }
+}
+
+/*
+ * Stops all the playing effects on the device.
+ */
+int
+SDL_SYS_HapticStopAll(SDL_Haptic * haptic)
+{
+    if (haptic->hwdata->bXInputHaptic) {
+        return SDL_XINPUT_HapticStopAll(haptic);
+    } else {
+        return SDL_DINPUT_HapticStopAll(haptic);
+    }
+}
+
+#endif /* SDL_HAPTIC_DINPUT || SDL_HAPTIC_XINPUT */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/haptic/windows/SDL_windowshaptic_c.h

@@ -0,0 +1,88 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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"
+
+#ifndef _SDL_windowshaptic_c_h
+#define _SDL_windowshaptic_c_h
+
+#include "SDL_thread.h"
+#include "../SDL_syshaptic.h"
+#include "../../core/windows/SDL_directx.h"
+#include "../../core/windows/SDL_xinput.h"
+
+/*
+ * Haptic system hardware data.
+ */
+struct haptic_hwdata
+{
+#if SDL_HAPTIC_DINPUT
+    LPDIRECTINPUTDEVICE8 device;
+#endif
+    DWORD axes[3];              /* Axes to use. */
+    SDL_bool is_joystick;       /* Device is loaded as joystick. */
+    Uint8 bXInputHaptic; /* Supports force feedback via XInput. */
+    Uint8 userid; /* XInput userid index for this joystick */
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
+    volatile Uint32 stopTicks;
+    volatile int stopThread;
+};
+
+
+/*
+ * Haptic system effect data.
+ */
+struct haptic_hweffect
+{
+#if SDL_HAPTIC_DINPUT
+    DIEFFECT effect;
+    LPDIRECTINPUTEFFECT ref;
+#endif
+#if SDL_HAPTIC_XINPUT
+    XINPUT_VIBRATION vibration;
+#endif
+};
+
+/*
+* List of available haptic devices.
+*/
+typedef struct SDL_hapticlist_item
+{
+    char *name;
+    SDL_Haptic *haptic;
+#if SDL_HAPTIC_DINPUT
+    DIDEVICEINSTANCE instance;
+    DIDEVCAPS capabilities;
+#endif
+    SDL_bool bXInputHaptic; /* Supports force feedback via XInput. */
+    Uint8 userid; /* XInput userid index for this joystick */
+    struct SDL_hapticlist_item *next;
+} SDL_hapticlist_item;
+
+extern SDL_hapticlist_item *SDL_hapticlist;
+
+extern int SDL_SYS_AddHapticDevice(SDL_hapticlist_item *item);
+extern int SDL_SYS_RemoveHapticDevice(SDL_hapticlist_item *prev, SDL_hapticlist_item *item);
+
+#endif /* _SDL_windowshaptic_c_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
+

src/haptic/windows/SDL_xinputhaptic.c

@@ -0,0 +1,495 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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"
+
+#include "SDL_error.h"
+#include "SDL_haptic.h"
+#include "../SDL_syshaptic.h"
+
+#if SDL_HAPTIC_XINPUT
+
+#include "SDL_assert.h"
+#include "SDL_hints.h"
+#include "SDL_timer.h"
+#include "SDL_windowshaptic_c.h"
+#include "SDL_xinputhaptic_c.h"
+#include "../../core/windows/SDL_xinput.h"
+#include "../../joystick/windows/SDL_windowsjoystick_c.h"
+
+/*
+ * Internal stuff.
+ */
+static SDL_bool loaded_xinput = SDL_FALSE;
+
+
+int
+SDL_XINPUT_HapticInit(void)
+{
+    const char *env = SDL_GetHint(SDL_HINT_XINPUT_ENABLED);
+    if (!env || SDL_atoi(env)) {
+        loaded_xinput = (WIN_LoadXInputDLL() == 0);
+    }
+
+    if (loaded_xinput) {
+        DWORD i;
+        for (i = 0; i < XUSER_MAX_COUNT; i++) {
+            SDL_XINPUT_MaybeAddDevice(i);
+        }
+    }
+    return 0;
+}
+
+int
+SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
+{
+    const Uint8 userid = (Uint8)dwUserid;
+    SDL_hapticlist_item *item;
+    XINPUT_VIBRATION state;
+
+    if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
+        return -1;
+    }
+
+    /* Make sure we don't already have it */
+    for (item = SDL_hapticlist; item; item = item->next) {
+        if (item->bXInputHaptic && item->userid == userid) {
+            return -1;  /* Already added */
+        }
+    }
+
+    SDL_zero(state);
+    if (XINPUTSETSTATE(dwUserid, &state) != ERROR_SUCCESS) {
+        return -1;  /* no force feedback on this device. */
+    }
+
+    item = (SDL_hapticlist_item *)SDL_malloc(sizeof(SDL_hapticlist_item));
+    if (item == NULL) {
+        return SDL_OutOfMemory();
+    }
+
+    SDL_zerop(item);
+
+    /* !!! FIXME: I'm not bothering to query for a real name right now (can we even?) */
+    {
+        char buf[64];
+        SDL_snprintf(buf, sizeof(buf), "XInput Controller #%u", (unsigned int)(userid + 1));
+        item->name = SDL_strdup(buf);
+    }
+
+    if (!item->name) {
+        SDL_free(item);
+        return -1;
+    }
+
+    /* Copy the instance over, useful for creating devices. */
+    item->bXInputHaptic = SDL_TRUE;
+    item->userid = userid;
+
+    return SDL_SYS_AddHapticDevice(item);
+}
+
+int
+SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
+{
+    const Uint8 userid = (Uint8)dwUserid;
+    SDL_hapticlist_item *item;
+    SDL_hapticlist_item *prev = NULL;
+
+    if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
+        return -1;
+    }
+
+    for (item = SDL_hapticlist; item != NULL; item = item->next) {
+        if (item->bXInputHaptic && item->userid == userid) {
+            /* found it, remove it. */
+            return SDL_SYS_RemoveHapticDevice(prev, item);
+        }
+        prev = item;
+    }
+    return -1;
+}
+
+/* !!! FIXME: this is a hack, remove this later. */
+/* Since XInput doesn't offer a way to vibrate for X time, we hook into
+ *  SDL_PumpEvents() to check if it's time to stop vibrating with some
+ *  frequency.
+ * In practice, this works for 99% of use cases. But in an ideal world,
+ *  we do this in a separate thread so that:
+ *    - we aren't bound to when the app chooses to pump the event queue.
+ *    - we aren't adding more polling to the event queue
+ *    - we can emulate all the haptic effects correctly (start on a delay,
+ *      mix multiple effects, etc).
+ *
+ * Mostly, this is here to get rumbling to work, and all the other features
+ *  are absent in the XInput path for now.  :(
+ */
+static int SDLCALL
+SDL_RunXInputHaptic(void *arg)
+{
+    struct haptic_hwdata *hwdata = (struct haptic_hwdata *) arg;
+
+    while (!hwdata->stopThread) {
+        SDL_Delay(50);
+        SDL_LockMutex(hwdata->mutex);
+        /* If we're currently running and need to stop... */
+        if (hwdata->stopTicks) {
+            if ((hwdata->stopTicks != SDL_HAPTIC_INFINITY) && SDL_TICKS_PASSED(SDL_GetTicks(), hwdata->stopTicks)) {
+                XINPUT_VIBRATION vibration = { 0, 0 };
+                hwdata->stopTicks = 0;
+                XINPUTSETSTATE(hwdata->userid, &vibration);
+            }
+        }
+        SDL_UnlockMutex(hwdata->mutex);
+    }
+
+    return 0;
+}
+
+static int
+SDL_XINPUT_HapticOpenFromUserIndex(SDL_Haptic *haptic, const Uint8 userid)
+{
+    char threadName[32];
+    XINPUT_VIBRATION vibration = { 0, 0 };  /* stop any current vibration */
+    XINPUTSETSTATE(userid, &vibration);
+
+    haptic->supported = SDL_HAPTIC_LEFTRIGHT;
+
+    haptic->neffects = 1;
+    haptic->nplaying = 1;
+
+    /* Prepare effects memory. */
+    haptic->effects = (struct haptic_effect *)
+        SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
+    if (haptic->effects == NULL) {
+        return SDL_OutOfMemory();
+    }
+    /* Clear the memory */
+    SDL_memset(haptic->effects, 0,
+        sizeof(struct haptic_effect) * haptic->neffects);
+
+    haptic->hwdata = (struct haptic_hwdata *) SDL_malloc(sizeof(*haptic->hwdata));
+    if (haptic->hwdata == NULL) {
+        SDL_free(haptic->effects);
+        haptic->effects = NULL;
+        return SDL_OutOfMemory();
+    }
+    SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
+
+    haptic->hwdata->bXInputHaptic = 1;
+    haptic->hwdata->userid = userid;
+
+    haptic->hwdata->mutex = SDL_CreateMutex();
+    if (haptic->hwdata->mutex == NULL) {
+        SDL_free(haptic->effects);
+        SDL_free(haptic->hwdata);
+        haptic->effects = NULL;
+        return SDL_SetError("Couldn't create XInput haptic mutex");
+    }
+
+    SDL_snprintf(threadName, sizeof(threadName), "SDLXInputDev%d", (int)userid);
+
+#if defined(__WIN32__) && !defined(HAVE_LIBC)  /* !!! FIXME: this is nasty. */
+#undef SDL_CreateThread
+#if SDL_DYNAMIC_API
+    haptic->hwdata->thread = SDL_CreateThread_REAL(SDL_RunXInputHaptic, threadName, haptic->hwdata, NULL, NULL);
+#else
+    haptic->hwdata->thread = SDL_CreateThread(SDL_RunXInputHaptic, threadName, haptic->hwdata, NULL, NULL);
+#endif
+#else
+    haptic->hwdata->thread = SDL_CreateThread(SDL_RunXInputHaptic, threadName, haptic->hwdata);
+#endif
+    if (haptic->hwdata->thread == NULL) {
+        SDL_DestroyMutex(haptic->hwdata->mutex);
+        SDL_free(haptic->effects);
+        SDL_free(haptic->hwdata);
+        haptic->effects = NULL;
+        return SDL_SetError("Couldn't create XInput haptic thread");
+    }
+
+    return 0;
+}
+
+int
+SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
+{
+    return SDL_XINPUT_HapticOpenFromUserIndex(haptic, item->userid);
+}
+
+int
+SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return (haptic->hwdata->userid == joystick->hwdata->userid);
+}
+
+int
+SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    SDL_hapticlist_item *item;
+    int index = 0;
+
+    /* Since it comes from a joystick we have to try to match it with a haptic device on our haptic list. */
+    for (item = SDL_hapticlist; item != NULL; item = item->next) {
+        if (item->bXInputHaptic && item->userid == joystick->hwdata->userid) {
+            haptic->index = index;
+            return SDL_XINPUT_HapticOpenFromUserIndex(haptic, joystick->hwdata->userid);
+        }
+        ++index;
+    }
+
+    SDL_SetError("Couldn't find joystick in haptic device list");
+    return -1;
+}
+
+void
+SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
+{
+    haptic->hwdata->stopThread = 1;
+    SDL_WaitThread(haptic->hwdata->thread, NULL);
+    SDL_DestroyMutex(haptic->hwdata->mutex);
+}
+
+void
+SDL_XINPUT_HapticQuit(void)
+{
+    if (loaded_xinput) {
+        WIN_UnloadXInputDLL();
+        loaded_xinput = SDL_FALSE;
+    }
+}
+
+int
+SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
+{
+    SDL_assert(base->type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
+    return SDL_XINPUT_HapticUpdateEffect(haptic, effect, base);
+}
+
+int
+SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
+{
+    XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
+    SDL_assert(data->type == SDL_HAPTIC_LEFTRIGHT);
+    vib->wLeftMotorSpeed = data->leftright.large_magnitude;
+    vib->wRightMotorSpeed = data->leftright.small_magnitude;
+    SDL_LockMutex(haptic->hwdata->mutex);
+    if (haptic->hwdata->stopTicks) {  /* running right now? Update it. */
+        XINPUTSETSTATE(haptic->hwdata->userid, vib);
+    }
+    SDL_UnlockMutex(haptic->hwdata->mutex);
+    return 0;
+}
+
+int
+SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
+{
+    XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
+    SDL_assert(effect->effect.type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
+    SDL_LockMutex(haptic->hwdata->mutex);
+    if (effect->effect.leftright.length == SDL_HAPTIC_INFINITY || iterations == SDL_HAPTIC_INFINITY) {
+        haptic->hwdata->stopTicks = SDL_HAPTIC_INFINITY;
+    } else if ((!effect->effect.leftright.length) || (!iterations)) {
+        /* do nothing. Effect runs for zero milliseconds. */
+    } else {
+        haptic->hwdata->stopTicks = SDL_GetTicks() + (effect->effect.leftright.length * iterations);
+        if ((haptic->hwdata->stopTicks == SDL_HAPTIC_INFINITY) || (haptic->hwdata->stopTicks == 0)) {
+            haptic->hwdata->stopTicks = 1;  /* fix edge cases. */
+        }
+    }
+    SDL_UnlockMutex(haptic->hwdata->mutex);
+    return (XINPUTSETSTATE(haptic->hwdata->userid, vib) == ERROR_SUCCESS) ? 0 : -1;
+}
+
+int
+SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    XINPUT_VIBRATION vibration = { 0, 0 };
+    SDL_LockMutex(haptic->hwdata->mutex);
+    haptic->hwdata->stopTicks = 0;
+    SDL_UnlockMutex(haptic->hwdata->mutex);
+    return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
+}
+
+void
+SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    SDL_XINPUT_HapticStopEffect(haptic, effect);
+}
+
+int
+SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
+{
+    XINPUT_VIBRATION vibration = { 0, 0 };
+    SDL_LockMutex(haptic->hwdata->mutex);
+    haptic->hwdata->stopTicks = 0;
+    SDL_UnlockMutex(haptic->hwdata->mutex);
+    return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
+}
+
+#else /* !SDL_HAPTIC_XINPUT */
+
+#include "../../core/windows/SDL_windows.h"
+
+typedef struct SDL_hapticlist_item SDL_hapticlist_item;
+
+int
+SDL_XINPUT_HapticInit(void)
+{
+    return 0;
+}
+
+int
+SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return SDL_Unsupported();
+}
+
+void
+SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
+{
+}
+
+void
+SDL_XINPUT_HapticQuit(void)
+{
+}
+
+int
+SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    return SDL_Unsupported();
+}
+
+void
+SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+}
+
+int
+SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
+{
+    return SDL_Unsupported();
+}
+
+int
+SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
+{
+    return SDL_Unsupported();
+}
+
+#endif /* SDL_HAPTIC_XINPUT */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/haptic/windows/SDL_xinputhaptic_c.h

@@ -0,0 +1,47 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2015 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"
+
+#include "SDL_haptic.h"
+#include "SDL_windowshaptic_c.h"
+
+
+extern int SDL_XINPUT_HapticInit(void);
+extern int SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid);
+extern int SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid);
+extern int SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item);
+extern int SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick);
+extern int SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick);
+extern void SDL_XINPUT_HapticClose(SDL_Haptic * haptic);
+extern void SDL_XINPUT_HapticQuit(void);
+extern int SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base);
+extern int SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data);
+extern int SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations);
+extern int SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect);
+extern void SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect);
+extern int SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect);
+extern int SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain);
+extern int SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter);
+extern int SDL_XINPUT_HapticPause(SDL_Haptic * haptic);
+extern int SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic);
+extern int SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic);
+
+/* vi: set ts=4 sw=4 expandtab: */