fix: prevent hangs during game launch

- Linux X11 remapper: open/close display per-call instead of caching
  to handle game fullscreen/X11 focus grabs gracefully
- Add X11 error handler to catch async errors without crashing
- GamepadManager: use timed_mutex with try_lock_for to prevent
  hotplug thread from blocking main thread during SDL enumeration

Fixes UnionCrax.Direct hangs during game launch

Author: veeeanti

GCPad_Lib/src/GamepadManager.cpp

@@ -12,6 +12,7 @@
 
 #include <thread>
 #include <atomic>
+#include <condition_variable>
 #include <mutex>
 #include <algorithm>
 #include <set>
@@ -54,7 +55,7 @@ class GamepadManagerImpl : public GamepadManager {
 
     std::thread hotplug_thread_;
     std::atomic<bool> hotplug_running_;
-    mutable std::mutex mutex_;
+    mutable std::timed_mutex mutex_;
 
     GamepadConnectedCallback connected_callback_;
     GamepadDisconnectedCallback disconnected_callback_;
@@ -103,7 +104,7 @@ GamepadManagerImpl::~GamepadManagerImpl() {
 }
 
 bool GamepadManagerImpl::initialize() {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
 
     // Initialize SDL2 first so we know which devices SDL has already
     // claimed before we try to open them via raw HID. On Windows, both
@@ -197,7 +198,7 @@ void GamepadManagerImpl::shutdown() {
     }
 
     // Now safe to lock — hotplug thread is dead
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
 
     for (auto& gamepad : gamepads_) {
         gamepad.reset();
@@ -223,7 +224,7 @@ void GamepadManagerImpl::shutdown() {
 }
 
 int GamepadManagerImpl::getConnectedGamepadCount() const {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
 
     int count = 0;
     for (const auto& gamepad : gamepads_) {
@@ -235,7 +236,7 @@ int GamepadManagerImpl::getConnectedGamepadCount() const {
 }
 
 std::vector<int> GamepadManagerImpl::getConnectedGamepadIndices() const {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
 
     std::vector<int> indices;
     for (int i = 0; i < MAX_GAMEPADS; ++i) {
@@ -247,7 +248,7 @@ std::vector<int> GamepadManagerImpl::getConnectedGamepadIndices() const {
 }
 
 GamepadDevice* GamepadManagerImpl::getGamepad(int index) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
 
     if (index >= 0 && index < MAX_GAMEPADS && gamepads_[index]) {
         return gamepads_[index].get();
@@ -256,7 +257,7 @@ GamepadDevice* GamepadManagerImpl::getGamepad(int index) {
 }
 
 const GamepadDevice* GamepadManagerImpl::getGamepad(int index) const {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
 
     if (index >= 0 && index < MAX_GAMEPADS && gamepads_[index]) {
         return gamepads_[index].get();
@@ -265,12 +266,12 @@ const GamepadDevice* GamepadManagerImpl::getGamepad(int index) const {
 }
 
 void GamepadManagerImpl::setGamepadConnectedCallback(GamepadConnectedCallback callback) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
     connected_callback_ = callback;
 }
 
 void GamepadManagerImpl::setGamepadDisconnectedCallback(GamepadDisconnectedCallback callback) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
     disconnected_callback_ = callback;
 }
 
@@ -284,13 +285,13 @@ void GamepadManagerImpl::updateAll() {
 }
 
 void GamepadManagerImpl::setRemapper(std::shared_ptr<Remapper> remapper) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
     global_remapper_ = std::move(remapper);
     apply_remapper_to_all();
 }
 
 std::shared_ptr<Remapper> GamepadManagerImpl::getRemapper() const {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::timed_mutex> lock(mutex_);
     return global_remapper_;
 }
 
@@ -306,7 +307,13 @@ void GamepadManagerImpl::hotplug_detection_loop() {
     while (hotplug_running_) {
         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 
-        std::lock_guard<std::mutex> lock(mutex_);
+        // FIX: Use try_lock with timeout to avoid blocking game launch.
+        // SDL enumeration can freeze momentarily when games are starting.
+        std::unique_lock<std::timed_mutex> lock(mutex_, std::defer_lock);
+        if (!lock.try_lock_for(std::chrono::milliseconds(100))) {
+            // Skip this cycle if mutex is held by another thread
+            continue;
+        }
 
 #ifdef _WIN32
         check_for_new_devices();

GCPad_Remap/src/gamepad_input_remapper.cpp

@@ -3,6 +3,7 @@
 #include <cmath>
 #include <algorithm>
 #include <cstring>
+#include <atomic>
 
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
@@ -69,6 +70,17 @@ static float axisToMouseMotionF(float value, const AxisMouseMapping& mapping) {
     return processed * mapping.sensitivity;
 }
 
+#ifdef __linux__
+// Global error handler state for X11 async error handling
+static std::atomic<int> g_x11_error_occurred{0};
+
+static int x11_error_handler(Display* /*display*/, XErrorEvent* /*event*/) {
+    // Don't crash on X11 errors - game may have grabbed focus
+    g_x11_error_occurred.store(1, std::memory_order_relaxed);
+    return 0;
+}
+#endif
+
 // ── Construction / reset ─────────────────────────────────────────────────────
 
 GamepadInputRemapper::GamepadInputRemapper() {
@@ -459,17 +471,46 @@ bool GamepadInputRemapper::sendInput(const GamepadState& current,
 
     return true;
 #elif defined(__linux__)
-    static Display* display = XOpenDisplay(nullptr);
+    // FIX: Open and close X11 display per-call instead of caching.
+    // When a game launches fullscreen, it takes control of X11 and the
+    // cached display handle becomes invalid, causing X11 calls to block.
+    // Also set up error handler to prevent crashes on X11 errors.
+    g_x11_error_occurred.store(0, std::memory_order_relaxed);
+    XSetErrorHandler(x11_error_handler);
+    
+    Display* display = XOpenDisplay(nullptr);
     if (!display) {
+        XSetErrorHandler(nullptr);
         return false;
     }
 
+    // Check if error occurred during display open
+    if (g_x11_error_occurred.load(std::memory_order_relaxed)) {
+        XCloseDisplay(display);
+        XSetErrorHandler(nullptr);
+        return false;
+    }
+
+    // Try to get input focus - this may fail during game launch
     Window root = DefaultRootWindow(display);
-    Window focus;
-    int revert_to;
+    Window focus = 0;
+    int revert_to = 0;
+    
+    // Use XGetInputFocus with error checking
     XGetInputFocus(display, &focus, &revert_to);
+    int focus_error = XSync(display, False);
+    if (g_x11_error_occurred.load(std::memory_order_relaxed)) {
+        XCloseDisplay(display);
+        XSetErrorHandler(nullptr);
+        return false;
+    }
 
     for (const auto& e : events) {
+        // Skip further processing if error occurred
+        if (g_x11_error_occurred.load(std::memory_order_relaxed)) {
+            break;
+        }
+        
         switch (e.type) {
             case GamepadInputEvent::Type::Keyboard: {
                 KeyCode keycode = static_cast<KeyCode>(e.keyboard.virtual_key);
@@ -511,7 +552,9 @@ bool GamepadInputRemapper::sendInput(const GamepadState& current,
     }
 
     XFlush(display);
-    return true;
+    XCloseDisplay(display);
+    XSetErrorHandler(nullptr);
+    return !g_x11_error_occurred.load(std::memory_order_relaxed);
 #else
     (void)events;
     return false;
@@ -541,16 +584,34 @@ std::string GamepadInputRemapper::virtualKeyName(uint16_t vk) {
     snprintf(buf, sizeof(buf), "VK_0x%02X", vk);
     return buf;
 #elif defined(__linux__)
-    static Display* display = XOpenDisplay(nullptr);
+    // FIX: Open and close display per-call instead of caching.
+    // This ensures we get a fresh connection that works even after
+    // a game has taken control of X11.
+    Display* display = XOpenDisplay(nullptr);
     if (!display) {
         char buf[32];
         snprintf(buf, sizeof(buf), "VK_0x%02X", vk);
         return buf;
     }
+    
+    g_x11_error_occurred.store(0, std::memory_order_relaxed);
+    XSetErrorHandler(x11_error_handler);
+    
     KeyCode keycode = static_cast<KeyCode>(vk);
-    KeySym keysym = XKeycodeToKeysym(display, keycode, 0);
+    // Use XGetKeyboardMapping as fallback for XKeycodeToKeysym deprecation
+    KeySym keysym = 0;
+    int keysyms_per_keycode_return = 0;
+    KeySym* keysym_map = XGetKeyboardMapping(display, keycode, 1, &keysyms_per_keycode_return);
+    if (keysym_map && keysyms_per_keycode_return > 0) {
+        keysym = keysym_map[0];
+        XFree(keysym_map);
+    }
     const char* name = XKeysymToString(keysym);
-    if (name) {
+    
+    XSetErrorHandler(nullptr);
+    XCloseDisplay(display);
+    
+    if (name && !g_x11_error_occurred.load(std::memory_order_relaxed)) {
         return std::string(name);
     }
     char buf[32];
@@ -563,4 +624,4 @@ std::string GamepadInputRemapper::virtualKeyName(uint16_t vk) {
 #endif
 }
 
-} // namespace gcpad
+} // namespace gcpad