Atlas - SDL_xinputhaptic.c
Home / ext / SDL2 / src / haptic / windows
Lines: 1 | Size: 13329 bytes
[Download] [Show on GitHub] [Search similar files] [Raw] [Raw (proxy)] 
[FILE BEGIN]
1/*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2018 Sam Lantinga <[email protected]>
4
5  This software is provided 'as-is', without any express or implied
6  warranty.  In no event will the authors be held liable for any damages
7  arising from the use of this software.
8
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12
13  1. The origin of this software must not be misrepresented; you must not
14     claim that you wrote the original software. If you use this software
15     in a product, an acknowledgment in the product documentation would be
16     appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18     misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20*/
21#include "../../SDL_internal.h"
22
23#include "SDL_error.h"
24#include "SDL_haptic.h"
25#include "../SDL_syshaptic.h"
26
27#if SDL_HAPTIC_XINPUT
28
29#include "SDL_assert.h"
30#include "SDL_hints.h"
31#include "SDL_timer.h"
32#include "SDL_windowshaptic_c.h"
33#include "SDL_xinputhaptic_c.h"
34#include "../../core/windows/SDL_xinput.h"
35#include "../../joystick/windows/SDL_windowsjoystick_c.h"
36#include "../../thread/SDL_systhread.h"
37
38/*
39 * Internal stuff.
40 */
41static SDL_bool loaded_xinput = SDL_FALSE;
42
43
44int
45SDL_XINPUT_HapticInit(void)
46{
47    if (SDL_GetHintBoolean(SDL_HINT_XINPUT_ENABLED, SDL_TRUE)) {
48        loaded_xinput = (WIN_LoadXInputDLL() == 0);
49    }
50
51    if (loaded_xinput) {
52        DWORD i;
53        for (i = 0; i < XUSER_MAX_COUNT; i++) {
54            SDL_XINPUT_MaybeAddDevice(i);
55        }
56    }
57    return 0;
58}
59
60int
61SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
62{
63    const Uint8 userid = (Uint8)dwUserid;
64    SDL_hapticlist_item *item;
65    XINPUT_VIBRATION state;
66
67    if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
68        return -1;
69    }
70
71    /* Make sure we don't already have it */
72    for (item = SDL_hapticlist; item; item = item->next) {
73        if (item->bXInputHaptic && item->userid == userid) {
74            return -1;  /* Already added */
75        }
76    }
77
78    SDL_zero(state);
79    if (XINPUTSETSTATE(dwUserid, &state) != ERROR_SUCCESS) {
80        return -1;  /* no force feedback on this device. */
81    }
82
83    item = (SDL_hapticlist_item *)SDL_malloc(sizeof(SDL_hapticlist_item));
84    if (item == NULL) {
85        return SDL_OutOfMemory();
86    }
87
88    SDL_zerop(item);
89
90    /* !!! FIXME: I'm not bothering to query for a real name right now (can we even?) */
91    {
92        char buf[64];
93        SDL_snprintf(buf, sizeof(buf), "XInput Controller #%u", (unsigned int)(userid + 1));
94        item->name = SDL_strdup(buf);
95    }
96
97    if (!item->name) {
98        SDL_free(item);
99        return -1;
100    }
101
102    /* Copy the instance over, useful for creating devices. */
103    item->bXInputHaptic = SDL_TRUE;
104    item->userid = userid;
105
106    return SDL_SYS_AddHapticDevice(item);
107}
108
109int
110SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
111{
112    const Uint8 userid = (Uint8)dwUserid;
113    SDL_hapticlist_item *item;
114    SDL_hapticlist_item *prev = NULL;
115
116    if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
117        return -1;
118    }
119
120    for (item = SDL_hapticlist; item != NULL; item = item->next) {
121        if (item->bXInputHaptic && item->userid == userid) {
122            /* found it, remove it. */
123            return SDL_SYS_RemoveHapticDevice(prev, item);
124        }
125        prev = item;
126    }
127    return -1;
128}
129
130/* !!! FIXME: this is a hack, remove this later. */
131/* Since XInput doesn't offer a way to vibrate for X time, we hook into
132 *  SDL_PumpEvents() to check if it's time to stop vibrating with some
133 *  frequency.
134 * In practice, this works for 99% of use cases. But in an ideal world,
135 *  we do this in a separate thread so that:
136 *    - we aren't bound to when the app chooses to pump the event queue.
137 *    - we aren't adding more polling to the event queue
138 *    - we can emulate all the haptic effects correctly (start on a delay,
139 *      mix multiple effects, etc).
140 *
141 * Mostly, this is here to get rumbling to work, and all the other features
142 *  are absent in the XInput path for now.  :(
143 */
144static int SDLCALL
145SDL_RunXInputHaptic(void *arg)
146{
147    struct haptic_hwdata *hwdata = (struct haptic_hwdata *) arg;
148
149    while (!SDL_AtomicGet(&hwdata->stopThread)) {
150        SDL_Delay(50);
151        SDL_LockMutex(hwdata->mutex);
152        /* If we're currently running and need to stop... */
153        if (hwdata->stopTicks) {
154            if ((hwdata->stopTicks != SDL_HAPTIC_INFINITY) && SDL_TICKS_PASSED(SDL_GetTicks(), hwdata->stopTicks)) {
155                XINPUT_VIBRATION vibration = { 0, 0 };
156                hwdata->stopTicks = 0;
157                XINPUTSETSTATE(hwdata->userid, &vibration);
158            }
159        }
160        SDL_UnlockMutex(hwdata->mutex);
161    }
162
163    return 0;
164}
165
166static int
167SDL_XINPUT_HapticOpenFromUserIndex(SDL_Haptic *haptic, const Uint8 userid)
168{
169    char threadName[32];
170    XINPUT_VIBRATION vibration = { 0, 0 };  /* stop any current vibration */
171    XINPUTSETSTATE(userid, &vibration);
172
173    haptic->supported = SDL_HAPTIC_LEFTRIGHT;
174
175    haptic->neffects = 1;
176    haptic->nplaying = 1;
177
178    /* Prepare effects memory. */
179    haptic->effects = (struct haptic_effect *)
180        SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
181    if (haptic->effects == NULL) {
182        return SDL_OutOfMemory();
183    }
184    /* Clear the memory */
185    SDL_memset(haptic->effects, 0,
186        sizeof(struct haptic_effect) * haptic->neffects);
187
188    haptic->hwdata = (struct haptic_hwdata *) SDL_malloc(sizeof(*haptic->hwdata));
189    if (haptic->hwdata == NULL) {
190        SDL_free(haptic->effects);
191        haptic->effects = NULL;
192        return SDL_OutOfMemory();
193    }
194    SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
195
196    haptic->hwdata->bXInputHaptic = 1;
197    haptic->hwdata->userid = userid;
198
199    haptic->hwdata->mutex = SDL_CreateMutex();
200    if (haptic->hwdata->mutex == NULL) {
201        SDL_free(haptic->effects);
202        SDL_free(haptic->hwdata);
203        haptic->effects = NULL;
204        return SDL_SetError("Couldn't create XInput haptic mutex");
205    }
206
207    SDL_snprintf(threadName, sizeof(threadName), "SDLXInputDev%d", (int)userid);
208    haptic->hwdata->thread = SDL_CreateThreadInternal(SDL_RunXInputHaptic, threadName, 64 * 1024, haptic->hwdata);
209
210    if (haptic->hwdata->thread == NULL) {
211        SDL_DestroyMutex(haptic->hwdata->mutex);
212        SDL_free(haptic->effects);
213        SDL_free(haptic->hwdata);
214        haptic->effects = NULL;
215        return SDL_SetError("Couldn't create XInput haptic thread");
216    }
217
218    return 0;
219}
220
221int
222SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
223{
224    return SDL_XINPUT_HapticOpenFromUserIndex(haptic, item->userid);
225}
226
227int
228SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
229{
230    return (haptic->hwdata->userid == joystick->hwdata->userid);
231}
232
233int
234SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
235{
236    SDL_hapticlist_item *item;
237    int index = 0;
238
239    /* Since it comes from a joystick we have to try to match it with a haptic device on our haptic list. */
240    for (item = SDL_hapticlist; item != NULL; item = item->next) {
241        if (item->bXInputHaptic && item->userid == joystick->hwdata->userid) {
242            haptic->index = index;
243            return SDL_XINPUT_HapticOpenFromUserIndex(haptic, joystick->hwdata->userid);
244        }
245        ++index;
246    }
247
248    SDL_SetError("Couldn't find joystick in haptic device list");
249    return -1;
250}
251
252void
253SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
254{
255    SDL_AtomicSet(&haptic->hwdata->stopThread, 1);
256    SDL_WaitThread(haptic->hwdata->thread, NULL);
257    SDL_DestroyMutex(haptic->hwdata->mutex);
258}
259
260void
261SDL_XINPUT_HapticQuit(void)
262{
263    if (loaded_xinput) {
264        WIN_UnloadXInputDLL();
265        loaded_xinput = SDL_FALSE;
266    }
267}
268
269int
270SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
271{
272    SDL_assert(base->type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
273    return SDL_XINPUT_HapticUpdateEffect(haptic, effect, base);
274}
275
276int
277SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
278{
279    XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
280    SDL_assert(data->type == SDL_HAPTIC_LEFTRIGHT);
281    /* SDL_HapticEffect has max magnitude of 32767, XInput expects 65535 max, so multiply */
282    vib->wLeftMotorSpeed = data->leftright.large_magnitude * 2;
283    vib->wRightMotorSpeed = data->leftright.small_magnitude * 2;
284    SDL_LockMutex(haptic->hwdata->mutex);
285    if (haptic->hwdata->stopTicks) {  /* running right now? Update it. */
286        XINPUTSETSTATE(haptic->hwdata->userid, vib);
287    }
288    SDL_UnlockMutex(haptic->hwdata->mutex);
289    return 0;
290}
291
292int
293SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
294{
295    XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
296    SDL_assert(effect->effect.type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
297    SDL_LockMutex(haptic->hwdata->mutex);
298    if (effect->effect.leftright.length == SDL_HAPTIC_INFINITY || iterations == SDL_HAPTIC_INFINITY) {
299        haptic->hwdata->stopTicks = SDL_HAPTIC_INFINITY;
300    } else if ((!effect->effect.leftright.length) || (!iterations)) {
301        /* do nothing. Effect runs for zero milliseconds. */
302    } else {
303        haptic->hwdata->stopTicks = SDL_GetTicks() + (effect->effect.leftright.length * iterations);
304        if ((haptic->hwdata->stopTicks == SDL_HAPTIC_INFINITY) || (haptic->hwdata->stopTicks == 0)) {
305            haptic->hwdata->stopTicks = 1;  /* fix edge cases. */
306        }
307    }
308    SDL_UnlockMutex(haptic->hwdata->mutex);
309    return (XINPUTSETSTATE(haptic->hwdata->userid, vib) == ERROR_SUCCESS) ? 0 : -1;
310}
311
312int
313SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
314{
315    XINPUT_VIBRATION vibration = { 0, 0 };
316    SDL_LockMutex(haptic->hwdata->mutex);
317    haptic->hwdata->stopTicks = 0;
318    SDL_UnlockMutex(haptic->hwdata->mutex);
319    return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
320}
321
322void
323SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
324{
325    SDL_XINPUT_HapticStopEffect(haptic, effect);
326}
327
328int
329SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
330{
331    return SDL_Unsupported();
332}
333
334int
335SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
336{
337    return SDL_Unsupported();
338}
339
340int
341SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
342{
343    return SDL_Unsupported();
344}
345
346int
347SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
348{
349    return SDL_Unsupported();
350}
351
352int
353SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
354{
355    return SDL_Unsupported();
356}
357
358int
359SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
360{
361    XINPUT_VIBRATION vibration = { 0, 0 };
362    SDL_LockMutex(haptic->hwdata->mutex);
363    haptic->hwdata->stopTicks = 0;
364    SDL_UnlockMutex(haptic->hwdata->mutex);
365    return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
366}
367
368#else /* !SDL_HAPTIC_XINPUT */
369
370#include "../../core/windows/SDL_windows.h"
371
372typedef struct SDL_hapticlist_item SDL_hapticlist_item;
373
374int
375SDL_XINPUT_HapticInit(void)
376{
377    return 0;
378}
379
380int
381SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
382{
383    return SDL_Unsupported();
384}
385
386int
387SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
388{
389    return SDL_Unsupported();
390}
391
392int
393SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
394{
395    return SDL_Unsupported();
396}
397
398int
399SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
400{
401    return SDL_Unsupported();
402}
403
404int
405SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
406{
407    return SDL_Unsupported();
408}
409
410void
411SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
412{
413}
414
415void
416SDL_XINPUT_HapticQuit(void)
417{
418}
419
420int
421SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
422{
423    return SDL_Unsupported();
424}
425
426int
427SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
428{
429    return SDL_Unsupported();
430}
431
432int
433SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
434{
435    return SDL_Unsupported();
436}
437
438int
439SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
440{
441    return SDL_Unsupported();
442}
443
444void
445SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
446{
447}
448
449int
450SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
451{
452    return SDL_Unsupported();
453}
454
455int
456SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
457{
458    return SDL_Unsupported();
459}
460
461int
462SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
463{
464    return SDL_Unsupported();
465}
466
467int
468SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
469{
470    return SDL_Unsupported();
471}
472
473int
474SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
475{
476    return SDL_Unsupported();
477}
478
479int
480SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
481{
482    return SDL_Unsupported();
483}
484
485#endif /* SDL_HAPTIC_XINPUT */
486
487/* vi: set ts=4 sw=4 expandtab: */
488
[FILE END]
(C) 2025 0x4248
(C) 2025 4248 Media and 4248 Systems, All part of 0x4248
See LICENCE files for more information. Not all files are by 0x4248 always check Licencing.