Enhance gaming mode edge switching with vertical movement checks and configuration refinements.

Author: rubenPerezInsparx

.gitignore

@@ -1,3 +1,4 @@
 build
 
 .idea/
+.aider*

disk/disk.img

@@ -23,9 +23,7 @@ const config_t default_config = {
     .jump_threshold = JUMP_THRESHOLD,
 
     .gaming_mode_on_boot = true,
-    .gaming_edge_enabled = false,
-    .gaming_edge_threshold = 500,
-    .gaming_edge_window_ms = 500,
+    .gaming_edge_enabled = false,  // Global gaming edge switching disabled by default
 
     .output = {
         [OUTPUT_A] = {
@@ -45,7 +43,10 @@ const config_t default_config = {
                 .only_if_inactive = SCREENSAVER_A_ONLY_IF_INACTIVE,
                 .idle_time_us = (uint64_t)SCREENSAVER_A_IDLE_TIME_SEC * 1000000,
                 .max_time_us = (uint64_t)SCREENSAVER_A_MAX_TIME_SEC * 1000000,
-            }
+            },
+            .gaming_edge_threshold = GAMING_EDGE_THRESHOLD,
+            .gaming_edge_window_ms = GAMING_EDGE_WINDOW_MS,
+            .gaming_edge_max_vertical = GAMING_EDGE_MAX_VERTICAL,
         },
         [OUTPUT_B] = {
             .number = OUTPUT_B,
@@ -64,7 +65,10 @@ const config_t default_config = {
                 .only_if_inactive = SCREENSAVER_B_ONLY_IF_INACTIVE,
                 .idle_time_us = (uint64_t)SCREENSAVER_B_IDLE_TIME_SEC * 1000000,
                 .max_time_us = (uint64_t)SCREENSAVER_B_MAX_TIME_SEC * 1000000,
-            }
+            },
+            .gaming_edge_threshold = GAMING_EDGE_THRESHOLD,
+            .gaming_edge_window_ms = GAMING_EDGE_WINDOW_MS,
+            .gaming_edge_max_vertical = GAMING_EDGE_MAX_VERTICAL,
         }
     }
 };

src/defaults.c

@@ -15,7 +15,7 @@
 #include "misc.h"
 #include "screen.h"
 
-#define CURRENT_CONFIG_VERSION 10
+#define CURRENT_CONFIG_VERSION 9
 
 /*==============================================================================
  *  Configuration Data

src/include/config.h

@@ -48,4 +48,9 @@ typedef struct {
     uint8_t pos;               // Screen position on this output
     uint8_t mouse_park_pos;    // Where the mouse goes after switch
     screensaver_t screensaver; // Screensaver parameters for this output
+    
+    // Gaming mode edge switching per output (except enabled flag which is global)
+    uint32_t gaming_edge_threshold;
+    uint32_t gaming_edge_window_ms;
+    uint32_t gaming_edge_max_vertical;  // M2aximum allowed vertical movement
 } output_t;

src/include/screen.h

@@ -80,10 +80,7 @@ typedef struct {
     uint16_t jump_threshold;
 
     uint8_t gaming_mode_on_boot;
-
-    uint8_t gaming_edge_enabled;
-    uint16_t gaming_edge_threshold;
-    uint16_t gaming_edge_window_ms;
+    uint8_t gaming_edge_enabled;  // Global enable for edge switching in gaming mode
 
     output_t output[NUM_SCREENS];
     uint32_t _reserved;
@@ -151,7 +148,8 @@ typedef struct {
     bool digitizer_active;   // True when digitizer Win/Mac workaround is active
 
     /* Gaming mode edge switching state */
-    int32_t gaming_edge_accum;        // Accumulated movement toward edge in gaming mode
+    uint32_t gaming_edge_accum;        // Accumulated horizontal movement toward edge in gaming mode
+    int32_t gaming_edge_vertical_accum; // Accumulated net vertical movement during edge detection (can be negative)
     uint64_t gaming_edge_last_reset;  // Timestamp of last accumulator reset
 
     /* Onboard LED blinky (provide feedback when e.g. mouse connected) */

src/include/structs.h

@@ -82,6 +82,27 @@
 /* Mouse acceleration */
 #define ENABLE_ACCELERATION 1
 
+/**================================================== *
+ * ===========  Gaming Edge Switching  ============== *
+ * ================================================== *
+ *
+ * Gaming mode edge switching allows switching outputs in gaming mode
+ * by moving the mouse toward the edge of the screen.
+ *
+ * GAMING_EDGE_THRESHOLD: [0-4294967295], accumulated horizontal movement needed
+ *                        to trigger a switch (in mouse movement units)
+ * GAMING_EDGE_WINDOW_MS: [0-4294967295], time window in milliseconds for
+ *                        accumulating movement (max ~49 days)
+ * GAMING_EDGE_MAX_VERTICAL: [0-4294967295], maximum allowed vertical movement
+ *                          during edge detection (prevents accidental switches
+ *                          when moving mouse diagonally)
+ *
+ * */
+
+#define GAMING_EDGE_THRESHOLD 20000
+#define GAMING_EDGE_WINDOW_MS 1000
+#define GAMING_EDGE_MAX_VERTICAL 2000
+
 /**================================================== *
  * ==============  Screensaver Config  ============== *
  * ================================================== *

src/include/user_config.h

@@ -321,14 +321,15 @@ mouse_report_t create_mouse_report(device_t *state, mouse_values_t *values) {
     return mouse_report;
 }
 
-enum screen_pos_e check_gaming_edge_switch(device_t *state, int offset_x) {
+enum screen_pos_e check_gaming_edge_switch(device_t *state, int offset_x, int offset_y) {
+    output_t *output = &state->config.output[state->active_output];
+    
     // Feature disabled - return early
     if (!state->config.gaming_edge_enabled || !state->gaming_mode)
         return NONE;
 
-    output_t *output = &state->config.output[state->active_output];
     uint64_t now = time_us_64();
-    uint64_t window_us = state->config.gaming_edge_window_ms * 1000;
+    uint64_t window_us = (uint64_t)output->gaming_edge_window_ms * 1000;
 
     // Determine which direction would switch screens
     enum screen_pos_e switch_direction = (output->pos == LEFT) ? RIGHT : LEFT;
@@ -337,24 +338,42 @@ enum screen_pos_e check_gaming_edge_switch(device_t *state, int offset_x) {
     bool moving_toward_switch = (switch_direction == LEFT && offset_x < 0) ||
                                 (switch_direction == RIGHT && offset_x > 0);
 
-    // Reset accumulator if:
+    // Reset accumulators if:
     // - Time window expired
     // - Moving in opposite direction
+    // - Vertical movement exceeds maximum allowed
+    bool reset_needed = false;
+    
     if ((now - state->gaming_edge_last_reset) > window_us || !moving_toward_switch) {
+        reset_needed = true;
+    }
+    
+    // Update vertical accumulation
+    state->gaming_edge_vertical_accum += offset_y;
+
+    uint32_t abs_vertical = (state->gaming_edge_vertical_accum < 0)
+        ? -(uint32_t)state->gaming_edge_vertical_accum
+        : (uint32_t)state->gaming_edge_vertical_accum;
+    if (abs_vertical > output->gaming_edge_max_vertical) {
+        reset_needed = true;
+    }
+    if (reset_needed) {
         state->gaming_edge_accum = 0;
+        state->gaming_edge_vertical_accum = 0;
         state->gaming_edge_last_reset = now;
 
         // If not moving toward switch, return early
         if (!moving_toward_switch)
             return NONE;
     }
 
-    // Accumulate movement (use absolute value)
-    state->gaming_edge_accum += abs(offset_x);
+    // Accumulate horizontal movement (use absolute value)
+    state->gaming_edge_accum += (uint32_t)abs(offset_x);
 
     // Check if threshold exceeded
-    if (state->gaming_edge_accum >= state->config.gaming_edge_threshold) {
+    if (state->gaming_edge_accum >= output->gaming_edge_threshold) {
         state->gaming_edge_accum = 0;
+        state->gaming_edge_vertical_accum = 0;
         state->gaming_edge_last_reset = now;
         return switch_direction;
     }
@@ -373,14 +392,15 @@ void process_mouse_report(uint8_t *raw_report, int len, uint8_t itf, hid_interfa
     enum screen_pos_e switch_direction = update_mouse_position(state, &values);
 
     /* Check for gaming mode edge switching */
-    if (state->gaming_mode && state->config.gaming_edge_enabled) {
+    if (state->gaming_mode) {
         // Use the acceleration-adjusted offset from update_mouse_position
         output_t *current = &state->config.output[state->active_output];
         uint8_t reduce_speed = state->mouse_zoom ? MOUSE_ZOOM_SCALING_FACTOR : 0;
         float acceleration_factor = calculate_mouse_acceleration_factor(values.move_x, values.move_y);
         int offset_x = round(values.move_x * acceleration_factor * (current->speed_x >> reduce_speed));
+        int offset_y = round(values.move_y * acceleration_factor * (current->speed_y >> reduce_speed));
 
-        switch_direction = check_gaming_edge_switch(state, offset_x);
+        switch_direction = check_gaming_edge_switch(state, offset_x, offset_y);
     }
 
     /* Create the report for the output PC based on the updated values */
@@ -432,4 +452,4 @@ void queue_mouse_report(mouse_report_t *report, device_t *state) {
         return;
 
     queue_try_add(&state->mouse_queue, report);
-}
+}

src/mouse.c

@@ -30,9 +30,14 @@ const field_map_t api_field_map[] = {
     { 19, false, UINT8,  1, offsetof(device_t, config.output[0].screensaver.mode) },
     { 20, false, UINT8,  1, offsetof(device_t, config.output[0].screensaver.only_if_inactive) },
 
-    /* Until we increase the payload size from 8 bytes, clamp to avoid exceeding the field size */
-    { 21, false, UINT64, 7, offsetof(device_t, config.output[0].screensaver.idle_time_us) },
-    { 22, false, UINT64, 7, offsetof(device_t, config.output[0].screensaver.max_time_us) },
+    /* Screensaver idle and max times (64-bit values) */
+    { 21, false, UINT64, 8, offsetof(device_t, config.output[0].screensaver.idle_time_us) },
+    { 22, false, UINT64, 8, offsetof(device_t, config.output[0].screensaver.max_time_us) },
+
+    /* Gaming edge settings for Output A */
+    { 23, false, UINT32, 4, offsetof(device_t, config.output[0].gaming_edge_threshold) },
+    { 24, false, UINT32, 4, offsetof(device_t, config.output[0].gaming_edge_window_ms) },
+    { 25, false, UINT32, 4, offsetof(device_t, config.output[0].gaming_edge_max_vertical) },
 
     /* Output B */
     { 40, false, UINT32, 4, offsetof(device_t, config.output[1].number) },
@@ -46,8 +51,14 @@ const field_map_t api_field_map[] = {
     { 48, false, UINT8,  1, offsetof(device_t, config.output[1].mouse_park_pos) },
     { 49, false, UINT8,  1, offsetof(device_t, config.output[1].screensaver.mode) },
     { 50, false, UINT8,  1, offsetof(device_t, config.output[1].screensaver.only_if_inactive) },
-    { 51, false, UINT64, 7, offsetof(device_t, config.output[1].screensaver.idle_time_us) },
-    { 52, false, UINT64, 7, offsetof(device_t, config.output[1].screensaver.max_time_us) },
+    /* Screensaver idle and max times (64-bit values) */
+    { 51, false, UINT64, 8, offsetof(device_t, config.output[1].screensaver.idle_time_us) },
+    { 52, false, UINT64, 8, offsetof(device_t, config.output[1].screensaver.max_time_us) },
+
+    /* Gaming edge settings for Output B */
+    { 53, false, UINT32, 4, offsetof(device_t, config.output[1].gaming_edge_threshold) },
+    { 54, false, UINT32, 4, offsetof(device_t, config.output[1].gaming_edge_window_ms) },
+    { 55, false, UINT32, 4, offsetof(device_t, config.output[1].gaming_edge_max_vertical) },
 
     /* Common config */
     { 70, false, UINT32, 4, offsetof(device_t, config.version) },
@@ -60,8 +71,6 @@ const field_map_t api_field_map[] = {
     { 77, false, UINT16, 2, offsetof(device_t, config.jump_threshold) },
     { 83, false, UINT8,  1, offsetof(device_t, config.gaming_mode_on_boot) },
     { 84, false, UINT8,  1, offsetof(device_t, config.gaming_edge_enabled) },
-    { 85, false, UINT16, 2, offsetof(device_t, config.gaming_edge_threshold) },
-    { 86, false, UINT16, 2, offsetof(device_t, config.gaming_edge_window_ms) },
 
     /* Firmware */
     { 78, true,  UINT16, 2, offsetof(device_t, _running_fw.version) },