Add Gamepad support+example for SDL3, todo are other backends

manuel5975p · manuel5975p · commit def091887b18 · 2026-01-28T11:05:56.000+01:00
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -66,6 +66,7 @@ add_example(core_rendertexture)
 #add_example(pipeline_basic)
 add_example(pipeline_settings)
 add_example(input_keys)
+add_example(input_gamepad)
 add_example(input_multitouch_gesture)
 add_example(input_text)
 #add_example(models_cube)
diff --git a/examples/input_gamepad.c b/examples/input_gamepad.c
@@ -0,0 +1,72 @@
+#include <raygpu.h>
+
+const int screenWidth = 800;
+const int screenHeight = 450;
+
+Vector2 ballPosition = { 400, 225 };
+Color ballColor = {0, 82, 172, 255};
+
+void setup(void){
+    SetTargetFPS(60);
+}
+
+void render(void) {
+    if (IsGamepadAvailable(0)) {
+        
+        
+        ballPosition.x += GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X) * 5.0f;
+        ballPosition.y += GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y) * 5.0f;        
+        if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_SOUTH))
+            ballColor = GREEN;
+        else if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_EAST)){
+            ballColor = RED;
+        }
+        else if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_WEST)){
+            ballColor = BLUE;
+        }
+        else if (IsGamepadButtonDown(0, GAMEPAD_BUTTON_NORTH)){
+            ballColor = YELLOW;
+        }
+        else ballColor = DARKBLUE;
+    }
+
+    BeginDrawing();
+        ClearBackground(RAYWHITE);
+
+        if (IsGamepadAvailable(0)) {
+            DrawText(GetGamepadName(0), 10, 10, 20, GRAY);
+            DrawText("Left stick to move, face buttons to change color", 10, 40, 20, GRAY);
+
+            DrawText(TextFormat("Left X: %.2f", GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X)), 10, 80, 20, BLACK);
+            DrawText(TextFormat("Left Y: %.2f", GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y)), 10, 110, 20, BLACK);
+            DrawText(TextFormat("Right X: %.2f", GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_X)), 10, 140, 20, BLACK);
+            DrawText(TextFormat("Right Y: %.2f", GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_Y)), 10, 170, 20, BLACK);
+            DrawText(TextFormat("L Trigger: %.2f", GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_TRIGGER)), 10, 200, 20, BLACK);
+            DrawText(TextFormat("R Trigger: %.2f", GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_TRIGGER)), 10, 230, 20, BLACK);
+
+            DrawCircleV(ballPosition, 50, ballColor);
+        } else {
+            DrawText("No gamepad detected", screenWidth/2 - 100, screenHeight/2, 20, GRAY);
+            DrawText("Connect a controller and it will be detected automatically", screenWidth/2 - 220, screenHeight/2 + 30, 20, LIGHTGRAY);
+        }
+
+    EndDrawing();
+}
+
+int main(void) {
+    ProgramInfo programInfo = {
+        .windowWidth = screenWidth,
+        .windowHeight = screenHeight,
+        .windowTitle = "Gamepad Input Example",
+        .setupFunction = setup,
+        .renderFunction = render
+    };
+
+    InitProgram(programInfo);
+    
+    while (!WindowShouldClose()) {
+        render();
+    }
+
+    return 0;
+}
diff --git a/include/raygpu.h b/include/raygpu.h
@@ -960,6 +960,47 @@ typedef enum {
     KEY_VOLUME_DOWN     = 25        // Key: Android volume down button
 } KeyboardKey;
 
+// Gamepad buttons (matching SDL3 gamepad button layout)
+typedef enum {
+    GAMEPAD_BUTTON_UNKNOWN = -1,
+    GAMEPAD_BUTTON_SOUTH = 0,           // Xbox A, PlayStation Cross
+    GAMEPAD_BUTTON_EAST = 1,            // Xbox B, PlayStation Circle
+    GAMEPAD_BUTTON_WEST = 2,            // Xbox X, PlayStation Square
+    GAMEPAD_BUTTON_NORTH = 3,           // Xbox Y, PlayStation Triangle
+    GAMEPAD_BUTTON_BACK = 4,            // Xbox Back, PlayStation Select
+    GAMEPAD_BUTTON_GUIDE = 5,           // Xbox Guide, PlayStation PS
+    GAMEPAD_BUTTON_START = 6,           // Xbox Start, PlayStation Start
+    GAMEPAD_BUTTON_LEFT_STICK = 7,      // Left stick click
+    GAMEPAD_BUTTON_RIGHT_STICK = 8,     // Right stick click
+    GAMEPAD_BUTTON_LEFT_SHOULDER = 9,   // Left bumper/shoulder
+    GAMEPAD_BUTTON_RIGHT_SHOULDER = 10, // Right bumper/shoulder
+    GAMEPAD_BUTTON_DPAD_UP = 11,
+    GAMEPAD_BUTTON_DPAD_DOWN = 12,
+    GAMEPAD_BUTTON_DPAD_LEFT = 13,
+    GAMEPAD_BUTTON_DPAD_RIGHT = 14,
+    GAMEPAD_BUTTON_MISC1 = 15,          // Xbox Series X share, PS5 microphone
+    GAMEPAD_BUTTON_RIGHT_PADDLE1 = 16,
+    GAMEPAD_BUTTON_LEFT_PADDLE1 = 17,
+    GAMEPAD_BUTTON_RIGHT_PADDLE2 = 18,
+    GAMEPAD_BUTTON_LEFT_PADDLE2 = 19,
+    GAMEPAD_BUTTON_TOUCHPAD = 20,       // PlayStation touchpad button
+    GAMEPAD_BUTTON_MISC2 = 21,
+    GAMEPAD_BUTTON_MISC3 = 22,
+    GAMEPAD_BUTTON_MISC4 = 23,
+    GAMEPAD_BUTTON_MISC5 = 24,
+    GAMEPAD_BUTTON_MISC6 = 25,
+} GamepadButton;
+
+// Gamepad axes (matching SDL3 gamepad axis layout)
+typedef enum {
+    GAMEPAD_AXIS_INVALID = -1,
+    GAMEPAD_AXIS_LEFT_X = 0,            // Left stick X axis
+    GAMEPAD_AXIS_LEFT_Y = 1,            // Left stick Y axis
+    GAMEPAD_AXIS_RIGHT_X = 2,           // Right stick X axis
+    GAMEPAD_AXIS_RIGHT_Y = 3,           // Right stick Y axis
+    GAMEPAD_AXIS_LEFT_TRIGGER = 4,      // Left trigger
+    GAMEPAD_AXIS_RIGHT_TRIGGER = 5,     // Right trigger
+} GamepadAxis;
 
 /**
  * @brief Limit enum to describe WebGPU requested device limits
@@ -1254,6 +1295,7 @@ typedef struct GamepadState{
     bool connected;
     float axis[GAMEPAD_AXIS_MAX];
     uint8_t buttons[GAMEPAD_BUTTON_MAX];
+    uint8_t buttonsPrevious[GAMEPAD_BUTTON_MAX];
 } GamepadState;
 
 typedef struct window_input_state{
@@ -1357,6 +1399,24 @@ RGAPI Vector2 GetMouseWheelMoveV(void); // Get mouse wheel movement for both X a
 RGAPI bool IsMouseButtonPressed(int button);
 RGAPI bool IsMouseButtonDown(int button);
 RGAPI bool IsMouseButtonReleased(int button);
+// Gamepad input functions (generic - dispatch to platform backend)
+RGAPI bool IsGamepadAvailable(int gamepad);                              // Check if a gamepad is connected
+RGAPI const char *GetGamepadName(int gamepad);                           // Get gamepad internal name
+RGAPI bool IsGamepadButtonPressed(int gamepad, int button);              // Check if a gamepad button has been pressed once
+RGAPI bool IsGamepadButtonDown(int gamepad, int button);                 // Check if a gamepad button is being pressed
+RGAPI bool IsGamepadButtonReleased(int gamepad, int button);             // Check if a gamepad button has been released once
+RGAPI int GetGamepadButtonPressed(void);                                 // Get the last gamepad button pressed
+RGAPI int GetGamepadAxisCount(int gamepad);                              // Get gamepad axis count for a gamepad
+RGAPI float GetGamepadAxisMovement(int gamepad, int axis);               // Get axis movement value for a gamepad axis
+// Gamepad input functions (SDL3-specific)
+RGAPI bool IsGamepadAvailable_SDL3(int gamepad);
+RGAPI const char *GetGamepadName_SDL3(int gamepad);
+RGAPI bool IsGamepadButtonPressed_SDL3(int gamepad, int button);
+RGAPI bool IsGamepadButtonDown_SDL3(int gamepad, int button);
+RGAPI bool IsGamepadButtonReleased_SDL3(int gamepad, int button);
+RGAPI int GetGamepadButtonPressed_SDL3(void);
+RGAPI int GetGamepadAxisCount_SDL3(int gamepad);
+RGAPI float GetGamepadAxisMovement_SDL3(int gamepad, int axis);
 RGAPI void ShowCursor(cwoid);                   // Shows cursor
 RGAPI void HideCursor(cwoid);                   // Hides cursor
 RGAPI bool IsCursorHidden(cwoid);               // Check if cursor is not visible
diff --git a/src/platform/InitWindow_SDL3.c b/src/platform/InitWindow_SDL3.c
@@ -638,4 +638,62 @@ void DisableCursor_SDL3(void* window){
     SDL_SetWindowRelativeMouseMode((SDL_Window*)window, true);
 }
 
+// Gamepad input functions
+bool IsGamepadAvailable_SDL3(int gamepad) {
+    if (gamepad < 0 || gamepad >= GAMEPAD_MAX) return false;
+    if (!g_renderstate.mainWindow) return false;
+    return g_renderstate.mainWindow->input_state.gamepads[gamepad].connected;
+}
+
+const char *GetGamepadName_SDL3(int gamepad) {
+    if (!IsGamepadAvailable_SDL3(gamepad)) return NULL;
+    SDL_Gamepad *gp = (SDL_Gamepad *)g_renderstate.mainWindow->input_state.gamepads[gamepad].handle;
+    return SDL_GetGamepadName(gp);
+}
+
+bool IsGamepadButtonPressed_SDL3(int gamepad, int button) {
+    if (!IsGamepadAvailable_SDL3(gamepad)) return false;
+    if (button < 0 || button >= GAMEPAD_BUTTON_MAX) return false;
+    GamepadState *state = &g_renderstate.mainWindow->input_state.gamepads[gamepad];
+    return state->buttons[button] && !state->buttonsPrevious[button];
+}
+
+bool IsGamepadButtonDown_SDL3(int gamepad, int button) {
+    if (!IsGamepadAvailable_SDL3(gamepad)) return false;
+    if (button < 0 || button >= GAMEPAD_BUTTON_MAX) return false;
+    return g_renderstate.mainWindow->input_state.gamepads[gamepad].buttons[button];
+}
+
+bool IsGamepadButtonReleased_SDL3(int gamepad, int button) {
+    if (!IsGamepadAvailable_SDL3(gamepad)) return false;
+    if (button < 0 || button >= GAMEPAD_BUTTON_MAX) return false;
+    GamepadState *state = &g_renderstate.mainWindow->input_state.gamepads[gamepad];
+    return !state->buttons[button] && state->buttonsPrevious[button];
+}
+
+int GetGamepadButtonPressed_SDL3(void) {
+    if (!g_renderstate.mainWindow) return GAMEPAD_BUTTON_UNKNOWN;
+    for (int gp = 0; gp < GAMEPAD_MAX; gp++) {
+        if (!g_renderstate.mainWindow->input_state.gamepads[gp].connected) continue;
+        GamepadState *state = &g_renderstate.mainWindow->input_state.gamepads[gp];
+        for (int btn = 0; btn < GAMEPAD_BUTTON_MAX; btn++) {
+            if (state->buttons[btn] && !state->buttonsPrevious[btn]) {
+                return btn;
+            }
+        }
+    }
+    return GAMEPAD_BUTTON_UNKNOWN;
+}
+
+int GetGamepadAxisCount_SDL3(int gamepad) {
+    if (!IsGamepadAvailable_SDL3(gamepad)) return 0;
+    return GAMEPAD_AXIS_MAX;
+}
+
+float GetGamepadAxisMovement_SDL3(int gamepad, int axis) {
+    if (!IsGamepadAvailable_SDL3(gamepad)) return 0.0f;
+    if (axis < 0 || axis >= GAMEPAD_AXIS_MAX) return 0.0f;
+    return g_renderstate.mainWindow->input_state.gamepads[gamepad].axis[axis];
+}
+
 // end file src/InitWindow_SDL3.c
diff --git a/src/raygpu.c b/src/raygpu.c
@@ -1212,6 +1212,9 @@ RGAPI void EndDrawing(){
     ipstate->scrollPreviousFrame = ipstate->scrollThisFrame;
     ipstate->scrollThisFrame = CLITERAL(Vector2){0, 0};
     memcpy(ipstate->mouseButtonDownPrevious, ipstate->mouseButtonDown, MOUSEBTN_MAX);
+    for (int gp = 0; gp < GAMEPAD_MAX; gp++) {
+        memcpy(ipstate->gamepads[gp].buttonsPrevious, ipstate->gamepads[gp].buttons, GAMEPAD_BUTTON_MAX);
+    }
     for(size_t i = 0;i < g_renderstate.createdSubwindows.current_capacity;i++){
         CreatedWindowMap_kv_pair* iter = g_renderstate.createdSubwindows.table + i;
         if(iter->key != PHM_EMPTY_SLOT_KEY && iter->key != PHM_DELETED_SLOT_KEY){
@@ -1817,6 +1820,95 @@ bool IsMouseButtonDown(int button){
 bool IsMouseButtonReleased(int button){
     return !CreatedWindowMap_get(&g_renderstate.createdSubwindows, GetActiveWindowHandle())->input_state.mouseButtonDown[button] && CreatedWindowMap_get(&g_renderstate.createdSubwindows, GetActiveWindowHandle())->input_state.mouseButtonDownPrevious[button];
 }
+bool IsGamepadAvailable_SDL3(int gamepad);
+const char *GetGamepadName_SDL3(int gamepad);
+bool IsGamepadButtonPressed_SDL3(int gamepad, int button);
+bool IsGamepadButtonDown_SDL3(int gamepad, int button);
+bool IsGamepadButtonReleased_SDL3(int gamepad, int button);
+int GetGamepadButtonPressed_SDL3(void);
+int GetGamepadAxisCount_SDL3(int gamepad);
+float GetGamepadAxisMovement_SDL3(int gamepad, int axis);
+// Generic gamepad functions with backend dispatch
+RGAPI bool IsGamepadAvailable(int gamepad) {
+    if (!g_renderstate.mainWindow) return false;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return IsGamepadAvailable_SDL3(gamepad);
+        #endif
+        default: return false;
+    }
+}
+
+RGAPI const char *GetGamepadName(int gamepad) {
+    if (!g_renderstate.mainWindow) return NULL;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return GetGamepadName_SDL3(gamepad);
+        #endif
+        default: return NULL;
+    }
+}
+
+RGAPI bool IsGamepadButtonPressed(int gamepad, int button) {
+    if (!g_renderstate.mainWindow) return false;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return IsGamepadButtonPressed_SDL3(gamepad, button);
+        #endif
+        default: return false;
+    }
+}
+
+RGAPI bool IsGamepadButtonDown(int gamepad, int button) {
+    if (!g_renderstate.mainWindow) return false;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return IsGamepadButtonDown_SDL3(gamepad, button);
+        #endif
+        default: return false;
+    }
+}
+
+RGAPI bool IsGamepadButtonReleased(int gamepad, int button) {
+    if (!g_renderstate.mainWindow) return false;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return IsGamepadButtonReleased_SDL3(gamepad, button);
+        #endif
+        default: return false;
+    }
+}
+
+RGAPI int GetGamepadButtonPressed(void) {
+    if (!g_renderstate.mainWindow) return GAMEPAD_BUTTON_UNKNOWN;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return GetGamepadButtonPressed_SDL3();
+        #endif
+        default: return GAMEPAD_BUTTON_UNKNOWN;
+    }
+}
+
+RGAPI int GetGamepadAxisCount(int gamepad) {
+    if (!g_renderstate.mainWindow) return 0;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return GetGamepadAxisCount_SDL3(gamepad);
+        #endif
+        default: return 0;
+    }
+}
+
+RGAPI float GetGamepadAxisMovement(int gamepad, int axis) {
+    if (!g_renderstate.mainWindow) return 0.0f;
+    switch (g_renderstate.mainWindow->type) {
+        #if SUPPORT_SDL3 == 1
+        case windowType_sdl3: return GetGamepadAxisMovement_SDL3(gamepad, axis);
+        #endif
+        default: return 0.0f;
+    }
+}
+
 bool IsCursorOnScreen(cwoid){
     return CreatedWindowMap_get(&g_renderstate.createdSubwindows, GetActiveWindowHandle())->input_state.cursorInWindow;
 }
@@ -2858,6 +2950,9 @@ RGAPI void EndWindowMode(){
     ipstate->scrollPreviousFrame = ipstate->scrollThisFrame;
     ipstate->scrollThisFrame = CLITERAL(Vector2){0, 0};
     memcpy(ipstate->mouseButtonDownPrevious, ipstate->mouseButtonDown, MOUSEBTN_MAX);
+    for (int gp = 0; gp < GAMEPAD_MAX; gp++) {
+        memcpy(ipstate->gamepads[gp].buttonsPrevious, ipstate->gamepads[gp].buttons, GAMEPAD_BUTTON_MAX);
+    }
     g_renderstate.activeSubWindow = NULL;
     return;
 }
