[SDL3] Adding input and FFB support for Logitech G29(PS3) on hidapi (#11598)

These changes enable the Logitech G29 wheel to run on hidapi with both SDL_Joystick and SDL_Haptic interfaces.

While it is already possible to use the wheel on Linux in WINE + SDL2 thanks to the in-tree evdev driver as well as new-lg4ff, these set of changes allow the G29 to be used with WINE under MacOS and FreeBSD

These wheels should also be supported, but I can only test them from G29's compat modes: G27, G25, DFGT, DFP, DFEX

Haptic and led support are ported from https://github.com/berarma/new-lg4ff

src/haptic/hidapi/SDL_hidapihaptic.c

@@ -0,0 +1,305 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2025 Katharine Chui <katharine.chui@gmail.com>
+
+  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"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "SDL_hidapihaptic_c.h"
+#include "SDL3/SDL_mutex.h"
+#include "SDL3/SDL_error.h"
+
+extern struct SDL_JoystickDriver SDL_HIDAPI_JoystickDriver;
+
+typedef struct haptic_list_node
+{
+    SDL_Haptic *haptic;
+    struct haptic_list_node *next;
+} haptic_list_node;
+
+static haptic_list_node *haptic_list_head = NULL;
+static SDL_Mutex *haptic_list_mutex = NULL;
+
+static SDL_HIDAPI_HapticDriver *drivers[] = {
+    #ifdef SDL_HAPTIC_HIDAPI_LG4FF
+    &SDL_HIDAPI_HapticDriverLg4ff,
+    #endif
+    NULL
+};
+
+bool SDL_HIDAPI_HapticInit()
+{
+    haptic_list_head = NULL;
+    haptic_list_mutex = SDL_CreateMutex();
+    if (haptic_list_mutex == NULL) {
+        return SDL_OutOfMemory();
+    }
+    return true;
+}
+
+bool SDL_HIDAPI_HapticIsHidapi(SDL_Haptic *haptic)
+{
+    haptic_list_node *cur;
+    bool ret = false;
+
+    SDL_LockMutex(haptic_list_mutex);
+    cur = haptic_list_head;
+    while (cur != NULL) {
+        if (cur->haptic == haptic) {
+            ret = true;
+            break;
+        }
+        cur = cur->next;
+    }
+
+    SDL_UnlockMutex(haptic_list_mutex);
+
+    return ret;
+}
+
+
+bool SDL_HIDAPI_JoystickIsHaptic(SDL_Joystick *joystick)
+{
+    const int numdrivers = SDL_arraysize(drivers) - 1;
+    int i;
+
+    SDL_AssertJoysticksLocked();
+
+    if (joystick->driver != &SDL_HIDAPI_JoystickDriver) {
+        return false;
+    }
+
+    for (i = 0; i < numdrivers; ++i) {
+        if (drivers[i]->JoystickSupported(joystick)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool SDL_HIDAPI_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+{
+    const int numdrivers = SDL_arraysize(drivers) - 1;
+    int i;
+
+    SDL_AssertJoysticksLocked();
+
+    if (joystick->driver != &SDL_HIDAPI_JoystickDriver) {
+        return SDL_SetError("Cannot open hidapi haptic from non hidapi joystick");
+    }
+
+    for (i = 0; i < numdrivers; ++i) {
+        if (drivers[i]->JoystickSupported(joystick)) {
+            SDL_HIDAPI_HapticDevice *device;
+            haptic_list_node *list_node;
+            // the driver is responsible for calling SDL_SetError
+            void *ctx = drivers[i]->Open(joystick);
+            if (ctx == NULL) {
+                return false;
+            }
+
+            device = SDL_malloc(sizeof(SDL_HIDAPI_HapticDevice));
+            if (device == NULL) {
+                SDL_HIDAPI_HapticDevice temp;
+                temp.ctx = ctx;
+                temp.driver = drivers[i];
+                temp.joystick = joystick;
+                temp.driver->Close(&temp);
+                return SDL_OutOfMemory();
+            }
+
+            device->driver = drivers[i];
+            device->haptic = haptic;
+            device->joystick = joystick;
+            device->ctx = ctx;
+
+            list_node = SDL_malloc(sizeof(haptic_list_node));
+            if (list_node == NULL) {
+                device->driver->Close(device);
+                SDL_free(device);
+                return SDL_OutOfMemory();
+            }
+
+            haptic->hwdata = (struct haptic_hwdata *)device;
+
+            // this is outside of the syshaptic driver
+
+            haptic->neffects = device->driver->NumEffects(device);
+            haptic->nplaying = device->driver->NumEffectsPlaying(device);
+            haptic->supported = device->driver->GetFeatures(device);
+            haptic->naxes = device->driver->NumAxes(device);
+
+            // outside of SYS_HAPTIC
+            haptic->instance_id = 255;
+
+            list_node->haptic = haptic;
+            list_node->next = NULL;
+            
+            // grab a joystick ref so that it doesn't get fully destroyed before the haptic is closed
+            SDL_OpenJoystick(SDL_GetJoystickID(joystick));
+
+            SDL_LockMutex(haptic_list_mutex);
+            if (haptic_list_head == NULL) {
+                haptic_list_head = list_node;
+            } else {
+                haptic_list_node *cur = haptic_list_head;
+                while(cur->next != NULL) {
+                cur = cur->next;
+                }
+                cur->next = list_node;
+            }
+            SDL_UnlockMutex(haptic_list_mutex);
+
+            return true;
+        }
+    }
+
+    return SDL_SetError("No supported HIDAPI haptic driver found for joystick");
+}
+
+bool SDL_HIDAPI_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
+{
+    SDL_HIDAPI_HapticDevice *device;
+
+    SDL_AssertJoysticksLocked();
+    if (joystick->driver != &SDL_HIDAPI_JoystickDriver) {
+        return false;
+    }
+
+    device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+
+    if (joystick == device->joystick) {
+        return true;
+    }
+    return false;
+}
+
+void SDL_HIDAPI_HapticClose(SDL_Haptic *haptic)
+{
+    haptic_list_node *cur, *last;
+
+    SDL_LockMutex(haptic_list_mutex);
+
+    cur = haptic_list_head;
+    last = NULL;
+    while (cur != NULL) {
+        if (cur->haptic == haptic) {
+            SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+
+            device->driver->Close(device);
+            
+            // a reference was grabbed during open, now release it
+            SDL_CloseJoystick(device->joystick);
+
+            if (cur == haptic_list_head) {
+                haptic_list_head = cur->next;
+            } else {
+                last->next = cur->next;
+            }
+
+            SDL_free(device->ctx);
+            SDL_free(device);
+            SDL_free(cur);
+            SDL_UnlockMutex(haptic_list_mutex);
+            return;
+        }
+        last = cur;
+        cur = cur->next;
+    }
+
+    SDL_UnlockMutex(haptic_list_mutex);
+}
+
+void SDL_HIDAPI_HapticQuit(void)
+{
+    // the list is cleared in SDL_haptic.c
+    if (haptic_list_mutex != NULL) {
+        SDL_DestroyMutex(haptic_list_mutex);
+        haptic_list_mutex = NULL;
+    }
+}
+
+int SDL_HIDAPI_HapticNewEffect(SDL_Haptic *haptic, const SDL_HapticEffect *base)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->CreateEffect(device, base);
+}
+
+bool SDL_HIDAPI_HapticUpdateEffect(SDL_Haptic *haptic, int id, const SDL_HapticEffect *data)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->UpdateEffect(device, id, data);
+}
+
+bool SDL_HIDAPI_HapticRunEffect(SDL_Haptic *haptic, int id, Uint32 iterations)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->RunEffect(device, id, iterations);
+}
+
+bool SDL_HIDAPI_HapticStopEffect(SDL_Haptic *haptic, int id)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->StopEffect(device, id);
+}
+
+void SDL_HIDAPI_HapticDestroyEffect(SDL_Haptic *haptic, int id)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    device->driver->DestroyEffect(device, id);
+}
+
+bool SDL_HIDAPI_HapticGetEffectStatus(SDL_Haptic *haptic, int id)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->GetEffectStatus(device, id);
+}
+
+bool SDL_HIDAPI_HapticSetGain(SDL_Haptic *haptic, int gain)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->SetGain(device, gain);
+}
+
+bool SDL_HIDAPI_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->SetAutocenter(device, autocenter);
+}
+
+bool SDL_HIDAPI_HapticPause(SDL_Haptic *haptic)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->Pause(device);
+}
+
+bool SDL_HIDAPI_HapticResume(SDL_Haptic *haptic)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->Resume(device);
+}
+
+bool SDL_HIDAPI_HapticStopAll(SDL_Haptic *haptic)
+{
+    SDL_HIDAPI_HapticDevice *device = (SDL_HIDAPI_HapticDevice *)haptic->hwdata;
+    return device->driver->StopEffects(device);
+}
+
+#endif //SDL_JOYSTICK_HIDAPI

src/haptic/hidapi/SDL_hidapihaptic_c.h

@@ -0,0 +1,70 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2025 Katharine Chui <katharine.chui@gmail.com>
+
+  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.
+*/
+
+#ifndef SDL_hidapihaptic_c_h_
+#define SDL_hidapihaptic_c_h_
+
+#include "SDL3/SDL_haptic.h"
+#include "SDL3/SDL_joystick.h"
+#include "../SDL_syshaptic.h"
+#include "../../joystick/SDL_joystick_c.h" // accessing _SDL_JoystickDriver
+#include "../../joystick/SDL_sysjoystick.h" // accessing _SDL_Joystick
+
+#define SDL_HAPTIC_HIDAPI_LG4FF
+
+typedef struct SDL_HIDAPI_HapticDriver SDL_HIDAPI_HapticDriver;
+typedef struct SDL_HIDAPI_HapticDevice
+{
+    SDL_Haptic *haptic; /* related haptic ref */
+    SDL_Joystick *joystick; /* related hidapi joystick */
+    SDL_HIDAPI_HapticDriver *driver; /* driver to use */
+    void *ctx; /* driver specific context */
+} SDL_HIDAPI_HapticDevice;
+
+struct SDL_HIDAPI_HapticDriver
+{
+    bool (*JoystickSupported)(SDL_Joystick *joystick); /* return SDL_TRUE if haptic can be opened from the joystick */
+    void *(*Open)(SDL_Joystick *joystick); /* returns a driver context allocated with SDL_malloc, or null if it cannot be allocated */
+  
+    /* functions below need to handle the possibility of a null joystick instance, indicating the absence of the joystick */
+    void (*Close)(SDL_HIDAPI_HapticDevice *device); /* cleanup resources allocated during Open, do NOT free driver context created in Open */
+  
+    /* below mirror SDL_haptic.h effect interfaces */
+    int (*NumEffects)(SDL_HIDAPI_HapticDevice *device); /* returns supported number of effects the device can store */
+    int (*NumEffectsPlaying)(SDL_HIDAPI_HapticDevice *device); /* returns supported number of effects the device can play concurrently */
+    Uint32 (*GetFeatures)(SDL_HIDAPI_HapticDevice *device); /* returns supported effects in a bitmask */
+    int (*NumAxes)(SDL_HIDAPI_HapticDevice *device); /* returns the number of haptic axes */
+    int (*CreateEffect)(SDL_HIDAPI_HapticDevice *device, const SDL_HapticEffect *data); /* returns effect id if created correctly, negative number on error */
+    bool (*UpdateEffect)(SDL_HIDAPI_HapticDevice *device, int id, const SDL_HapticEffect *data); /* returns 0 on success, negative number on error */
+    bool (*RunEffect)(SDL_HIDAPI_HapticDevice *device, int id, Uint32 iterations); /* returns 0 on success, negative number on error */
+    bool (*StopEffect)(SDL_HIDAPI_HapticDevice *device, int id); /* returns 0 on success, negative number on error */
+    void (*DestroyEffect)(SDL_HIDAPI_HapticDevice *device, int id); /* returns 0 on success, negative number on error */
+    bool (*GetEffectStatus)(SDL_HIDAPI_HapticDevice *device, int id); /* returns 0 if not playing, 1 if playing, negative number on error */
+    bool (*SetGain)(SDL_HIDAPI_HapticDevice *device, int gain); /* gain 0 - 100, returns 0 on success, negative number on error */
+    bool (*SetAutocenter)(SDL_HIDAPI_HapticDevice *device, int autocenter); /* gain 0 - 100, returns 0 on success, negative number on error */
+    bool (*Pause)(SDL_HIDAPI_HapticDevice *device); /* returns 0 on success, negative number on error */
+    bool (*Resume)(SDL_HIDAPI_HapticDevice *device); /* returns 0 on success, negative number on error */
+    bool (*StopEffects)(SDL_HIDAPI_HapticDevice *device); /* returns 0 on success, negative number on error */
+};
+
+extern SDL_HIDAPI_HapticDriver SDL_HIDAPI_HapticDriverLg4ff;
+
+#endif //SDL_joystick_c_h_