Keep the wheel's focus until the pointer leaves a dead zone, and draw a pointer of our own

After the scroll wheel, the keys or the pad move the focus in a menu, the pointer takes it back only once it has
moved 6 layout units from where it was then (menu_cursor_poll), so a hand resting on the mouse no longer undoes a
scroll. While the cursor is not captured, the game window shows a gold arrowhead drawn at the window's DPI
(cursor_art.c) instead of the Windows arrow.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
itaskaev2andClaude Opus 5.5 committed 2026-11-11 09:44:01 +01:00
1 parent a10c546a06
commit c0ca89fdda
5 files changed
+168 -4

No files matched your search

+89
View File
@@ -0,0 +1,89 @@
// The mouse pointer's image in the game window while the cursor is not captured (the game's menus, the settings menu):
// a gold arrowhead with a notched back, a dark outline, a turquoise gem and a soft shadow, drawn here at the size the
// window's DPI asks for instead of the Windows arrow. input_win.c and input_sdl.c make the system cursor from it.
// Nothing comes from the game's files.
#include <math.h>
#include <stdint.h>
#include "input_wsys.h"
typedef struct { float x, y; } V;
// In units of a 32-pixel cursor: the tip at the top left (the hotspot), the wings to the right and below, the notch
// between them
static const V SHAPE[] = {{1.5f, 1.5f}, {25.0f, 10.5f}, {14.5f, 14.5f}, {10.5f, 25.0f}};
static const V GEM[] = {{10.4f, 7.6f}, {13.0f, 10.2f}, {10.4f, 12.8f}, {7.8f, 10.2f}};
#define OUTLINE 1.7f // the dark edge's width
#define SHADOW 1.6f // the shadow's offset to the bottom right
static float seg_dist(V p, V a, V b) {
float dx = b.x - a.x, dy = b.y - a.y, t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / (dx * dx + dy * dy);
t = t < 0 ? 0 : t > 1 ? 1 : t;
float ex = a.x + t * dx - p.x, ey = a.y + t * dy - p.y;
return sqrtf(ex * ex + ey * ey);
}
// Distance to the polygon's edge, negative inside (even-odd: the shapes are simple)
static float poly_sdf(V p, const V *v, int n) {
float d = 1e9f;
int in = 0;
for (int i = 0, j = n - 1; i < n; j = i++) {
float e = seg_dist(p, v[j], v[i]);
if (e < d) d = e;
if ((v[i].y > p.y) != (v[j].y > p.y) && p.x < (v[j].x - v[i].x) * (p.y - v[i].y) / (v[j].y - v[i].y) + v[i].x)
in = !in;
}
return in ? -d : d;
}
// One sample's colour (straight r, g, b in 0..1) and coverage
static float sample(V p, float *r, float *g, float *b) {
float d = poly_sdf(p, SHAPE, 4);
if (d < 0) {
if (-d < OUTLINE) { *r = 0.17f, *g = 0.11f, *b = 0.04f; return 1; }
if (poly_sdf(p, GEM, 4) < 0) { // the gem, lighter towards its top left
float t = (p.x + p.y - 20.4f) / 5.2f + 0.5f;
t = t < 0 ? 0 : t > 1 ? 1 : t;
*r = 0.62f - 0.42f * t, *g = 0.98f - 0.22f * t, *b = 0.92f - 0.12f * t;
return 1;
}
// gold, pale at the tip and deeper at the wings; a thin light line inside the outline
float t = (p.x + p.y) / 34.0f;
t = t < 0 ? 0 : t > 1 ? 1 : t;
float rim = -d < OUTLINE + 1.0f ? 0.12f : 0;
*r = fminf(1, 1.00f - 0.12f * t + rim), *g = fminf(1, 0.93f - 0.32f * t + rim),
*b = fminf(1, 0.70f - 0.52f * t + rim);
return 1;
}
V s = {p.x - SHADOW, p.y - SHADOW};
float ds = poly_sdf(s, SHAPE, 4);
if (ds < 0.8f) { // the shadow, soft at its edge
*r = *g = *b = 0;
float a = ds < -0.8f ? 1 : (0.8f - ds) / 1.6f;
return 0.38f * a;
}
return 0;
}
void cursor_art(uint32_t *argb, int size, int *hot) {
float k = 32.0f / (float)size;
enum { SS = 4 }; // 4 x 4 samples a pixel
for (int y = 0; y < size; y++)
for (int x = 0; x < size; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int sy = 0; sy < SS; sy++)
for (int sx = 0; sx < SS; sx++) {
V p = {(x + (sx + 0.5f) / SS) * k, (y + (sy + 0.5f) / SS) * k};
float sr, sg, sb, c = sample(p, &sr, &sg, &sb);
r += sr * c, g += sg * c, b += sb * c, a += c;
}
uint32_t px = 0;
if (a > 0) { // straight alpha, as Windows and SDL take it
r /= a, g /= a, b /= a, a /= SS * SS;
px = (uint32_t)lrintf(a * 255) << 24 | (uint32_t)lrintf(r * 255) << 16 |
(uint32_t)lrintf(g * 255) << 8 | (uint32_t)lrintf(b * 255);
}
argb[y * size + x] = px;
}
*hot = (int)(1.5f / k);
}
+18
View File
@@ -200,8 +200,26 @@ void ikb_menu_closed(void) {
if (o & CUR_ESC) plat_cas32(&cur_rel, 0, o);
}
// The pointer over the window while the cursor is not captured (cursor_art.c), sized by the window's display scale.
// The default arrow stays when SDL refuses it.
static void art_cursor(SDL_Window *w) {
float scale = SDL_GetWindowDisplayScale(w);
int size = (int)lrintf(32 * (scale > 0 ? scale : 1)), hot;
size = size < 32 ? 32 : size > 128 ? 128 : size;
SDL_Surface *s = SDL_CreateSurface(size, size, SDL_PIXELFORMAT_ARGB8888);
if (!s) return;
if (s->pitch == size * 4) {
cursor_art(s->pixels, size, &hot);
SDL_Cursor *c = SDL_CreateColorCursor(s, hot, hot);
if (c) SDL_SetCursor(c);
else rt_log("input: the pointer's image failed (%s); the arrow stays", SDL_GetError());
}
SDL_DestroySurface(s);
}
void input_sdl_window(SDL_Window *w) {
win = w;
art_cursor(w);
wake_event = SDL_RegisterEvents(1);
plat_xchg32(&focused, (SDL_GetWindowFlags(w) & SDL_WINDOW_INPUT_FOCUS) != 0);
__atomic_store_n(&ptr_have, 0, __ATOMIC_RELEASE); // the pointer's place is unknown until it enters or moves
+37 -1
View File
@@ -122,6 +122,39 @@ static void cursor_update(HWND h) {
ReleaseSRWLockExclusive(&cur_lock);
}
// The pointer shown over the client area while the cursor is not captured (cursor_art.c), 32 pixels at 96 DPI and
// larger with the window's DPI; made again when the DPI changes. Window thread. NULL when Windows refuses it: the
// window class's arrow stays.
static HCURSOR art_cursor(HWND h) {
static HCURSOR cur;
static UINT made_dpi;
UINT dpi = GetDpiForWindow(h);
if (!dpi) dpi = USER_DEFAULT_SCREEN_DPI;
if (cur && dpi == made_dpi) return cur;
int size = MulDiv(32, (int)dpi, USER_DEFAULT_SCREEN_DPI), hot;
size = size < 32 ? 32 : size > 128 ? 128 : size;
BITMAPV5HEADER bh = {.bV5Size = sizeof bh, .bV5Width = size, .bV5Height = -size, .bV5Planes = 1, .bV5BitCount = 32,
.bV5Compression = BI_BITFIELDS, .bV5RedMask = 0xff0000, .bV5GreenMask = 0xff00,
.bV5BlueMask = 0xff, .bV5AlphaMask = 0xff000000u};
void *bits = NULL;
HDC dc = GetDC(NULL);
HBITMAP color = CreateDIBSection(dc, (BITMAPINFO *)&bh, DIB_RGB_COLORS, &bits, NULL, 0);
ReleaseDC(NULL, dc);
HBITMAP mask = CreateBitmap(size, size, 1, 1, NULL);
HCURSOR made = NULL;
if (color && mask && bits) {
cursor_art(bits, size, &hot);
ICONINFO ii = {.fIcon = FALSE, .xHotspot = (DWORD)hot, .yHotspot = (DWORD)hot, .hbmMask = mask,
.hbmColor = color};
made = (HCURSOR)CreateIconIndirect(&ii);
}
if (color) DeleteObject(color);
if (mask) DeleteObject(mask);
if (!made) return cur; // the old size, or NULL
cur = made, made_dpi = dpi; // the old one may still be on screen: kept (a DPI change is rare)
return cur;
}
int input_cursor_released(void) { return (cur_rel & CUR_REL) != 0; }
void input_cursor_suspend(int on) {
@@ -159,7 +192,10 @@ int input_window_msg(HWND h, UINT m, WPARAM w, LPARAM l, LRESULT *res) {
break; // DefWindowProc must see WM_INPUT for cleanup
}
case WM_SETCURSOR:
if (cur_captured && LOWORD(l) == HTCLIENT) { SetCursor(NULL); *res = TRUE; return 1; }
if (LOWORD(l) == HTCLIENT) {
HCURSOR c = cur_captured ? NULL : art_cursor(h);
if (cur_captured || c) { SetCursor(c); *res = TRUE; return 1; }
}
break;
case WM_SYSCOMMAND: // Alt pressed alone would enter the window menu loop, which stalls the game: Alt is a game key
if ((w & 0xFFF0) == SC_KEYMENU && l == 0) { *res = 0; return 1; }
+5
View File
@@ -19,5 +19,10 @@ int32_t ikb_wheel_take(void); // whole wheel notches turned sinc
void ikb_cursor_update(void); // what input_cursor_allowed says may have changed
void ikb_menu_closed(void); // the menu closed: a capture that Esc gave up comes back
// ---- shared by the back ends
// cursor_art.c: the pointer's image at size x size pixels (0xAARRGGBB, straight alpha, rows from the top) and its
// hotspot (*hot, the same in x and y). Pure.
void cursor_art(uint32_t *argb, int size, int *hot);
// ---- what input.c provides the back end
int input_cursor_allowed(void); // no text entry or menu open, the mouse camera on, input not disabled
+19 -3
View File
@@ -50,6 +50,10 @@ enum { DI_PROJ = 0x10, DI_VIEW = 0x50, LYT_ROOT = 0x18, LYT_SIZE = 0x28, LYT_NAM
// nn::ui2d::Pane
enum { PANE_PARENT = 0x18, PANE_SIZE = 0x50, PANE_FLAG = 0x58, PANE_ALPHA = 0x59, PANE_BASE = 0x5b, PANE_MTX = 0x70 };
// How far the pointer moves, in layout units (1280 x 720 across the picture: 1.5 window pixels at 1080p, 3 at 4K),
// before it takes back a focus that the wheel, the keys or the pad moved away from it (menu_cursor_poll)
#define DEAD_ZONE 6.0f
static uint64_t main_lo, main_hi;
static int ok_at(uint64_t p, uint64_t n) {
@@ -324,9 +328,10 @@ static void log_screen(const Focus *f, const char *nm, int n, float lw, float lh
// Once per pad read on the game thread: the pointer's hover and clicks, as pad buttons (A, B) for this read
void menu_cursor_poll(uint64_t *buttons) {
static int inited, pending_a, held_l, held_r;
static int inited, pending_a, held_l, held_r, anchored;
static uint64_t pending_node, pending_until, hold_until, hold_bit, menu_seen;
static float last_px = -1, last_py = -1;
static uint64_t ptr_node, last_focus; // the item the pointer last pointed at, the focus at the last read
static float last_px = -1, last_py = -1, anchor_px, anchor_py;
if (!inited) {
inited = 1;
main_lo = MOD_MAIN_BASE, main_hi = MOD_MAIN_BASE + MAIN_SIZE;
@@ -367,7 +372,7 @@ void menu_cursor_poll(uint64_t *buttons) {
return;
}
if (gap) return; // a click's focus request waits for the next screen
if (!menu) { pending_a = 0; last_px = last_py = -1; return; }
if (!menu) { pending_a = 0, anchored = 0, ptr_node = last_focus = 0; last_px = last_py = -1; return; }
if (pending_a) { // the focus asked for by a click: A once it is there
if (rd64(f.control + CTL_ACTIVE) == pending_node) {
pending_a = 0, hold_until = now + 60, hold_bit = 1ull << B_A;
@@ -381,11 +386,21 @@ void menu_cursor_poll(uint64_t *buttons) {
if (click_r) { hold_until = now + 60, hold_bit = 1ull << B_B; *buttons |= hold_bit; return; }
float px, py;
if (!picture_pos(&px, &py)) return;
// The focus moved to another item than the pointer's (the scroll wheel, the keys, the pad): the pointer takes it
// back only after it has left a dead zone of DEAD_ZONE layout units around where it was then, so a hand resting on
// the mouse does not undo a scroll. A click still acts at once.
if (f.node != last_focus) {
if (f.node != ptr_node) anchored = 1, anchor_px = px, anchor_py = py;
last_focus = f.node;
}
int moved = fabsf(px - last_px) > 0.001f || fabsf(py - last_py) > 0.001f;
if (!moved && !click_l) return;
last_px = px, last_py = py;
float lw, lh;
layout_size(f.screen, &lw, &lh);
if (anchored && !click_l && fabsf(px - anchor_px) * lw < DEAD_ZONE && fabsf(py - anchor_py) * lh < DEAD_ZONE)
return;
anchored = 0;
Xf xf = screen_xf(f.screen);
Pt p = {(px - 0.5f) * lw, (0.5f - py) * lh, px * 2 - 1, 1 - py * 2, NULL};
if (xf.ok && !xf_plain(&xf, lw, lh)) p.t = &xf;
@@ -394,6 +409,7 @@ void menu_cursor_poll(uint64_t *buttons) {
log_screen(&f, nm, n, lw, lh, p.t, n && stale_hit_panes(n, btn, lw, lh, p.t));
uint64_t at = n ? node_at(n, node, btn, &p, lw, lh) : 0;
if (!at) return;
ptr_node = at;
if (at != f.node) move_focus(&f, at);
if (click_l) {
if (at == f.node) { hold_until = now + 60, hold_bit = 1ull << B_A; *buttons |= hold_bit; }