Add support for SDL3 joystick input driver

Made possible by EIREXE, xsellier and the SDL team.

This commit includes statically linked SDL3 for Windows, Linux and macOS.
The vendored copy of SDL3 was setup to only build the required subsystems
for gamepad/joystick support, with some patches to be able to make it as
minimal as possible and reduce the impact on binary size and code size.

Co-authored-by: Álex Román Núñez <eirexe123@gmail.com>
Co-authored-by: Xavier Sellier <xsellier@gmail.com>
Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>

thirdparty/sdl/sensor/SDL_sensor.c

@@ -0,0 +1,622 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 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"
+
+// This is the sensor API for Simple DirectMedia Layer
+
+#include "SDL_syssensor.h"
+
+#include "../events/SDL_events_c.h"
+#include "../joystick/SDL_gamepad_c.h"
+
+static SDL_SensorDriver *SDL_sensor_drivers[] = {
+#ifdef SDL_SENSOR_ANDROID
+    &SDL_ANDROID_SensorDriver,
+#endif
+#ifdef SDL_SENSOR_COREMOTION
+    &SDL_COREMOTION_SensorDriver,
+#endif
+#ifdef SDL_SENSOR_WINDOWS
+    &SDL_WINDOWS_SensorDriver,
+#endif
+#ifdef SDL_SENSOR_VITA
+    &SDL_VITA_SensorDriver,
+#endif
+#ifdef SDL_SENSOR_N3DS
+    &SDL_N3DS_SensorDriver,
+#endif
+#if defined(SDL_SENSOR_DUMMY) || defined(SDL_SENSOR_DISABLED)
+    &SDL_DUMMY_SensorDriver
+#endif
+};
+
+#ifndef SDL_THREAD_SAFETY_ANALYSIS
+static
+#endif
+SDL_Mutex *SDL_sensor_lock = NULL; // This needs to support recursive locks
+static SDL_AtomicInt SDL_sensor_lock_pending;
+static int SDL_sensors_locked;
+static bool SDL_sensors_initialized;
+static SDL_Sensor *SDL_sensors SDL_GUARDED_BY(SDL_sensor_lock) = NULL;
+
+#define CHECK_SENSOR_MAGIC(sensor, result)                  \
+    if (!SDL_ObjectValid(sensor, SDL_OBJECT_TYPE_SENSOR)) { \
+        SDL_InvalidParamError("sensor");                    \
+        SDL_UnlockSensors();                                \
+        return result;                                      \
+    }
+
+bool SDL_SensorsInitialized(void)
+{
+    return SDL_sensors_initialized;
+}
+
+void SDL_LockSensors(void)
+{
+    (void)SDL_AtomicIncRef(&SDL_sensor_lock_pending);
+    SDL_LockMutex(SDL_sensor_lock);
+    (void)SDL_AtomicDecRef(&SDL_sensor_lock_pending);
+
+    ++SDL_sensors_locked;
+}
+
+void SDL_UnlockSensors(void)
+{
+    bool last_unlock = false;
+
+    --SDL_sensors_locked;
+
+    if (!SDL_sensors_initialized) {
+        // NOTE: There's a small window here where another thread could lock the mutex after we've checked for pending locks
+        if (!SDL_sensors_locked && SDL_GetAtomicInt(&SDL_sensor_lock_pending) == 0) {
+            last_unlock = true;
+        }
+    }
+
+    /* The last unlock after sensors are uninitialized will cleanup the mutex,
+     * allowing applications to lock sensors while reinitializing the system.
+     */
+    if (last_unlock) {
+        SDL_Mutex *sensor_lock = SDL_sensor_lock;
+
+        SDL_LockMutex(sensor_lock);
+        {
+            SDL_UnlockMutex(SDL_sensor_lock);
+
+            SDL_sensor_lock = NULL;
+        }
+        SDL_UnlockMutex(sensor_lock);
+        SDL_DestroyMutex(sensor_lock);
+    } else {
+        SDL_UnlockMutex(SDL_sensor_lock);
+    }
+}
+
+bool SDL_SensorsLocked(void)
+{
+    return (SDL_sensors_locked > 0);
+}
+
+void SDL_AssertSensorsLocked(void)
+{
+    SDL_assert(SDL_SensorsLocked());
+}
+
+bool SDL_InitSensors(void)
+{
+    int i;
+    bool status;
+
+    // Create the sensor list lock
+    if (SDL_sensor_lock == NULL) {
+        SDL_sensor_lock = SDL_CreateMutex();
+    }
+
+    if (!SDL_InitSubSystem(SDL_INIT_EVENTS)) {
+        return false;
+    }
+
+    SDL_LockSensors();
+
+    SDL_sensors_initialized = true;
+
+    status = false;
+    for (i = 0; i < SDL_arraysize(SDL_sensor_drivers); ++i) {
+        if (SDL_sensor_drivers[i]->Init()) {
+            status = true;
+        }
+    }
+
+    SDL_UnlockSensors();
+
+    if (!status) {
+        SDL_QuitSensors();
+    }
+
+    return status;
+}
+
+bool SDL_SensorsOpened(void)
+{
+    bool opened;
+
+    SDL_LockSensors();
+    {
+        if (SDL_sensors != NULL) {
+            opened = true;
+        } else {
+            opened = false;
+        }
+    }
+    SDL_UnlockSensors();
+
+    return opened;
+}
+
+SDL_SensorID *SDL_GetSensors(int *count)
+{
+    int i, num_sensors, device_index;
+    int sensor_index = 0, total_sensors = 0;
+    SDL_SensorID *sensors;
+
+    SDL_LockSensors();
+    {
+        for (i = 0; i < SDL_arraysize(SDL_sensor_drivers); ++i) {
+            total_sensors += SDL_sensor_drivers[i]->GetCount();
+        }
+
+        sensors = (SDL_SensorID *)SDL_malloc((total_sensors + 1) * sizeof(*sensors));
+        if (sensors) {
+            if (count) {
+                *count = total_sensors;
+            }
+
+            for (i = 0; i < SDL_arraysize(SDL_sensor_drivers); ++i) {
+                num_sensors = SDL_sensor_drivers[i]->GetCount();
+                for (device_index = 0; device_index < num_sensors; ++device_index) {
+                    SDL_assert(sensor_index < total_sensors);
+                    sensors[sensor_index] = SDL_sensor_drivers[i]->GetDeviceInstanceID(device_index);
+                    SDL_assert(sensors[sensor_index] > 0);
+                    ++sensor_index;
+                }
+            }
+            SDL_assert(sensor_index == total_sensors);
+            sensors[sensor_index] = 0;
+        } else {
+            if (count) {
+                *count = 0;
+            }
+        }
+    }
+    SDL_UnlockSensors();
+
+    return sensors;
+}
+
+/*
+ * Get the driver and device index for a sensor instance ID
+ * This should be called while the sensor lock is held, to prevent another thread from updating the list
+ */
+static bool SDL_GetDriverAndSensorIndex(SDL_SensorID instance_id, SDL_SensorDriver **driver, int *driver_index)
+{
+    int i, num_sensors, device_index;
+
+    if (instance_id > 0) {
+        for (i = 0; i < SDL_arraysize(SDL_sensor_drivers); ++i) {
+            num_sensors = SDL_sensor_drivers[i]->GetCount();
+            for (device_index = 0; device_index < num_sensors; ++device_index) {
+                SDL_SensorID sensor_id = SDL_sensor_drivers[i]->GetDeviceInstanceID(device_index);
+                if (sensor_id == instance_id) {
+                    *driver = SDL_sensor_drivers[i];
+                    *driver_index = device_index;
+                    return true;
+                }
+            }
+        }
+    }
+    SDL_SetError("Sensor %" SDL_PRIu32 " not found", instance_id);
+    return false;
+}
+
+/*
+ * Get the implementation dependent name of a sensor
+ */
+const char *SDL_GetSensorNameForID(SDL_SensorID instance_id)
+{
+    SDL_SensorDriver *driver;
+    int device_index;
+    const char *name = NULL;
+
+    SDL_LockSensors();
+    if (SDL_GetDriverAndSensorIndex(instance_id, &driver, &device_index)) {
+        name = SDL_GetPersistentString(driver->GetDeviceName(device_index));
+    }
+    SDL_UnlockSensors();
+
+    return name;
+}
+
+SDL_SensorType SDL_GetSensorTypeForID(SDL_SensorID instance_id)
+{
+    SDL_SensorDriver *driver;
+    int device_index;
+    SDL_SensorType type = SDL_SENSOR_INVALID;
+
+    SDL_LockSensors();
+    if (SDL_GetDriverAndSensorIndex(instance_id, &driver, &device_index)) {
+        type = driver->GetDeviceType(device_index);
+    }
+    SDL_UnlockSensors();
+
+    return type;
+}
+
+int SDL_GetSensorNonPortableTypeForID(SDL_SensorID instance_id)
+{
+    SDL_SensorDriver *driver;
+    int device_index;
+    int type = -1;
+
+    SDL_LockSensors();
+    if (SDL_GetDriverAndSensorIndex(instance_id, &driver, &device_index)) {
+        type = driver->GetDeviceNonPortableType(device_index);
+    }
+    SDL_UnlockSensors();
+
+    return type;
+}
+
+/*
+ * Open a sensor for use - the index passed as an argument refers to
+ * the N'th sensor on the system.  This index is the value which will
+ * identify this sensor in future sensor events.
+ *
+ * This function returns a sensor identifier, or NULL if an error occurred.
+ */
+SDL_Sensor *SDL_OpenSensor(SDL_SensorID instance_id)
+{
+    SDL_SensorDriver *driver;
+    int device_index;
+    SDL_Sensor *sensor;
+    SDL_Sensor *sensorlist;
+    const char *sensorname = NULL;
+
+    SDL_LockSensors();
+
+    if (!SDL_GetDriverAndSensorIndex(instance_id, &driver, &device_index)) {
+        SDL_UnlockSensors();
+        return NULL;
+    }
+
+    sensorlist = SDL_sensors;
+    /* If the sensor is already open, return it
+     * it is important that we have a single sensor * for each instance id
+     */
+    while (sensorlist) {
+        if (instance_id == sensorlist->instance_id) {
+            sensor = sensorlist;
+            ++sensor->ref_count;
+            SDL_UnlockSensors();
+            return sensor;
+        }
+        sensorlist = sensorlist->next;
+    }
+
+    // Create and initialize the sensor
+    sensor = (SDL_Sensor *)SDL_calloc(1, sizeof(*sensor));
+    if (!sensor) {
+        SDL_UnlockSensors();
+        return NULL;
+    }
+    SDL_SetObjectValid(sensor, SDL_OBJECT_TYPE_SENSOR, true);
+    sensor->driver = driver;
+    sensor->instance_id = instance_id;
+    sensor->type = driver->GetDeviceType(device_index);
+    sensor->non_portable_type = driver->GetDeviceNonPortableType(device_index);
+
+    if (!driver->Open(sensor, device_index)) {
+        SDL_SetObjectValid(sensor, SDL_OBJECT_TYPE_SENSOR, false);
+        SDL_free(sensor);
+        SDL_UnlockSensors();
+        return NULL;
+    }
+
+    sensorname = driver->GetDeviceName(device_index);
+    if (sensorname) {
+        sensor->name = SDL_strdup(sensorname);
+    } else {
+        sensor->name = NULL;
+    }
+
+    // Add sensor to list
+    ++sensor->ref_count;
+    // Link the sensor in the list
+    sensor->next = SDL_sensors;
+    SDL_sensors = sensor;
+
+    driver->Update(sensor);
+
+    SDL_UnlockSensors();
+
+    return sensor;
+}
+
+/*
+ * Find the SDL_Sensor that owns this instance id
+ */
+SDL_Sensor *SDL_GetSensorFromID(SDL_SensorID instance_id)
+{
+    SDL_Sensor *sensor;
+
+    SDL_LockSensors();
+    for (sensor = SDL_sensors; sensor; sensor = sensor->next) {
+        if (sensor->instance_id == instance_id) {
+            break;
+        }
+    }
+    SDL_UnlockSensors();
+    return sensor;
+}
+
+/*
+ * Get the properties associated with a sensor.
+ */
+SDL_PropertiesID SDL_GetSensorProperties(SDL_Sensor *sensor)
+{
+    SDL_PropertiesID result;
+
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor, 0);
+
+        if (sensor->props == 0) {
+            sensor->props = SDL_CreateProperties();
+        }
+        result = sensor->props;
+    }
+    SDL_UnlockSensors();
+
+    return result;
+}
+
+/*
+ * Get the friendly name of this sensor
+ */
+const char *SDL_GetSensorName(SDL_Sensor *sensor)
+{
+    const char *result;
+
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor, NULL);
+
+        result = SDL_GetPersistentString(sensor->name);
+    }
+    SDL_UnlockSensors();
+
+    return result;
+}
+
+/*
+ * Get the type of this sensor
+ */
+SDL_SensorType SDL_GetSensorType(SDL_Sensor *sensor)
+{
+    SDL_SensorType result;
+
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor, SDL_SENSOR_INVALID);
+
+        result = sensor->type;
+    }
+    SDL_UnlockSensors();
+
+    return result;
+}
+
+/*
+ * Get the platform dependent type of this sensor
+ */
+int SDL_GetSensorNonPortableType(SDL_Sensor *sensor)
+{
+    int result;
+
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor, -1);
+
+        result = sensor->non_portable_type;
+    }
+    SDL_UnlockSensors();
+
+    return result;
+}
+
+/*
+ * Get the instance id for this opened sensor
+ */
+SDL_SensorID SDL_GetSensorID(SDL_Sensor *sensor)
+{
+    SDL_SensorID result;
+
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor, 0);
+
+        result = sensor->instance_id;
+    }
+    SDL_UnlockSensors();
+
+    return result;
+}
+
+/*
+ * Get the current state of this sensor
+ */
+bool SDL_GetSensorData(SDL_Sensor *sensor, float *data, int num_values)
+{
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor, false);
+
+        num_values = SDL_min(num_values, SDL_arraysize(sensor->data));
+        SDL_memcpy(data, sensor->data, num_values * sizeof(*data));
+    }
+    SDL_UnlockSensors();
+
+    return true;
+}
+
+/*
+ * Close a sensor previously opened with SDL_OpenSensor()
+ */
+void SDL_CloseSensor(SDL_Sensor *sensor)
+{
+    SDL_Sensor *sensorlist;
+    SDL_Sensor *sensorlistprev;
+
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor,);
+
+        // First decrement ref count
+        if (--sensor->ref_count > 0) {
+            SDL_UnlockSensors();
+            return;
+        }
+
+        SDL_DestroyProperties(sensor->props);
+
+        sensor->driver->Close(sensor);
+        sensor->hwdata = NULL;
+        SDL_SetObjectValid(sensor, SDL_OBJECT_TYPE_SENSOR, false);
+
+        sensorlist = SDL_sensors;
+        sensorlistprev = NULL;
+        while (sensorlist) {
+            if (sensor == sensorlist) {
+                if (sensorlistprev) {
+                    // unlink this entry
+                    sensorlistprev->next = sensorlist->next;
+                } else {
+                    SDL_sensors = sensor->next;
+                }
+                break;
+            }
+            sensorlistprev = sensorlist;
+            sensorlist = sensorlist->next;
+        }
+
+        // Free the data associated with this sensor
+        SDL_free(sensor->name);
+        SDL_free(sensor);
+    }
+    SDL_UnlockSensors();
+}
+
+void SDL_QuitSensors(void)
+{
+    int i;
+
+    SDL_LockSensors();
+
+    // Stop the event polling
+    while (SDL_sensors) {
+        SDL_sensors->ref_count = 1;
+        SDL_CloseSensor(SDL_sensors);
+    }
+
+    // Quit the sensor setup
+    for (i = 0; i < SDL_arraysize(SDL_sensor_drivers); ++i) {
+        SDL_sensor_drivers[i]->Quit();
+    }
+
+    SDL_QuitSubSystem(SDL_INIT_EVENTS);
+
+    SDL_sensors_initialized = false;
+
+    SDL_UnlockSensors();
+}
+
+// These are global for SDL_syssensor.c and SDL_events.c
+
+void SDL_SendSensorUpdate(Uint64 timestamp, SDL_Sensor *sensor, Uint64 sensor_timestamp, float *data, int num_values)
+{
+    SDL_AssertSensorsLocked();
+
+    // Allow duplicate events, for things like steps and heartbeats
+
+    // Update internal sensor state
+    num_values = SDL_min(num_values, SDL_arraysize(sensor->data));
+    SDL_memcpy(sensor->data, data, num_values * sizeof(*data));
+
+    // Post the event, if desired
+    if (SDL_EventEnabled(SDL_EVENT_SENSOR_UPDATE)) {
+        SDL_Event event;
+        event.type = SDL_EVENT_SENSOR_UPDATE;
+        event.common.timestamp = timestamp;
+        event.sensor.which = sensor->instance_id;
+        num_values = SDL_min(num_values, SDL_arraysize(event.sensor.data));
+        SDL_memset(event.sensor.data, 0, sizeof(event.sensor.data));
+        SDL_memcpy(event.sensor.data, data, num_values * sizeof(*data));
+        event.sensor.sensor_timestamp = sensor_timestamp;
+        SDL_PushEvent(&event);
+    }
+
+    SDL_GamepadSensorWatcher(timestamp, sensor->instance_id, sensor_timestamp, data, num_values);
+}
+
+void SDL_UpdateSensor(SDL_Sensor *sensor)
+{
+    SDL_LockSensors();
+    {
+        CHECK_SENSOR_MAGIC(sensor,);
+
+        sensor->driver->Update(sensor);
+    }
+    SDL_UnlockSensors();
+}
+
+void SDL_UpdateSensors(void)
+{
+    int i;
+    SDL_Sensor *sensor;
+
+    if (!SDL_WasInit(SDL_INIT_SENSOR)) {
+        return;
+    }
+
+    SDL_LockSensors();
+
+    for (sensor = SDL_sensors; sensor; sensor = sensor->next) {
+        sensor->driver->Update(sensor);
+    }
+
+    /* this needs to happen AFTER walking the sensor list above, so that any
+       dangling hardware data from removed devices can be free'd
+     */
+    for (i = 0; i < SDL_arraysize(SDL_sensor_drivers); ++i) {
+        SDL_sensor_drivers[i]->Detect();
+    }
+
+    SDL_UnlockSensors();
+}

thirdparty/sdl/sensor/SDL_sensor_c.h

@@ -0,0 +1,59 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 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_sensor_c_h_
+#define SDL_sensor_c_h_
+
+#ifdef SDL_THREAD_SAFETY_ANALYSIS
+extern SDL_Mutex *SDL_sensor_lock;
+#endif
+
+struct SDL_SensorDriver;
+
+// Useful functions and variables from SDL_sensor.c
+
+// Initialization and shutdown functions
+extern bool SDL_InitSensors(void);
+extern void SDL_QuitSensors(void);
+
+// Return whether the sensor system is currently initialized
+extern bool SDL_SensorsInitialized(void);
+
+// Return whether the sensors are currently locked
+extern bool SDL_SensorsLocked(void);
+
+// Make sure we currently have the sensors locked
+extern void SDL_AssertSensorsLocked(void) SDL_ASSERT_CAPABILITY(SDL_sensor_lock);
+
+extern void SDL_LockSensors(void) SDL_ACQUIRE(SDL_sensor_lock);
+extern void SDL_UnlockSensors(void) SDL_RELEASE(SDL_sensor_lock);
+
+// Function to return whether there are any sensors opened by the application
+extern bool SDL_SensorsOpened(void);
+
+// Update an individual sensor, used by gamepad sensor fusion
+extern void SDL_UpdateSensor(SDL_Sensor *sensor);
+
+// Internal event queueing functions
+extern void SDL_SendSensorUpdate(Uint64 timestamp, SDL_Sensor *sensor, Uint64 sensor_timestamp, float *data, int num_values);
+
+#endif // SDL_sensor_c_h_

thirdparty/sdl/sensor/SDL_syssensor.h

@@ -0,0 +1,110 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 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_syssensor_c_h_
+#define SDL_syssensor_c_h_
+
+// This is the system specific header for the SDL sensor API
+
+#include "SDL_sensor_c.h"
+
+#define _guarded SDL_GUARDED_BY(SDL_sensor_lock)
+
+// The SDL sensor structure
+struct SDL_Sensor
+{
+    SDL_SensorID instance_id _guarded;   // Device instance, monotonically increasing from 0
+    char *name _guarded;                 // Sensor name - system dependent
+    SDL_SensorType type _guarded;        // Type of the sensor
+    int non_portable_type _guarded;      // Platform dependent type of the sensor
+
+    float data[16] _guarded;             // The current state of the sensor
+
+    struct SDL_SensorDriver *driver _guarded;
+
+    struct sensor_hwdata *hwdata _guarded; // Driver dependent information
+
+    SDL_PropertiesID props _guarded;
+
+    int ref_count _guarded; // Reference count for multiple opens
+
+    struct SDL_Sensor *next _guarded; // pointer to next sensor we have allocated
+};
+
+#undef _guarded
+
+typedef struct SDL_SensorDriver
+{
+    /* Function to scan the system for sensors.
+     * sensor 0 should be the system default sensor.
+     * This function should return 0, or -1 on an unrecoverable fatal error.
+     */
+    bool (*Init)(void);
+
+    // Function to return the number of sensors available right now
+    int (*GetCount)(void);
+
+    // Function to check to see if the available sensors have changed
+    void (*Detect)(void);
+
+    // Function to get the device-dependent name of a sensor
+    const char *(*GetDeviceName)(int device_index);
+
+    // Function to get the type of a sensor
+    SDL_SensorType (*GetDeviceType)(int device_index);
+
+    // Function to get the platform dependent type of a sensor
+    int (*GetDeviceNonPortableType)(int device_index);
+
+    // Function to get the current instance id of the sensor located at device_index
+    SDL_SensorID (*GetDeviceInstanceID)(int device_index);
+
+    /* Function to open a sensor for use.
+       The sensor to open is specified by the device index.
+       It returns 0, or -1 if there is an error.
+     */
+    bool (*Open)(SDL_Sensor *sensor, int device_index);
+
+    /* Function to update the state of a sensor - called as a device poll.
+     * This function shouldn't update the sensor structure directly,
+     * but instead should call SDL_SendSensorUpdate() to deliver events
+     * and update sensor device state.
+     */
+    void (*Update)(SDL_Sensor *sensor);
+
+    // Function to close a sensor after use
+    void (*Close)(SDL_Sensor *sensor);
+
+    // Function to perform any system-specific sensor related cleanup
+    void (*Quit)(void);
+
+} SDL_SensorDriver;
+
+// The available sensor drivers
+extern SDL_SensorDriver SDL_ANDROID_SensorDriver;
+extern SDL_SensorDriver SDL_COREMOTION_SensorDriver;
+extern SDL_SensorDriver SDL_WINDOWS_SensorDriver;
+extern SDL_SensorDriver SDL_DUMMY_SensorDriver;
+extern SDL_SensorDriver SDL_VITA_SensorDriver;
+extern SDL_SensorDriver SDL_N3DS_SensorDriver;
+
+#endif // SDL_syssensor_h_

thirdparty/sdl/sensor/dummy/SDL_dummysensor.c

@@ -0,0 +1,93 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 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_SENSOR_DUMMY) || defined(SDL_SENSOR_DISABLED)
+
+#include "SDL_dummysensor.h"
+#include "../SDL_syssensor.h"
+
+static bool SDL_DUMMY_SensorInit(void)
+{
+    return true;
+}
+
+static int SDL_DUMMY_SensorGetCount(void)
+{
+    return 0;
+}
+
+static void SDL_DUMMY_SensorDetect(void)
+{
+}
+
+static const char *SDL_DUMMY_SensorGetDeviceName(int device_index)
+{
+    return NULL;
+}
+
+static SDL_SensorType SDL_DUMMY_SensorGetDeviceType(int device_index)
+{
+    return SDL_SENSOR_INVALID;
+}
+
+static int SDL_DUMMY_SensorGetDeviceNonPortableType(int device_index)
+{
+    return -1;
+}
+
+static SDL_SensorID SDL_DUMMY_SensorGetDeviceInstanceID(int device_index)
+{
+    return -1;
+}
+
+static bool SDL_DUMMY_SensorOpen(SDL_Sensor *sensor, int device_index)
+{
+    return SDL_Unsupported();
+}
+
+static void SDL_DUMMY_SensorUpdate(SDL_Sensor *sensor)
+{
+}
+
+static void SDL_DUMMY_SensorClose(SDL_Sensor *sensor)
+{
+}
+
+static void SDL_DUMMY_SensorQuit(void)
+{
+}
+
+SDL_SensorDriver SDL_DUMMY_SensorDriver = {
+    SDL_DUMMY_SensorInit,
+    SDL_DUMMY_SensorGetCount,
+    SDL_DUMMY_SensorDetect,
+    SDL_DUMMY_SensorGetDeviceName,
+    SDL_DUMMY_SensorGetDeviceType,
+    SDL_DUMMY_SensorGetDeviceNonPortableType,
+    SDL_DUMMY_SensorGetDeviceInstanceID,
+    SDL_DUMMY_SensorOpen,
+    SDL_DUMMY_SensorUpdate,
+    SDL_DUMMY_SensorClose,
+    SDL_DUMMY_SensorQuit,
+};
+
+#endif // SDL_SENSOR_DUMMY || SDL_SENSOR_DISABLED

thirdparty/sdl/sensor/dummy/SDL_dummysensor.h

@@ -0,0 +1,21 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 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"