Release v5.0: raw mouse pump WM_INPUT skip, cvar callback fix, logging

Author: d3nd3

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v5.0
+
+- Raw mouse: message pump no longer removes `WM_INPUT` from the queue (avoids high-frequency peel cost on high-poll mice). Uses filtered `PeekMessage` bands around `WM_INPUT` when it blocks the head; otherwise `GetMessage` for strict FIFO. When both low-ID and high-ID candidates exist, orders by `MSG.time` with high-band tie-break for mouse/client messages. Raises per-pump cap to 10 dispatched messages; updates `sys_msg_time` and centralizes quit/dispatch in `DispatchOneMsg`.
+- Raw mouse: fix enabling `_sofbuddy_rawmouse` when the engine runs the cvar change callback before `Cvar_Get` returns — set `in_mouse_raw = cvar` at the start of `raw_mouse_on_change`; drop redundant second `raw_mouse_on_change` after registration (avoids false “not enabled” / “registration failed” pairs and duplicate “ENABLED” logs).
+- Raw mouse: optional dev logging when `raw_mouse_ensure_registered` is asked to log — “not enabled or API not supported”, “already registered for this window”; `raw_mouse_register_input` logs “Raw input registration succeeded” when registration completes.
+
 ## v4.9
 
 - Raw mouse: register raw input only with HWNDs owned by the game process (`GetWindowThreadProcessId` vs `GetCurrentProcessId`). Resolve the window via `GetGUIThreadInfo`, then `GetActiveWindow` / `GetForegroundWindow` only when they are local, plus `EnumThreadWindows` fallback—fixes `RegisterRawInputDevices` failing with error 87 (`ERROR_INVALID_PARAMETER`) when foreground belonged to another app or at startup. Cvar enable uses the same `raw_mouse_ensure_registered` path as the message pump; clearer log lines for invalid HWND and for error 87.

VERSION

@@ -1 +1 @@
-4.9
+5.0

hdr/version.h

@@ -7,4 +7,4 @@
     Increment version using: ./increment_version.sh
 */
 
-#define SOFBUDDY_VERSION "4.9"
+#define SOFBUDDY_VERSION "5.0"

src/features/raw_mouse/raw_cvars.cpp

@@ -13,6 +13,9 @@ cvar_t * in_mouse_raw = NULL;
 void raw_mouse_on_change(cvar_t *cvar)
 {
     if (!cvar) return;
+    /* Cvar_Get may invoke this callback before returning; in_mouse_raw is not
+     * assigned yet, so raw_mouse_is_enabled() would read a null pointer. */
+    in_mouse_raw = cvar;
 
     raw_mouse_reset_deltas();
     raw_mouse_center_valid = false;
@@ -38,11 +41,6 @@ void raw_mouse_on_change(cvar_t *cvar)
 void create_raw_mouse_cvars(void) {
     in_mouse_raw = orig_Cvar_Get("_sofbuddy_rawmouse", "0", CVAR_SOFBUDDY_ARCHIVE, &raw_mouse_on_change);
 
-    // Apply archived state immediately in case callback is not triggered on load.
-    if (in_mouse_raw && in_mouse_raw->value != 0.0f) {
-        raw_mouse_on_change(in_mouse_raw);
-    }
-
     PrintOut(PRINT_DEV, "raw_mouse: Registered _sofbuddy_rawmouse cvar with change callback\n");
 }
 

src/features/raw_mouse/raw_message_pump.cpp

@@ -13,30 +13,83 @@
 #ifndef WM_INPUT
 #define WM_INPUT 0x00FF
 #endif
-#ifndef WM_QUIT
-#define WM_QUIT 0x0012
-#endif
 
-static const int MAX_MSG_PER_FRAME = 5;
+static const int MAX_MSG_PER_FRAME = 10;
 
 static void QuitPath();
 static void SV_Shutdown(char*, int);
+static unsigned* SysMsgTimePtr();
+
+
+static void DispatchOneMsg(MSG* m, bool from_winmain) {
+  if (m->message == WM_QUIT) {
+    if (from_winmain) {
+      SV_Shutdown(nullptr, 0);
+    }
+    QuitPath();
+  }
+  *SysMsgTimePtr() = static_cast<unsigned>(m->time);
+  TranslateMessage(m);
+  DispatchMessageA(m);
+}
 
 void PumpWindowMessagesCapped(bool from_winmain) {
   MSG msg;
+  MSG low_msg;
+  MSG high_msg;
   int processed = 0;
+  /* WM_INPUT is never removed (avoids high-frequency peel cost). When it sits at
+   * the queue head, PeekMessage with ID bands skips it and removes the next matching
+   * message. When the head is not WM_INPUT, GetMessage preserves strict FIFO.
+   * If both bands have a candidate (WM_INPUT at head, or interleaved), msg.time
+   * picks the earlier; tie-break prefers high band (mouse / client-area messages). */
   while (processed < MAX_MSG_PER_FRAME &&
-         PeekMessageA(&msg, nullptr, 0, WM_INPUT - 1, PM_REMOVE)) {
-    if (msg.message == WM_QUIT) { if (from_winmain) SV_Shutdown(nullptr, 0); QuitPath(); }
-    TranslateMessage(&msg);
-    DispatchMessageA(&msg);
-    ++processed;
-  }
-  while (processed < MAX_MSG_PER_FRAME &&
-         PeekMessageA(&msg, nullptr, WM_INPUT + 1, 0xFFFFFFFF, PM_REMOVE)) {
-    if (msg.message == WM_QUIT) { if (from_winmain) SV_Shutdown(nullptr, 0); QuitPath(); }
-    TranslateMessage(&msg);
-    DispatchMessageA(&msg);
+         PeekMessageA(&msg, nullptr, 0, 0, PM_NOREMOVE)) {
+    if (msg.message != WM_INPUT) {
+      if (!GetMessageA(&msg, nullptr, 0, 0)) {
+        if (from_winmain) {
+          SV_Shutdown(nullptr, 0);
+        }
+        QuitPath();
+      }
+      DispatchOneMsg(&msg, from_winmain);
+      ++processed;
+      continue;
+    }
+
+    const BOOL has_low =
+        PeekMessageA(&low_msg, nullptr, 0, WM_INPUT - 1, PM_NOREMOVE);
+    const BOOL has_high = PeekMessageA(&high_msg, nullptr, WM_INPUT + 1, 0xFFFFFFFF,
+                                        PM_NOREMOVE);
+    if (!has_low && !has_high) {
+      break;
+    }
+    if (has_low && !has_high) {
+      if (!PeekMessageA(&msg, nullptr, 0, WM_INPUT - 1, PM_REMOVE)) {
+        break;
+      }
+    } else if (!has_low && has_high) {
+      if (!PeekMessageA(&msg, nullptr, WM_INPUT + 1, 0xFFFFFFFF, PM_REMOVE)) {
+        break;
+      }
+    } else {
+      const DWORD t_low = low_msg.time;
+      const DWORD t_high = high_msg.time;
+      if (t_low < t_high) {
+        if (!PeekMessageA(&msg, nullptr, 0, WM_INPUT - 1, PM_REMOVE)) {
+          break;
+        }
+      } else if (t_high < t_low) {
+        if (!PeekMessageA(&msg, nullptr, WM_INPUT + 1, 0xFFFFFFFF, PM_REMOVE)) {
+          break;
+        }
+      } else {
+        if (!PeekMessageA(&msg, nullptr, WM_INPUT + 1, 0xFFFFFFFF, PM_REMOVE)) {
+          break;
+        }
+      }
+    }
+    DispatchOneMsg(&msg, from_winmain);
     ++processed;
   }
 }

src/features/raw_mouse/raw_shared.cpp

@@ -231,7 +231,12 @@ static HWND RawMouseGetRoot(HWND hwnd) {
 }
 
 void raw_mouse_ensure_registered(HWND hwnd_hint, bool log_register_attempts) {
-  if (!raw_mouse_is_enabled() || !raw_mouse_api_supported()) return;
+  if (!raw_mouse_is_enabled() || !raw_mouse_api_supported()){
+    if (log_register_attempts) {
+      PrintOut(PRINT_BAD, "raw_mouse: Raw input is not enabled or API is not supported\n");
+    }
+    return;
+  } 
   if (raw_mouse_hwnd_target && !IsWindow(raw_mouse_hwnd_target)) {
     raw_mouse_registered = false;
     raw_mouse_hwnd_target = nullptr;
@@ -247,7 +252,12 @@ void raw_mouse_ensure_registered(HWND hwnd_hint, bool log_register_attempts) {
     return;
   }
   HWND root = RawMouseGetRoot(hwnd);
-  if (raw_mouse_registered && raw_mouse_hwnd_target && IsWindow(raw_mouse_hwnd_target) && RawMouseGetRoot(raw_mouse_hwnd_target) == root) return;
+  if (raw_mouse_registered && raw_mouse_hwnd_target && IsWindow(raw_mouse_hwnd_target) && RawMouseGetRoot(raw_mouse_hwnd_target) == root) {
+    if (log_register_attempts) {
+      PrintOut(PRINT_DEV, "raw_mouse: Raw input is already registered for this window\n");
+    }
+    return;
+  }
   raw_mouse_register_input(root, log_register_attempts);
 }
 
@@ -373,6 +383,9 @@ bool raw_mouse_register_input(HWND hwnd, bool log_result) {
   raw_mouse_registered = true;
   raw_mouse_hwnd_target = hwnd;
   raw_mouse_refresh_cursor_clip(hwnd);
+  if (log_result) {
+    PrintOut(PRINT_DEV, "raw_mouse: Raw input registration succeeded\n");
+  }
   return true;
 #endif
 }