SDL3: SDL_EVENT_MOUSE_MOTION relative movement stops at screen borders

[thrust26]

With SDL_SetWindowMouseGrab enabled (and mouse cursor disabled), the invisible mouse cursor will sooner or later hit a screen border. While this should be no problem when checking only the relative mouse movements, the relative movements reported by SDL_EVENT_MOUSE_MOTION are stopping in SDL 3 then too. This is different to SDL 2, where the absolute positions stop at the screen border too, but the relative positions continue to provide the movement values.

E.g. if you have a 800 pixel wide screen, you eventually get 799 as x position. If you move the mouse further right in SDL 2, xrel will continue to return values > 0, while in SDL 3 xrel will be 0.

Windows 10 x64, Direct 3D and OpenGL, SDL 3.2.14

[slime73]

Does SDL_SetWindowRelativeMouseMode fit your use case?

 * Set relative mouse mode for a window.
 *
 * While the window has focus and relative mouse mode is enabled, the cursor
 * is hidden, the mouse position is constrained to the window, and SDL will
 * report continuous relative mouse motion even if the mouse is at the edge of
 * the window.
 *
 * If you'd like to keep the mouse position fixed while in relative mode you
 * can use SDL_SetWindowMouseRect(). If you'd like the cursor to be at a
 * specific location when relative mode ends, you should use
 * SDL_WarpMouseInWindow() before disabling relative mode.

[thrust26]

Thanks. That does the trick. Somehow.

The bug is gone, but the mouse feels sluggish and not precise now. What's happening here? Is the OS suddenly kicking in?

Should I open a new issue for this? (it was much better with SDL 2)

[thrust26]

I did some more testing and it seems that with SDL_SetWindowRelativeMouseMode enabled, the mouse ignores the OS settings. Is there a way to combine both? As it was in SDL 2?

If tried SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE but the cursor still behaves different.

[slouken]

I did some more testing and it seems that with SDL_SetWindowRelativeMouseMode enabled, the mouse ignores the OS settings. Is there a way to combine both? As it was in SDL 2?

If tried SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE but the cursor still behaves different.

That should work. Can you describe how the cursor behaves differently? Adding @expikr for visibility.

[expikr]

minimal test app

#define SDL_MAIN_USE_CALLBACKS
#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <windows.h>

static char debug_string[32];
static bool system_scale_enabled;

typedef struct {
    SDL_Window *window;
    SDL_Renderer *renderer;
} AppState;

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    AppState *as = SDL_calloc(1, sizeof(AppState));
    if (!as) {
        return SDL_APP_FAILURE;
    } else {
        *appstate = as;
    }

    if (!SDL_Init(SDL_INIT_VIDEO)) {
        return SDL_APP_FAILURE;
    }
    if (!SDL_CreateWindowAndRenderer("mouse test", 640, 480, SDL_WINDOW_FULLSCREEN, &as->window, &as->renderer)) {
        return SDL_APP_FAILURE;
    }

    SDL_SetHintWithPriority(SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE, "1", SDL_HINT_OVERRIDE);
    SDL_SetHintWithPriority(SDL_HINT_MOUSE_RELATIVE_MODE_CENTER, "0", SDL_HINT_OVERRIDE);
    SDL_SetHintWithPriority(SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE, "1", SDL_HINT_OVERRIDE);
    system_scale_enabled = true;

    SDL_SetWindowRelativeMouseMode(as->window, true);
    {
        int x0, y0;
        float x, y;
        SDL_GetGlobalMouseState(&x, &y);
        SDL_GetWindowPosition(as->window, &x0, &y0);
        SDL_WarpMouseInWindow(as->window, x-(float)x0, y-(float)y0);
    }
    debug_string[0] = 0;
    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
{
    AppState *as = appstate;
    int i;
    switch (event->type) {
        case SDL_EVENT_QUIT:
            return SDL_APP_SUCCESS;
            break;
        case SDL_EVENT_KEY_UP: {
            SDL_Keycode sym = event->key.key;
            if (sym == SDLK_ESCAPE) return SDL_APP_SUCCESS;
            if (sym == SDLK_R) {
                system_scale_enabled = !system_scale_enabled;
                SDL_SetHintWithPriority(SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE, system_scale_enabled ? "1" : "0", SDL_HINT_OVERRIDE);
                int x0, y0;
                float x, y;
                SDL_GetGlobalMouseState(&x, &y);
                SDL_GetWindowPosition(as->window, &x0, &y0);
                SDL_WarpMouseInWindow(as->window, x-(float)x0, y-(float)y0);
            };
            break;
        }
    }
    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    AppState *as = appstate;
    static Uint64 accu = 0;
    static Uint64 last = 0;
    static Uint64 past = 0;
    Uint64 now = SDL_GetTicksNS();
    Uint64 dt_ns = now - past;
    {
        int w, h;
        float x, y;
        SDL_Renderer *renderer = as->renderer;
        SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
        SDL_RenderClear(renderer);
        SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
        SDL_RenderDebugText(renderer, 0, 0, debug_string);
        SDL_GetRenderOutputSize(renderer, &w, &h);
        SDL_GetMouseState(&x, &y);
        if (!system_scale_enabled) SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
        SDL_RenderLine(renderer, x, 0, x, h);
        SDL_RenderLine(renderer, 0, y, w, y);
        SDL_RenderPresent(renderer);
    }
    if (now - last > 999999999) {
        last = now;
        SDL_snprintf(debug_string, sizeof(debug_string), "%" SDL_PRIu64 " fps", accu);
        accu = 0;
    }
    past = now;
    accu += 1;
    Uint64 elapsed = SDL_GetTicksNS() - now;
    if (elapsed < 999999) {
        SDL_DelayNS(999999 - elapsed);
    }
    return SDL_APP_CONTINUE;
}

void SDL_AppQuit(void *appstate, SDL_AppResult result)
{
    SDL_free(appstate);
}

[slouken]

@thrust26, if you run the test app @expikr wrote above, you'll see a white crosshair that should match the system cursor as you move around. That's relative mode with SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE enabled. If you press 'R', the crosshair will turn red, and SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE will be off, and you can compare the difference.

[thrust26]

Thanks, that seems to work identical. With and without grabbed mouse, with and without visible cursor, red or not.

Hm... I will have to compare with our code...

[expikr]

What mouse setting are you using?

[thrust26]

I am now using the settings from the demo. The mouse movement is fine, but we are back to the original problem. With mouse grab enabled, the mouse seems to hit invisible barriers at varying positions. You can overcome these barriers by moving the mouse into opposite directions. It seems that the mouse behaves as it is inside a differently positioned window. Note: Windowed mode.

I tried to adapt the test code, but that doesn't work. In windowed mode one or both lines disappear. With and without SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE enabled.

[slouken]

Is the issue that setting both relative mouse mode and grabbing the mouse together causes this issue? In this case are you still getting relative motion in the mouse events? If not, can you adapt the example above to show the problem?

[thrust26]

I am still experimenting. Got the demo working as expected, but our own code behaves differently, even with the same mouse settings applied.

Could it be due to the input processing? We are using SDL_PollEvent and then react to SDL_EVENT_MOUSE_MOTION. This is used because we also use the mouse movement (relative positions) to emulate digital input. And working well in SDL2.

Your code seems to do no event handling, and instead just repositions the mouse at an absolute position each frame(or so). That's something completely different, right?

BTW: I don't get the description of SDL_HINT_MOUSE_RELATIVE_MODE_CENTER:

 * A variable controlling whether relative mouse mode constrains the mouse to
 * the center of the window.
 *
 * Constraining to the center of the window works better for FPS games and
 * when the application is running over RDP. Constraining to the whole window
 * works better for 2D games and increases the chance that the mouse will be
 * in the correct position when using high DPI mice.

What sense does a mouse constraint to the center of a window make? Then you cannot move it anymore. 😕

[slouken]

You shouldn’t set any of the hints in the demo above, they’re just used to make it easier to see what the mouse is doing.