mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 23:39:57 -04:00
Each player keeps their own game and save. One player makes a room, the others join it with its secret, and story flags and, by the room's rules, items, songs, quest items, small keys (a shared pool), rupees and ammunition reach every save. The layer is a host thread with one UDP socket to a relay the players run themselves (tools/coop_relay.py, Python's standard library only); the messages between the players are sealed with a key from the room's secret (XChaCha20-Poly1305, Monocypher 4.0.2 vendored with its licence and a row in THIRD_PARTY_NOTICES.md), every change is signed by the player who made it, a player accepts a room by its members' keys and the key of its rules, the save is copied to coop-backup before anything is applied, and values are set through the game's own routines between frames. The Co-op tab makes, joins, accepts, removes and leaves, and the menu takes typed text for the name, the relay and the secret. This is the contributor's pull request #518 on this line. Nothing reaches the network while co-op is off: the socket is opened, and the relay's name looked up, only after co-op is on, a relay is set and a room is made or joined. There is no default relay. Left out of the pull request: the other players drawn in the world (the "puppets") with the copied engine they need. They were unfinished, added two patch sites to the game's per-frame update that could not be put through the differential tests here, and their file helpers clashed with the ones this line already has. So no position is sent: the POS message's codec stays, nothing sends it. Changed against the pull request: - The menu's test hook drives the Co-op tab only when it comes from the environment. From nx2navi.ini it could turn co-op on, join a room and accept its offer. - The log's label for a room is hashed from the secret instead of being its first three characters. - A game that has not saved yet has no save to copy, and takes nothing from the room until it has saved once; that used to count as a copy made. - A PING's token no longer carries the PC's uptime. - On Windows the maker's key file and its folder get an access list with the player's account alone. - The tests that link the platform layer get the socket library, and the save test a stand-in for the title screen's hook. Checked on Windows, where the pull request had never been compiled: the runtime builds and links; --probe-coop passes (sockets on 127.0.0.1, the codec against its byte vectors, a fuzz of every parser, two sessions through a hostile mock relay, a relay restart, the sync engine); tests/coop_relay_test.py passes its 61 tests, with the probe through the real relay on 127.0.0.1 at 0 and 30 % loss; tests/coop_page_check.py passes and its deliberate fault fails 48 checks. Not checked: two games in one room (one game runs at a time here), any real network, the tab in the game. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
579 lines
23 KiB
C
579 lines
23 KiB
C
// The SDL3 back end of the window (gfx_wsys.h), for hosts without Win32: the window on a thread of its own that also
|
|
// runs SDL's event loop, F11 fullscreen (borderless, the desktop's mode), the settings NX2NAVI_WINDOW_SIZE,
|
|
// NX2NAVI_FULLSCREEN and NX2NAVI_MONITOR, the display's refresh rate, focus, the Vulkan surface. The swapchain and the
|
|
// present are gfx_present.c's. Keyboard and mouse events go to input_sdl.c and to the menu (ui/menu_sdl.cpp).
|
|
//
|
|
// SDL wants its video calls on the thread that initialised video, so this thread does them all: the others hand it
|
|
// work through run_on_window (a user event and a wait) or post a user event. Video is initialised before the window
|
|
// exists: the Vulkan instance asks for SDL's surface extensions first (gfx_window_vk_extensions), the window comes with
|
|
// gfx_window_start (wsys_open).
|
|
//
|
|
// NX2NAVI_WINDOW_SIZE is in pixels. On a display that scales windows (Wayland, HiDPI) the window asks for its pixels in
|
|
// the display's units (SDL_GetWindowDisplayScale), and SDL reports mouse positions in those units: input_sdl.c and the
|
|
// menu scale them back (gfx_window_sdl_density).
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <SDL3/SDL.h>
|
|
#include <SDL3/SDL_vulkan.h>
|
|
|
|
#include "cfg.h"
|
|
#include "gfx.h"
|
|
#include "gfx_wsys.h"
|
|
#include "input.h"
|
|
#include "input_sdl.h"
|
|
#include "ui/menu.h"
|
|
#include "vk.h"
|
|
#include "platform/platform.h"
|
|
|
|
static SDL_Window *g_win;
|
|
static uint32_t g_ev_base; // SDL_RegisterEvents: the user events below
|
|
enum { EV_RUN, EV_SETTINGS, EV_CLOSE, EV_TEXT_ON, EV_TEXT_OFF, EV_PASTE, EV_COUNT };
|
|
static PlatEvent g_video_ready; // manual-reset: SDL video is up (or failed)
|
|
static int g_video_ok;
|
|
static PlatOnce g_thread_once = PLAT_ONCE_INIT;
|
|
static uint32_t g_window_tid; // the window thread, which runs the video calls
|
|
static volatile int32_t g_density_milli = 1000; // pixels per window unit, x1000
|
|
|
|
// ---- work on the window thread
|
|
typedef struct {
|
|
void (*fn)(void *arg);
|
|
void *arg;
|
|
PlatEvent done;
|
|
} RunReq;
|
|
|
|
static void run_on_window(void (*fn)(void *arg), void *arg) {
|
|
if (plat_thread_id() == g_window_tid) {
|
|
fn(arg);
|
|
return;
|
|
}
|
|
RunReq r = {fn, arg};
|
|
plat_event_init(&r.done, 1, 0);
|
|
SDL_Event e = {.user = {.type = g_ev_base + EV_RUN, .data1 = &r}};
|
|
if (!SDL_PushEvent(&e)) rt_fatal("gfx: cannot reach the window thread (%s)", SDL_GetError());
|
|
plat_event_wait(&r.done);
|
|
}
|
|
|
|
static void post(int ev) {
|
|
SDL_Event e = {.user = {.type = g_ev_base + (uint32_t)ev}};
|
|
SDL_PushEvent(&e);
|
|
}
|
|
|
|
double gfx_window_sdl_density(void) { return __atomic_load_n(&g_density_milli, __ATOMIC_RELAXED) / 1000.0; }
|
|
|
|
SDL_Window *gfx_window_sdl(void) { return g_win; }
|
|
|
|
void gfx_window_sdl_run(void (*fn)(void *arg), void *arg) { run_on_window(fn, arg); }
|
|
|
|
// ---- settings: size and fullscreen
|
|
static char g_applied_size[32];
|
|
static int g_applied_fs;
|
|
|
|
static void note_applied(void) {
|
|
snprintf(g_applied_size, sizeof g_applied_size, "%s", cfg_value("NX2NAVI_WINDOW_SIZE"));
|
|
g_applied_fs = gfx_cfg_fullscreen();
|
|
}
|
|
|
|
static int is_fullscreen(void) { return (SDL_GetWindowFlags(g_win) & SDL_WINDOW_FULLSCREEN) != 0; }
|
|
|
|
// The display scale as a DPI, 96 at 100% (the menu's text size floor); 96 before the window exists.
|
|
unsigned gfx_window_dpi(void) {
|
|
float scale = g_win ? SDL_GetWindowDisplayScale(g_win) : 0;
|
|
return scale > 0 ? (unsigned)(scale * 96 + 0.5f) : 96;
|
|
}
|
|
|
|
// The window's size in its units for w x h pixels.
|
|
static void set_pixel_size(int w, int h) {
|
|
float scale = SDL_GetWindowDisplayScale(g_win);
|
|
if (!(scale > 0)) scale = 1;
|
|
SDL_SetWindowSize(g_win, (int)(w / scale + 0.5f), (int)(h / scale + 0.5f));
|
|
}
|
|
|
|
static void set_fullscreen(int on) {
|
|
input_cursor_suspend(1);
|
|
SDL_SetWindowFullscreen(g_win, on); // the desktop's mode: borderless over the display
|
|
SDL_SyncWindow(g_win);
|
|
input_cursor_suspend(0);
|
|
}
|
|
|
|
// Window thread: the window takes the size and fullscreen state of the settings when they changed. A window resized by
|
|
// hand keeps its size when another setting changes.
|
|
static void apply_settings(void) {
|
|
int size_changed = strcmp(cfg_value("NX2NAVI_WINDOW_SIZE"), g_applied_size) != 0, fs = gfx_cfg_fullscreen();
|
|
int fs_changed = fs != g_applied_fs;
|
|
note_applied();
|
|
if (size_changed) {
|
|
int w, h;
|
|
gfx_cfg_window_size(&w, &h);
|
|
if (is_fullscreen()) SDL_SetWindowFullscreen(g_win, false);
|
|
set_pixel_size(w, h);
|
|
if (is_fullscreen() || (fs && !fs_changed)) SDL_SetWindowFullscreen(g_win, true);
|
|
}
|
|
if (fs_changed && fs != is_fullscreen()) set_fullscreen(fs);
|
|
}
|
|
|
|
void gfx_window_apply_settings(void) {
|
|
if (g_win) post(EV_SETTINGS);
|
|
}
|
|
|
|
void gfx_window_request_close(void) {
|
|
if (g_win) post(EV_CLOSE);
|
|
}
|
|
|
|
// SDL sends SDL_EVENT_TEXT_INPUT between SDL_StartTextInput and SDL_StopTextInput only (and shows an on-screen keyboard
|
|
// there where the system has one, as Steam's on a handheld); the window thread makes the calls.
|
|
void gfx_window_text_input(int on) {
|
|
if (g_win) post(on ? EV_TEXT_ON : EV_TEXT_OFF);
|
|
}
|
|
|
|
// SDL's clipboard belongs to the window thread: the text is read there and handed to the menu.
|
|
void gfx_window_paste(void) {
|
|
if (g_win) post(EV_PASTE);
|
|
}
|
|
|
|
// ---- the display's refresh rate
|
|
static void refresh_rate_update(void) {
|
|
const SDL_DisplayMode *m = SDL_GetCurrentDisplayMode(SDL_GetDisplayForWindow(g_win));
|
|
double hz = 0;
|
|
if (m && m->refresh_rate_denominator) hz = (double)m->refresh_rate_numerator / m->refresh_rate_denominator;
|
|
else if (m) hz = m->refresh_rate;
|
|
gfx_window_set_refresh(hz);
|
|
}
|
|
|
|
static void density_update(void) {
|
|
float d = SDL_GetWindowPixelDensity(g_win);
|
|
__atomic_store_n(&g_density_milli, (int32_t)((d > 0 ? d : 1) * 1000 + 0.5f), __ATOMIC_RELAXED);
|
|
}
|
|
|
|
// ---- the window thread
|
|
// NX2NAVI_MONITOR's display while a Wayland compositor has yet to place the fullscreen window (open_window): SDL learns
|
|
// the output a Wayland window is on later, with a display, scale or mode change (Hyprland sends only the latter two).
|
|
static SDL_DisplayID g_place_pending;
|
|
|
|
static void report_placement(SDL_DisplayID want) {
|
|
SDL_DisplayID at = SDL_GetDisplayForWindow(g_win);
|
|
const char *name = SDL_GetDisplayName(at);
|
|
if (at == want) rt_log("gfx: the window is on the chosen monitor \"%s\"", name ? name : "an unknown monitor");
|
|
else rt_log("gfx: the window is not on the chosen monitor; it is on \"%s\"", name ? name : "an unknown monitor");
|
|
}
|
|
|
|
static void handle(const SDL_Event *e) {
|
|
if (e->type == g_ev_base + EV_RUN) {
|
|
RunReq *r = e->user.data1;
|
|
r->fn(r->arg);
|
|
plat_event_set(&r->done);
|
|
return;
|
|
}
|
|
if (e->type == g_ev_base + EV_SETTINGS) {
|
|
if (g_win) apply_settings();
|
|
return;
|
|
}
|
|
if (e->type == g_ev_base + EV_TEXT_ON || e->type == g_ev_base + EV_TEXT_OFF) {
|
|
if (g_win && e->type == g_ev_base + EV_TEXT_ON) SDL_StartTextInput(g_win);
|
|
else if (g_win) SDL_StopTextInput(g_win);
|
|
return;
|
|
}
|
|
if (e->type == g_ev_base + EV_PASTE) {
|
|
char text[256];
|
|
plat_clipboard_get(text, sizeof text);
|
|
menu_event_paste(text);
|
|
return;
|
|
}
|
|
if (e->type == g_ev_base + EV_CLOSE) gfx_window_closed();
|
|
if (!g_win) return;
|
|
input_sdl_event(e);
|
|
menu_sdl_event(e);
|
|
switch (e->type) {
|
|
case SDL_EVENT_KEY_DOWN:
|
|
if (e->key.scancode == SDL_SCANCODE_F11 && !e->key.repeat) {
|
|
set_fullscreen(!is_fullscreen());
|
|
cfg_set("NX2NAVI_FULLSCREEN", is_fullscreen() ? "1" : "0"); // the menu shows it; the next start keeps it
|
|
cfg_save();
|
|
note_applied();
|
|
}
|
|
break;
|
|
case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
|
|
case SDL_EVENT_WINDOW_RESIZED:
|
|
case SDL_EVENT_WINDOW_RESTORED:
|
|
density_update();
|
|
gfx_window_mark_dirty();
|
|
break;
|
|
case SDL_EVENT_WINDOW_DISPLAY_CHANGED:
|
|
case SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED:
|
|
case SDL_EVENT_DISPLAY_CURRENT_MODE_CHANGED:
|
|
density_update();
|
|
refresh_rate_update();
|
|
gfx_window_mark_dirty();
|
|
if (g_place_pending && SDL_GetDisplayForWindow(g_win) == g_place_pending) {
|
|
report_placement(g_place_pending);
|
|
g_place_pending = 0;
|
|
}
|
|
break;
|
|
case SDL_EVENT_WINDOW_FOCUS_GAINED:
|
|
case SDL_EVENT_WINDOW_FOCUS_LOST:
|
|
gfx_window_focus_changed(e->type == SDL_EVENT_WINDOW_FOCUS_GAINED);
|
|
break;
|
|
case SDL_EVENT_QUIT:
|
|
case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
|
|
gfx_window_closed();
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void window_main(void *arg) {
|
|
(void)arg;
|
|
g_window_tid = plat_thread_id();
|
|
SDL_SetHint(SDL_HINT_APP_ID, "nx2navi"); // Wayland's app id: the desktop file and the taskbar match it
|
|
SDL_SetHint(SDL_HINT_VIDEO_ALLOW_SCREENSAVER, "0");
|
|
g_video_ok = SDL_Init(SDL_INIT_VIDEO);
|
|
if (!g_video_ok) rt_log("gfx: SDL video init failed (%s)", SDL_GetError());
|
|
// SDL's Vulkan queries need its Vulkan loader, which a window would load at creation: the instance and the device
|
|
// are made before the window.
|
|
else if (!SDL_Vulkan_LoadLibrary(NULL)) {
|
|
rt_log("gfx: SDL cannot load Vulkan (%s)", SDL_GetError());
|
|
g_video_ok = 0;
|
|
} else {
|
|
g_ev_base = SDL_RegisterEvents(EV_COUNT);
|
|
rt_log("gfx: SDL %d.%d.%d, video driver %s", SDL_VERSIONNUM_MAJOR(SDL_GetVersion()),
|
|
SDL_VERSIONNUM_MINOR(SDL_GetVersion()), SDL_VERSIONNUM_MICRO(SDL_GetVersion()), SDL_GetCurrentVideoDriver());
|
|
}
|
|
plat_event_set(&g_video_ready);
|
|
if (!g_video_ok) return;
|
|
for (;;) {
|
|
SDL_Event e;
|
|
if (SDL_WaitEventTimeout(&e, 100)) handle(&e);
|
|
else input_sdl_idle(); // a cursor change requested from another thread meanwhile
|
|
}
|
|
}
|
|
|
|
static void video_start(void *arg) {
|
|
(void)arg;
|
|
plat_event_init(&g_video_ready, 1, 0);
|
|
if (!plat_thread_spawn(window_main, NULL, "window", 0)) rt_fatal("gfx: cannot start the window thread");
|
|
plat_event_wait(&g_video_ready);
|
|
}
|
|
|
|
static int video_up(void) {
|
|
plat_once(&g_thread_once, video_start, NULL);
|
|
return g_video_ok;
|
|
}
|
|
|
|
int gfx_window_vk_extensions(const char **out, int max) {
|
|
if (!video_up()) return 0;
|
|
Uint32 n = 0;
|
|
const char *const *ext = SDL_Vulkan_GetInstanceExtensions(&n);
|
|
if (!ext) {
|
|
rt_log("gfx: SDL_Vulkan_GetInstanceExtensions failed (%s)", SDL_GetError());
|
|
return 0;
|
|
}
|
|
int k = 0;
|
|
for (Uint32 i = 0; i < n && k < max; i++) out[k++] = ext[i];
|
|
return k;
|
|
}
|
|
|
|
int gfx_window_vk_presentable(VkInstance inst, VkPhysicalDevice pd, uint32_t family) {
|
|
return video_up() && SDL_Vulkan_GetPresentationSupport(inst, pd, family);
|
|
}
|
|
|
|
// ---- monitor choice (NX2NAVI_MONITOR, --monitor, --list-monitors)
|
|
// The monitors in SDL_GetDisplays order, which is the index the setting counts in (1-based) and --list-monitors prints.
|
|
// The video driver sets that order, which need not match the desktop's own list of monitors: it holds while the same
|
|
// monitors stay connected, but a monitor that appears or goes away can move the ones after it. SDL has one name per
|
|
// monitor: make and model, with the connector (such as DP-2) on Wayland and X11. The name pins one monitor more firmly
|
|
// than its index. These calls belong to the thread that initialised video: the window thread, or the main thread in
|
|
// --list-monitors.
|
|
#define MON_MAX 32
|
|
|
|
typedef struct {
|
|
SDL_DisplayID id;
|
|
SDL_Rect rc; // the monitor's pixels, at its position in the desktop's coordinates
|
|
int primary;
|
|
unsigned dpi; // the display scale as a DPI, 96 at 100%
|
|
char name[128]; // SDL_GetDisplayName; empty when SDL has none
|
|
} MonInfo;
|
|
|
|
typedef struct { MonInfo m[MON_MAX]; int n; } MonList;
|
|
|
|
static int enum_monitors(MonList *l) {
|
|
*l = (MonList){0};
|
|
int n = 0;
|
|
SDL_DisplayID *ids = SDL_GetDisplays(&n);
|
|
if (!ids) return 0;
|
|
SDL_DisplayID primary = SDL_GetPrimaryDisplay();
|
|
for (int i = 0; i < n && l->n < MON_MAX; i++) {
|
|
SDL_Rect rc;
|
|
if (!SDL_GetDisplayBounds(ids[i], &rc)) continue;
|
|
// A scaled desktop (Wayland at 125%) counts its coordinates in scaled units: the pixel density turns the size
|
|
// back into the monitor's pixels, and the content scale and the density together are the display scale
|
|
// (SDL_GetWindowDisplayScale gives a window the same product). The position stays in the desktop's units.
|
|
const SDL_DisplayMode *mode = SDL_GetCurrentDisplayMode(ids[i]);
|
|
float density = mode && mode->pixel_density > 0 ? mode->pixel_density : 1, scale = SDL_GetDisplayContentScale(ids[i]);
|
|
if (!(scale > 0)) scale = 1;
|
|
const char *name = SDL_GetDisplayName(ids[i]);
|
|
MonInfo *m = &l->m[l->n++];
|
|
*m = (MonInfo){.id = ids[i], .rc = {rc.x, rc.y, (int)(rc.w * density + 0.5f), (int)(rc.h * density + 0.5f)},
|
|
.primary = ids[i] == primary, .dpi = (unsigned)(96 * scale * density + 0.5f)};
|
|
snprintf(m->name, sizeof m->name, "%s", name ? name : "");
|
|
}
|
|
SDL_free(ids);
|
|
return l->n;
|
|
}
|
|
|
|
// `2 "HP Inc. HP E243 CNK0161ZY2 (DP-3)" 1920x1080 at 3456,756 dpi 120 (125%)`: one monitor, for the log and
|
|
// --list-monitors, with " primary" after the rectangle on the primary one.
|
|
static void monitor_line(const MonList *l, int i, char *out, size_t cap) {
|
|
const MonInfo *m = &l->m[i];
|
|
snprintf(out, cap, "%d \"%s\" %dx%d at %d,%d%s dpi %u (%u%%)", i + 1, m->name, m->rc.w, m->rc.h, m->rc.x, m->rc.y,
|
|
m->primary ? " primary" : "", m->dpi, m->dpi * 100 / 96);
|
|
}
|
|
|
|
static int monitor_unset(const char *v) { return !v || !*v || !SDL_strcasecmp(v, "auto"); }
|
|
|
|
// Which monitor of the list a NX2NAVI_MONITOR value (not empty, not auto) names, as a 0-based index; -1 when none.
|
|
// Rules, in this order: "primary"; all digits, a 1-based index; any other text, a case-insensitive substring of a
|
|
// monitor's name (the first monitor in list order when several match). why gets the rule that matched, or the reason
|
|
// nothing did. The same rules as gfx_window_win.c resolve_monitor, which also matches the GDI device name.
|
|
static int resolve_monitor(const MonList *l, const char *want, char *why, size_t cap) {
|
|
if (!SDL_strcasecmp(want, "primary")) {
|
|
for (int i = 0; i < l->n; i++)
|
|
if (l->m[i].primary) {
|
|
snprintf(why, cap, "the primary monitor");
|
|
return i;
|
|
}
|
|
snprintf(why, cap, "no monitor is marked primary");
|
|
return -1;
|
|
}
|
|
if (want[strspn(want, "0123456789")] == 0) {
|
|
long idx = strtol(want, NULL, 10);
|
|
if (idx >= 1 && idx <= l->n) {
|
|
snprintf(why, cap, "index %ld of %d", idx, l->n);
|
|
return (int)idx - 1;
|
|
}
|
|
snprintf(why, cap, "index %s is outside 1..%d", want, l->n);
|
|
return -1;
|
|
}
|
|
int first = -1, hits = 0;
|
|
for (int i = 0; i < l->n; i++)
|
|
if (SDL_strcasestr(l->m[i].name, want)) {
|
|
if (first < 0) first = i;
|
|
hits++;
|
|
}
|
|
if (first < 0) {
|
|
snprintf(why, cap, "no monitor name contains it");
|
|
return -1;
|
|
}
|
|
if (hits > 1) snprintf(why, cap, "monitor name contains it; the first of %d matches", hits);
|
|
else snprintf(why, cap, "monitor name contains it");
|
|
return first;
|
|
}
|
|
|
|
// The monitor NX2NAVI_MONITOR picks, copied to *out; 0 when it is unset or auto (the system places the window), or when
|
|
// it matches nothing now (the monitors present are logged, and the default placement applies). log: say what was decided
|
|
// and why. The window thread asks with log set; the size query below, which widescreen.c makes before the window
|
|
// exists, stays quiet. Window thread.
|
|
static int chosen_monitor(MonInfo *out, int log) {
|
|
const char *want = cfg_get("NX2NAVI_MONITOR");
|
|
if (monitor_unset(want)) return 0;
|
|
MonList l;
|
|
char why[256], line[512];
|
|
int n = enum_monitors(&l), pick = -1;
|
|
if (n) pick = resolve_monitor(&l, want, why, sizeof why);
|
|
else snprintf(why, sizeof why, "no monitor was found");
|
|
if (pick < 0) {
|
|
if (log) {
|
|
rt_log("gfx: NX2NAVI_MONITOR=%s picks no monitor (%s); the window gets the default placement. Monitors present:",
|
|
want, why);
|
|
for (int i = 0; i < n; i++) {
|
|
monitor_line(&l, i, line, sizeof line);
|
|
rt_log("gfx: %s", line);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
if (log) {
|
|
monitor_line(&l, pick, line, sizeof line);
|
|
rt_log("gfx: NX2NAVI_MONITOR=%s picks monitor %s (%s)", want, line, why);
|
|
}
|
|
*out = l.m[pick];
|
|
return 1;
|
|
}
|
|
|
|
// --list-monitors (main.c): one line per monitor, then what the current NX2NAVI_MONITOR would pick. No game files. It
|
|
// runs on the main thread before any window thread exists, so that thread initialises video here and shuts it down again.
|
|
int list_monitors(void) {
|
|
if (!SDL_Init(SDL_INIT_VIDEO)) {
|
|
fprintf(stderr, "list-monitors: SDL video init failed (%s)\n", SDL_GetError());
|
|
return 1;
|
|
}
|
|
MonList l;
|
|
char line[512], why[256];
|
|
int n = enum_monitors(&l);
|
|
if (!n) {
|
|
fprintf(stderr, "list-monitors: no monitor found\n");
|
|
SDL_Quit();
|
|
return 1;
|
|
}
|
|
printf("index name desktop rectangle primary dpi\n");
|
|
for (int i = 0; i < n; i++) {
|
|
monitor_line(&l, i, line, sizeof line);
|
|
printf("%s\n", line);
|
|
}
|
|
const char *want = cfg_get("NX2NAVI_MONITOR");
|
|
if (monitor_unset(want)) {
|
|
printf("NX2NAVI_MONITOR is not set (auto): the system places the window\n");
|
|
} else {
|
|
int pick = resolve_monitor(&l, want, why, sizeof why);
|
|
if (pick >= 0) printf("NX2NAVI_MONITOR=%s picks monitor %d (%s)\n", want, pick + 1, why);
|
|
else printf("NX2NAVI_MONITOR=%s picks no monitor (%s)\n", want, why);
|
|
}
|
|
SDL_Quit();
|
|
return 0;
|
|
}
|
|
|
|
typedef struct { int w, h, ok; } SizeReq;
|
|
|
|
static void chosen_size(void *arg) {
|
|
SizeReq *r = arg;
|
|
MonInfo mon;
|
|
if (chosen_monitor(&mon, 0)) r->w = mon.rc.w, r->h = mon.rc.h, r->ok = 1;
|
|
}
|
|
|
|
// Pixels of the monitor the window is on; 0 when unknown. Before the window exists (widescreen.c wide_init at start) a
|
|
// fullscreen window opens on the monitor NX2NAVI_MONITOR picks, so that one's size; without a choice the system decides
|
|
// where the window goes, which is not known yet.
|
|
int gfx_window_monitor_size(int *w, int *h) {
|
|
if (g_win) {
|
|
const SDL_DisplayMode *m = SDL_GetCurrentDisplayMode(SDL_GetDisplayForWindow(g_win));
|
|
if (!m) return 0;
|
|
*w = (int)(m->w * m->pixel_density + 0.5f);
|
|
*h = (int)(m->h * m->pixel_density + 0.5f);
|
|
return 1;
|
|
}
|
|
SizeReq r = {0};
|
|
if (monitor_unset(cfg_get("NX2NAVI_MONITOR")) || !video_up()) return 0;
|
|
run_on_window(chosen_size, &r);
|
|
*w = r.w, *h = r.h;
|
|
return r.ok;
|
|
}
|
|
|
|
// ---- gfx_wsys.h
|
|
static int open_ok;
|
|
|
|
static void open_window(void *arg) {
|
|
(void)arg;
|
|
int w, h;
|
|
gfx_cfg_window_size(&w, &h);
|
|
// NX2NAVI_MONITOR: the window is created centred on the chosen monitor; without a choice the system places it.
|
|
MonInfo mon;
|
|
int on_mon = chosen_monitor(&mon, 1);
|
|
SDL_PropertiesID props = SDL_CreateProperties();
|
|
SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING, "NX2navi");
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, w);
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, h);
|
|
SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_VULKAN_BOOLEAN, true);
|
|
SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN, true);
|
|
SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN, true);
|
|
if (on_mon) {
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, SDL_WINDOWPOS_CENTERED_DISPLAY(mon.id));
|
|
SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, SDL_WINDOWPOS_CENTERED_DISPLAY(mon.id));
|
|
}
|
|
g_win = SDL_CreateWindowWithProperties(props);
|
|
SDL_DestroyProperties(props);
|
|
if (!g_win) {
|
|
rt_log("gfx: SDL_CreateWindow failed (%s)", SDL_GetError());
|
|
return;
|
|
}
|
|
set_pixel_size(w, h); // w x h were window units; the setting is in pixels
|
|
// Centred again at the size it ended up with. SDL also takes this position as the display the fullscreen below
|
|
// covers: a Wayland window cannot be moved, and this is how its fullscreen still opens on the chosen output.
|
|
if (on_mon) SDL_SetWindowPosition(g_win, SDL_WINDOWPOS_CENTERED_DISPLAY(mon.id), SDL_WINDOWPOS_CENTERED_DISPLAY(mon.id));
|
|
density_update();
|
|
note_applied();
|
|
refresh_rate_update();
|
|
if (cfg_get("NX2NAVI_BACKGROUND_WINDOW")) rt_log("gfx: NX2NAVI_BACKGROUND_WINDOW has no effect with SDL windows");
|
|
int wayland = !SDL_strcmp(SDL_GetCurrentVideoDriver(), "wayland");
|
|
// open_window runs once, so this is logged once
|
|
if (on_mon && wayland)
|
|
rt_log("gfx: Wayland leaves the placement of a windowed window to the compositor, so NX2NAVI_MONITOR only decides "
|
|
"where the game opens in fullscreen");
|
|
if (gfx_cfg_fullscreen()) SDL_SetWindowFullscreen(g_win, true);
|
|
SDL_SyncWindow(g_win);
|
|
// A Wayland compositor places the fullscreen window after SDL_SyncWindow returns; handle reports it once the window
|
|
// is on the chosen monitor.
|
|
if (on_mon && (gfx_cfg_fullscreen() || !wayland)) {
|
|
if (wayland && SDL_GetDisplayForWindow(g_win) != mon.id) g_place_pending = mon.id;
|
|
else report_placement(mon.id);
|
|
}
|
|
input_sdl_window(g_win);
|
|
open_ok = 1;
|
|
}
|
|
|
|
int wsys_open(void) {
|
|
if (!video_up()) return 0;
|
|
if (!g_win) run_on_window(open_window, NULL);
|
|
return open_ok;
|
|
}
|
|
|
|
typedef struct { VkInstance inst; VkSurfaceKHR surface; } SurfaceReq;
|
|
|
|
static void make_surface(void *arg) {
|
|
SurfaceReq *r = arg;
|
|
if (!SDL_Vulkan_CreateSurface(g_win, r->inst, NULL, &r->surface)) {
|
|
rt_log("gfx: SDL_Vulkan_CreateSurface failed (%s)", SDL_GetError());
|
|
r->surface = VK_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
VkSurfaceKHR wsys_surface(VkInstance inst) {
|
|
SurfaceReq r = {inst, VK_NULL_HANDLE};
|
|
run_on_window(make_surface, &r);
|
|
return r.surface;
|
|
}
|
|
|
|
void wsys_client_size(int *w, int *h) {
|
|
*w = *h = 0;
|
|
if (g_win) SDL_GetWindowSizeInPixels(g_win, w, h);
|
|
}
|
|
|
|
int wsys_minimized(void) { return g_win && (SDL_GetWindowFlags(g_win) & (SDL_WINDOW_MINIMIZED | SDL_WINDOW_HIDDEN)); }
|
|
|
|
static void resize_window(void *arg) {
|
|
const int *wh = arg;
|
|
set_pixel_size(wh[0], wh[1]);
|
|
SDL_SyncWindow(g_win);
|
|
}
|
|
|
|
void wsys_resize(int w, int h) {
|
|
int wh[2] = {w, h};
|
|
run_on_window(resize_window, wh);
|
|
}
|
|
|
|
// ---- --probe-window: synthetic events through the event handler, on the window thread
|
|
static void probe_event(void *arg) { handle(arg); }
|
|
|
|
void wsys_probe_focus(int in) {
|
|
SDL_Event e = {.window = {.type = in ? SDL_EVENT_WINDOW_FOCUS_GAINED : SDL_EVENT_WINDOW_FOCUS_LOST,
|
|
.windowID = SDL_GetWindowID(g_win)}};
|
|
run_on_window(probe_event, &e);
|
|
}
|
|
|
|
void wsys_probe_escape(void) {
|
|
SDL_Event e = {.key = {.type = SDL_EVENT_KEY_DOWN, .scancode = SDL_SCANCODE_ESCAPE, .key = SDLK_ESCAPE, .down = true,
|
|
.windowID = SDL_GetWindowID(g_win)}};
|
|
run_on_window(probe_event, &e);
|
|
e.key.type = SDL_EVENT_KEY_UP, e.key.down = false;
|
|
run_on_window(probe_event, &e);
|
|
}
|
|
|
|
// SDL reports no activation by a title bar click: only the client click exists.
|
|
int wsys_probe_click(int where) {
|
|
if (where == 2) return 0;
|
|
SDL_Event e = {.button = {.type = SDL_EVENT_MOUSE_BUTTON_DOWN, .button = SDL_BUTTON_LEFT, .down = true,
|
|
.windowID = SDL_GetWindowID(g_win)}};
|
|
run_on_window(probe_event, &e);
|
|
e.button.type = SDL_EVENT_MOUSE_BUTTON_UP, e.button.down = false;
|
|
run_on_window(probe_event, &e);
|
|
return 1;
|
|
}
|