From 2f78585b4c7724a32b141aa82dcd4dd7eeb4edb8 Mon Sep 17 00:00:00 2001 From: Wellington Dias Date: Thu, 29 Oct 2026 18:14:30 -0300 Subject: [PATCH] Add a Steam Deck profile and keep the picture's proportions on screens of another shape. The present fits the game's picture into the largest centred rectangle of its own aspect ratio and clears the rest to black (gfx_fit_rect, through both the blit and FSR), so a 16:9 game on the Deck's 16:10 screen is no longer stretched; picture_fit = stretch keeps the old fill. probe-window checks the bars as well as the picture. device_profile = auto|desktop|deck: on a Steam Deck (the firmware's Valve Jupiter or Galileo board, or SteamDeck=1) the keys totk.ini does not set default to fullscreen, a 1280x800 window, a 1280x720 game resolution, the game's own scene scale, vsync and a 40 fps limit; the environment and totk.ini still win. These are starting points until measured on the device (docs/tester-guide.md, Steam Deck). Both stick clicks (L3 + R3) step the performance overlay as F10 does, for a controller with no keyboard. The menu offers 1280x720 and 1600x900 game resolutions and 40, 45 and 90 fps limits. --- docs/controls.md | 2 +- docs/tester-guide.md | 20 ++++++++++ runtime/cfg.c | 81 +++++++++++++++++++++++++++++++++++--- runtime/cfg.h | 6 ++- runtime/gfx_present.c | 32 +++++++++++++-- runtime/gfx_window_probe.c | 13 ++++-- runtime/input.c | 3 ++ runtime/input.h | 1 + runtime/input_map.c | 14 ++++++- runtime/ui/menu.cpp | 11 ++++-- runtime/ui_text.c | 15 ++++++- runtime/ui_text.h | 4 +- runtime/vk.h | 11 ++++-- runtime/vk_fsr.c | 4 +- totk.ini.example | 18 ++++++--- 15 files changed, 200 insertions(+), 35 deletions(-) diff --git a/docs/controls.md b/docs/controls.md index 00f5a5d1..fde705eb 100644 --- a/docs/controls.md +++ b/docs/controls.md @@ -35,7 +35,7 @@ Esc is unbound in the game; it opens the settings menu and releases the mouse cu | Key | Gamepad | Action | |---|---|---| | F1 or Esc | Minus and Plus together | open or close the settings menu; the game gets no input while it is open | -| F10 | | performance overlay: off, frame rate, full panel | +| F10 | L3 + R3 (both stick clicks) | performance overlay: off, frame rate, full panel | | F11 | | borderless fullscreen on or off, saved to `totk.ini` | The Minus+Plus combo never reaches the game. In the menu the arrow keys, the D-pad or the left stick move, Enter or A selects, Q and E or L and R switch tabs, Esc or B goes back (Switch button names, as in the table above). diff --git a/docs/tester-guide.md b/docs/tester-guide.md index 4c9dcad4..5d86f628 100644 --- a/docs/tester-guide.md +++ b/docs/tester-guide.md @@ -63,6 +63,26 @@ The line `vk: using gpu N: ` says which one ran. 5. For a bug you can trigger again: a recording of your input (`set TOTK_INPUT_RECORD=input.txt`, see [controls.md](controls.md), "Scripted input") and the save you started from. +## Steam Deck + +Build or install on Linux ([installer.md](installer.md), "Linux release"), in Desktop Mode. The game then runs in either +mode; for Game Mode, add `totk` from the install folder to Steam as a non-Steam game. + +The game recognises the Deck (LCD and OLED) and uses its device profile for every setting `totk.ini` does not set: +fullscreen, game resolution 1280x720 letterboxed in the 1280x800 screen, the game's own 3D scale, vsync and a 40 fps +limit. These are starting points, not measurements. What helps most: + +1. The performance overlay (F10, or both stick clicks L3 + R3) in full mode: the frame rate, mean and longest frame + time over a minute in Lookout Landing, in the Depths and in the Sky, with the settings named. +2. The same with `fps_limit` 30, 45 and 60 and `render_scale` 50, 67 and game, so the defaults can be picked from + measurements. Steam's own performance overlay (the ... button) adds power draw and temperatures. +3. LCD or OLED, SteamOS version (`uname -r` in Desktop Mode's terminal), and the game update. +4. Anything that looks stretched or cut off: the game draws 16:9 only, so the profile keeps black bars above and + below; `picture_fit = stretch` fills the screen instead. + +`device_profile = desktop` in `totk.ini` turns the profile off; `deck` turns it on elsewhere, to try the Deck's +settings on a PC. + ## Switches for the developer's questions Only set these when asked; each forces a fallback the build picks by itself on GPUs that need it. diff --git a/runtime/cfg.c b/runtime/cfg.c index e52a7fb9..001e4d33 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -35,13 +35,13 @@ static const char *const known[] = { "BIND_LSTICK_RIGHT", "BIND_LSTICK_UP", "BIND_MINUS", "BIND_PLUS", "BIND_R", "BIND_RCLICK", "BIND_RIGHT", "BIND_RSTICK_DOWN", "BIND_RSTICK_LEFT", "BIND_RSTICK_RIGHT", "BIND_RSTICK_UP", "BIND_SKIP", "BIND_STATS", "BIND_UP", "BIND_X", "BIND_Y", - "BIND_ZL", "BIND_ZR", "CLOTH_REALTIME", "CORE_DIAG", "CRIT", "CRIT_OUT", "DESC_TEMPLATE", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", + "BIND_ZL", "BIND_ZR", "CLOTH_REALTIME", "CORE_DIAG", "CRIT", "CRIT_OUT", "DESC_TEMPLATE", "DEVICE_PROFILE", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", "EXEFS", "FEEDBACK", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES", "FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FPS60", "FPS_LIMIT", "FREEZE_IDLE", "FREE_CORES", "FULLSCREEN", "GPL", "GPL_DRAW_BUILD", "GPU", "GPU_INDEX", "GPU_NAME", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "LANG", "LIB_PREBUILD", "LIB_PREBUILD_KEEP", "LIB_PREBUILD_THREADS", "LOCALE", "LOD_GUARD", "MEMORY", "MENU_LANG", "MENU_TEST", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MOTION", "MOUSE_SENS", "MOVIE_HOST", "MOVIE_PACE", - "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PATCH_OUTPUT", "PATCH_SCENE", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", + "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PATCH_OUTPUT", "PATCH_SCENE", "PERF_OVERLAY", "PERF_SLOW_MS", "PICTURE_FIT", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", "PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES", "PROFILE_MAIN", "PROFILE_RENDER", "PUSH_SKIP", "PUSH_STAGE", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REEXEC", "RENDER_SCALE", "REPLAY_ASYNC", @@ -59,7 +59,8 @@ static const struct { const char *key, *section; } sections[] = { {"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"}, {"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"}, {"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"}, - {"SHARPNESS", "display"}, + {"SHARPNESS", "display"}, {"PICTURE_FIT", "display"}, + {"DEVICE_PROFILE", "display"}, {"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"}, {"VOLUME", "audio"}, {"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"}, @@ -93,8 +94,10 @@ static const CfgMeta metas[] = { {"PERF_OVERLAY", "off", "off|fps|full", LIVE}, {"OUTPUT_RES", "1920x1080", NULL, RESTART}, {"RENDER_SCALE", "game", "game|50|67|75|100|125|150|200", RESTART}, {"UPSCALER", "fsr", "fsr|bilinear", LIVE}, {"SHARPNESS", "80", "0..100", LIVE}, + {"PICTURE_FIT", "keep", "keep|stretch", LIVE}, + {"DEVICE_PROFILE", "auto", "auto|desktop|deck", RESTART}, // Game - {"FPS_LIMIT", "60", "30|60|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, + {"FPS_LIMIT", "60", "30|40|45|60|90|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"REALTIME", "1", "0|1", RESTART}, {"CLOTH_REALTIME", "1", "0|1", RESTART}, {"HIGHFPS_FIX", "1", "0|1", RESTART}, {"LANG", "", "ja|en-US|fr|de|it|es|zh-CN|ko|nl|pt|ru|zh-TW|en-GB|fr-CA|es-419|zh-Hans|zh-Hant|pt-BR", RESTART}, @@ -196,7 +199,55 @@ int cfg_load(const char *path) { return 1; } -const char *cfg_get(const char *name) { +// ---- device profiles: defaults for a known machine, below the environment and totk.ini and above the table, so any +// key the player sets wins and resetting a key in the menu returns to the profile's value. TOTK_DEVICE_PROFILE = auto +// (default: the Steam Deck when the firmware says so), desktop (none) or deck. +// +// The Steam Deck (LCD Jupiter, OLED Galileo; 1280x800, 16:10, 4 Zen 2 cores, RDNA 2 with 8 CUs sharing 16 GB): the game +// at 1280x720 with its own 5/6 scene, letterboxed in the 16:10 screen (TOTK_PICTURE_FIT) until the game draws 16:10 +// itself; fullscreen and vsync, as gamescope composes Game Mode; 40 fps, which divides 40 Hz (and 120 Hz on the OLED). +// Starting points to replace with measured ones (docs/tester-guide.md, Steam Deck). +static const struct { const char *key, *value; } DECK[] = { + {"FULLSCREEN", "1"}, {"WINDOW_SIZE", "1280x800"}, {"OUTPUT_RES", "1280x720"}, {"RENDER_SCALE", "game"}, + {"VK_PRESENT", "fifo"}, {"FPS_LIMIT", "40"}, +}; +static int profile = -1; // 0 none, 1 Steam Deck + +static int read_line(const char *path, char *out, size_t n) { + FILE *f = fopen(path, "r"); + if (!f) return 0; + int ok = fgets(out, (int)n, f) != NULL; + fclose(f); + out[ok ? strcspn(out, "\r\n") : 0] = 0; + return ok; +} + +// The Steam Deck: Valve's board, product Jupiter or Galileo (/sys/class/dmi/id); SteamDeck=1, which Steam sets on it. +static int on_steam_deck(void) { + const char *env = getenv("SteamDeck"); + if (env && !strcmp(env, "1")) return 1; + char vendor[64], product[64]; + return read_line("/sys/class/dmi/id/board_vendor", vendor, sizeof vendor) && !strcmp(vendor, "Valve") && + read_line("/sys/class/dmi/id/product_name", product, sizeof product) && + (!strcmp(product, "Jupiter") || !strcmp(product, "Galileo")); +} + +static const char *raw_get(const char *name); + +static int profile_of(void) { + int p = __atomic_load_n(&profile, __ATOMIC_ACQUIRE); + if (p >= 0) return p; + const char *set = raw_get(PREFIX "DEVICE_PROFILE"); + if (set && !strcmp(set, "deck")) p = 1; + else if (set && *set && strcmp(set, "auto")) p = 0; + else p = on_steam_deck(); + __atomic_store_n(&profile, p, __ATOMIC_RELEASE); + return p; +} + +const char *cfg_device_profile(void) { return profile_of() ? "deck" : "desktop"; } + +static const char *raw_get(const char *name) { const char *e = getenv(name); if (e || strncmp(name, PREFIX, PREFIX_LEN)) return e; int n = __atomic_load_n(&n_entries, __ATOMIC_ACQUIRE); @@ -205,6 +256,17 @@ const char *cfg_get(const char *name) { return NULL; } +const char *cfg_get(const char *name) { + const char *v = raw_get(name); + if (v || strncmp(name, PREFIX, PREFIX_LEN) || !profile_of()) return v; + for (size_t i = 0; i < sizeof DECK / sizeof *DECK; i++) + if (!strcasecmp(DECK[i].key, name + PREFIX_LEN)) return DECK[i].value; + return NULL; +} + +// Whether name's value comes from the player (the environment or totk.ini), not a profile or the table. +int cfg_is_set(const char *name) { return raw_get(name) != NULL; } + unsigned cfg_version(void) { return __atomic_load_n(&version, __ATOMIC_ACQUIRE); } int cfg_from_env(const char *name) { return getenv(name) != NULL; } @@ -554,7 +616,7 @@ int cfg_save(void) { return 0; } -void cfg_init(void) { +static void load_ini(void) { if (!find_ini()) return; if (!cfg_load(ini_path)) { rt_log("cfg: no settings file at %s", ini_path); @@ -567,3 +629,10 @@ void cfg_init(void) { if (getenv(var)) rt_log("cfg: %s is set in the environment and overrides totk.ini", var); } } + +void cfg_init(void) { + load_ini(); + if (profile_of()) + rt_log("cfg: device profile Steam Deck: defaults for the keys totk.ini does not set (TOTK_DEVICE_PROFILE=desktop " + "turns it off)"); +} diff --git a/runtime/cfg.h b/runtime/cfg.h index c0c5dd55..5f94bc7a 100644 --- a/runtime/cfg.h +++ b/runtime/cfg.h @@ -2,7 +2,7 @@ #pragma once // getenv for a setting: the environment variable when set, else the totk.ini key (the name without "TOTK_", any -// case), else NULL. Same string semantics as getenv; the pointer stays valid for the process (a value cfg_set replaces +// case), else the device profile's default (cfg.c: the Steam Deck), else NULL. Same string semantics as getenv; the pointer stays valid for the process (a value cfg_set replaces // is kept). A name without the TOTK_ prefix goes to getenv unchanged. Safe from any thread once cfg_init has returned. const char *cfg_get(const char *name); @@ -21,6 +21,10 @@ void cfg_set(const char *name, const char *value); unsigned cfg_version(void); // 1 when the environment sets name: cfg_set cannot change what cfg_get returns (the menu greys the setting out). int cfg_from_env(const char *name); +// 1 when the player set name (the environment or totk.ini), 0 when cfg_get gives a device profile's default or NULL. +int cfg_is_set(const char *name); +// The device profile in use, "deck" or "desktop" (TOTK_DEVICE_PROFILE, else what the machine is). +const char *cfg_device_profile(void); // Writes the keys cfg_set changed since the last save into totk.ini next to totk.exe (cfg_save_to: the file at path). // Only those lines change: the last line of a changed key gets the new value, a missing key goes under its section // (after the commented example line of the key when the section has one; the section is added at the end of the file diff --git a/runtime/gfx_present.c b/runtime/gfx_present.c index 969f1330..67a7059c 100644 --- a/runtime/gfx_present.c +++ b/runtime/gfx_present.c @@ -510,6 +510,20 @@ static void save_capture(const char *path) { rt_log("gfx: menu test shot %s (%dx%d)", path, g_cap_w, g_cap_h); } +// The rectangle {x, y, w, h} of a dw x dh swapchain image the cw x ch picture goes into: the whole image with +// TOTK_PICTURE_FIT=stretch, else the largest one of the picture's own aspect ratio, centred (a 16:9 picture on the Steam +// Deck's 1280x800 screen gets bars of 40 rows above and below; a wider window, bars at the sides). +void gfx_fit_rect(int cw, int ch, int dw, int dh, int out[4]) { + out[0] = out[1] = 0, out[2] = dw, out[3] = dh; + if (cw <= 0 || ch <= 0 || !strcmp(cfg_value("TOTK_PICTURE_FIT"), "stretch")) return; + if ((int64_t)dw * ch > (int64_t)dh * cw) out[2] = (int)(((int64_t)dh * cw + ch / 2) / ch); // window wider: pillarbox + else out[3] = (int)(((int64_t)dw * ch + cw / 2) / cw); // taller: letterbox + out[2] += out[2] & 1, out[3] += out[3] & 1; // even sizes keep the bars equal + if (out[2] > dw) out[2] = dw; + if (out[3] > dh) out[3] = dh; + out[0] = (dw - out[2]) / 2, out[1] = (dh - out[3]) / 2; +} + static void present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w, int h, const int crop[4], int defer) { int general = layout == VK_IMAGE_LAYOUT_GENERAL; gfx_window_start(); @@ -566,16 +580,26 @@ static void present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w sync_barrier(cb, dst, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_PIPELINE_STAGE_2_TRANSFER_BIT, 0, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT); const int rect[4] = {cx, cy, cw, ch}; - // FSR (TOTK_UPSCALER) when the swapchain is larger than the crop; else the bilinear blit - int fsr = general && vk_fsr_record(cb, slot, src, fmt, w, h, rect, dst, g_sc_ext.width, g_sc_ext.height); - g_scaler = fsr ? 2 : (uint32_t)cw != g_sc_ext.width || (uint32_t)ch != g_sc_ext.height; + int to[4]; // where the picture goes in the swapchain image: {x, y, w, h} + gfx_fit_rect(cw, ch, (int)g_sc_ext.width, (int)g_sc_ext.height, to); + if (to[2] != (int)g_sc_ext.width || to[3] != (int)g_sc_ext.height) { // black bars beside or above and below it + VkClearColorValue black = {.float32 = {0, 0, 0, 1}}; + VkImageSubresourceRange all = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + vkCmdClearColorImage(cb, dst, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &black, 1, &all); + sync_barrier(cb, dst, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_2_TRANSFER_BIT, + VK_ACCESS_2_TRANSFER_WRITE_BIT); + } + // FSR (TOTK_UPSCALER) when the picture's rectangle is larger than the crop; else the bilinear blit + int fsr = general && vk_fsr_record(cb, slot, src, fmt, w, h, rect, dst, to[0], to[1], (uint32_t)to[2], (uint32_t)to[3]); + g_scaler = fsr ? 2 : cw != to[2] || ch != to[3]; if (!fsr) { if (general) // a GENERAL source (vk_texture.c images): earlier submissions' writes become visible to the blit here sync_barrier(cb, src, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_MEMORY_WRITE_BIT, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_READ_BIT); VkImageBlit region = { .srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .srcOffsets = {{cx, cy, 0}, {cx + cw, cy + ch, 1}}, - .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .dstOffsets = {{0, 0, 0}, {(int)g_sc_ext.width, (int)g_sc_ext.height, 1}}}; + .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .dstOffsets = {{to[0], to[1], 0}, {to[0] + to[2], to[1] + to[3], 1}}}; vkCmdBlitImage(cb, src, general ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion, VK_FILTER_LINEAR); if (general) // later submissions that write the source wait for the blit's read diff --git a/runtime/gfx_window_probe.c b/runtime/gfx_window_probe.c index 93175507..3ab56b64 100644 --- a/runtime/gfx_window_probe.c +++ b/runtime/gfx_window_probe.c @@ -112,14 +112,19 @@ static int present_and_check(Source *s, int first, int i, int *w_out, int *h_out else if (fmt == VK_FORMAT_R8G8B8A8_UNORM) { want[0] = rgb[0]; want[1] = rgb[1]; want[2] = rgb[2]; } else { printf("probe-window: swapchain format %d is not UNORM RGBA/BGRA\n", (int)fmt); return 3; } want[3] = 255; - uint32_t wv; + uint32_t wv, black = 0xff000000u; // opaque black in both byte orders memcpy(&wv, want, 4); + int r[4]; // the picture's rectangle; bars of black around it when the window's shape differs + gfx_fit_rect(SRC_W, SRC_H, w, h, r); const uint32_t *p = (const uint32_t *)px; - for (long k = 0, n = (long)w * h; k < n; k++) - if (p[k] != wv) { - printf("probe-window: frame %d pixel %ld is %08x, expected %08x\n", i, k, p[k], wv); + for (long k = 0, n = (long)w * h; k < n; k++) { + int x = (int)(k % w), y = (int)(k / w); + uint32_t e = x >= r[0] && x < r[0] + r[2] && y >= r[1] && y < r[1] + r[3] ? wv : black; + if (p[k] != e) { + printf("probe-window: frame %d pixel %ld (%d, %d) is %08x, expected %08x\n", i, k, x, y, p[k], e); return 4; } + } *w_out = w; *h_out = h; return 0; diff --git a/runtime/input.c b/runtime/input.c index e0b4e3f3..581175e2 100644 --- a/runtime/input.c +++ b/runtime/input.c @@ -424,9 +424,12 @@ static void poll_merged(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx static int combo_held; int32_t st[4] = {sl[0], sl[1], sr[0], sr[1]}; int toggle = input_menu_gate(&combo_held, menu_is_open(), &b, st); + static int overlay_held; // L3+R3 step the performance overlay (F10) + int overlay = input_overlay_gate(&overlay_held, &b); sl[0] = st[0], sl[1] = st[1], sr[0] = st[2], sr[1] = st[3]; plat_mutex_unlock(&lock); if (toggle) menu_toggle(); + if (overlay) menu_perf_cycle(); stick_bits(&b, sl[0], sl[1], B_SL_LEFT); stick_bits(&b, sr[0], sr[1], B_SR_LEFT); *buttons = b; *lx = sl[0]; *ly = sl[1]; *rx = sr[0]; *ry = sr[1]; diff --git a/runtime/input.h b/runtime/input.h index a127e44f..8fe24377 100644 --- a/runtime/input.h +++ b/runtime/input.h @@ -17,6 +17,7 @@ void input_menu(int open); // Minus+Plus combo and the neutral pad while the menu is open (input_map.c, window-system free): *held is the caller's memory // of the combo, sticks are lx, ly, rx, ry. Returns 1 in the poll where the combo goes down (toggle the menu once). int input_menu_gate(int *held, int menu_open, uint64_t *buttons, int32_t sticks[4]); +int input_overlay_gate(int *held, uint64_t *buttons); // L3+R3: 1 in the poll both go down int input_pad_read(uint64_t *buttons, int32_t *lx, int32_t *ly); // The gamepad layout in effect (PAD_LAYOUT_*, input_map.h; TOTK_PAD_LAYOUT, live); -1 without a gamepad. Any thread. int input_pad_layout(void); diff --git a/runtime/input_map.c b/runtime/input_map.c index 23775332..22596309 100644 --- a/runtime/input_map.c +++ b/runtime/input_map.c @@ -329,8 +329,7 @@ void input_mouse_stick(int32_t dx, int32_t dy, double dt_s, float sens, int32_t // down (the caller keeps it). Every poll of the latch reports neither to the game, so releasing one button first does not // leak the other; Minus alone before Plus reaches the game unchanged. With the menu open the game sees a neutral pad. // Returns 1 in the poll where both go down: the caller toggles the menu once. -int input_menu_gate(int *held, int menu_open, uint64_t *buttons, int32_t sticks[4]) { - const uint64_t combo = 1ull << B_MINUS | 1ull << B_PLUS; +static int chord(int *held, uint64_t *buttons, uint64_t combo) { uint64_t raw = *buttons & combo; int edge = 0; if (*held) { @@ -340,9 +339,20 @@ int input_menu_gate(int *held, int menu_open, uint64_t *buttons, int32_t sticks[ edge = 1; } if (*held) *buttons &= ~combo; + return edge; +} + +int input_menu_gate(int *held, int menu_open, uint64_t *buttons, int32_t sticks[4]) { + int edge = chord(held, buttons, 1ull << B_MINUS | 1ull << B_PLUS); if (menu_open) { *buttons = 0; sticks[0] = sticks[1] = sticks[2] = sticks[3] = 0; } return edge; } + +// Both stick clicks held together step the performance overlay as F10 does (a gamepad has no F10: the Steam Deck in +// Game Mode). The same latch as the menu's above; the game sees neither click while it holds. +int input_overlay_gate(int *held, uint64_t *buttons) { + return chord(held, buttons, 1ull << B_STICK_L | 1ull << B_STICK_R); +} diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index b6dcde9c..7e86ce74 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -412,7 +412,8 @@ static void row_window_size(void) { // The game resolution (resolution.c): 16:9 sizes from the game's own 1920x1080 up, and the current value when it is // another size. static void row_output_res(void) { - static const char *const vals[] = {"1920x1080", "2560x1440", "3200x1800", "3840x2160"}; + // 1280x720: the Steam Deck's (letterboxed in its 1280x800 screen, TOTK_PICTURE_FIT) + static const char *const vals[] = {"1280x720", "1600x900", "1920x1080", "2560x1440", "3200x1800", "3840x2160"}; enum { N = sizeof vals / sizeof *vals }; char shown[N][32]; const char *names[N]; @@ -476,8 +477,10 @@ static void row_game_lang(void) { // The frame limit (frame_rate.c): unset, the older fps60 = 0 still means 30. The monitor choice shows the rate it gives. static void row_fps_limit() { - static const char *const vals[] = {"30", "60", "120", "144", "display"}; - static const UiTextId ids[] = {UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_120, UI_MENU_FPS_144, UI_MENU_FPS_DISPLAY}; + // 40 and 45: the Steam Deck's screen runs at 40 to 60 Hz (the OLED to 90); 40 divides 40 and 120 Hz evenly + static const char *const vals[] = {"30", "40", "45", "60", "90", "120", "144", "display"}; + static const UiTextId ids[] = {UI_MENU_FPS_30, UI_MENU_FPS_40, UI_MENU_FPS_45, UI_MENU_FPS_60, + UI_MENU_FPS_90, UI_MENU_FPS_120, UI_MENU_FPS_144, UI_MENU_FPS_DISPLAY}; enum { N = sizeof vals / sizeof *vals }; const char *names[N]; for (int i = 0; i < N; i++) names[i] = menu_text(ids[i]); @@ -527,6 +530,8 @@ static void tab_screen(float scale) { row_render_scale(); static const UiTextId up[] = {UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR}; opt_choice("TOTK_UPSCALER", UI_MENU_UPSCALER, up, 2, UI_MENU_UPSCALER_DESC); + static const UiTextId fit[] = {UI_MENU_PICTURE_FIT_KEEP, UI_MENU_PICTURE_FIT_STRETCH}; + opt_choice("TOTK_PICTURE_FIT", UI_MENU_PICTURE_FIT, fit, 2, UI_MENU_PICTURE_FIT_DESC); opt_slider("TOTK_SHARPNESS", UI_MENU_SHARPNESS, 0, 100, UI_MENU_SHARPNESS_DESC, 5, "%.0f %%"); opt_end(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index f93107ae..4cd7444a 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -61,13 +61,19 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_UPSCALER_DESC] = "How the picture is scaled when the window is larger than the game resolution. FSR keeps " "edges and detail sharper than bilinear.", [UI_MENU_UPSCALER_FSR] = "AMD FSR 1", [UI_MENU_UPSCALER_BILINEAR] = "Bilinear", + [UI_MENU_PICTURE_FIT] = "Picture shape", + [UI_MENU_PICTURE_FIT_DESC] = "When the window's shape differs from the game resolution's (a 16:9 game on the Steam " + "Deck's 16:10 screen), keep the picture's proportions with black bars, or stretch it " + "over the whole window.", + [UI_MENU_PICTURE_FIT_KEEP] = "Keep (bars)", [UI_MENU_PICTURE_FIT_STRETCH] = "Stretch", [UI_MENU_SHARPNESS] = "FSR sharpness", [UI_MENU_SHARPNESS_DESC] = "Sharpening after FSR scaling; 0 turns it off.", [UI_MENU_FPS_LIMIT] = "Frame rate limit", [UI_MENU_FPS_LIMIT_DESC] = "The most frames per second the game draws. Above 60 is experimental and needs Game speed " "follows the clock.", - [UI_MENU_FPS_30] = "30 FPS", [UI_MENU_FPS_60] = "60 FPS", [UI_MENU_FPS_120] = "120 FPS", [UI_MENU_FPS_144] = "144 FPS", + [UI_MENU_FPS_30] = "30 FPS", [UI_MENU_FPS_40] = "40 FPS", [UI_MENU_FPS_45] = "45 FPS", + [UI_MENU_FPS_60] = "60 FPS", [UI_MENU_FPS_90] = "90 FPS", [UI_MENU_FPS_120] = "120 FPS", [UI_MENU_FPS_144] = "144 FPS", // the monitor's refresh rate; printf format with the rate in Hz when it is known [UI_MENU_FPS_DISPLAY] = "Monitor rate", [UI_MENU_FPS_DISPLAY_HZ] = "Monitor rate (%.0f Hz)", [UI_MENU_REALTIME] = "Game speed follows the clock", @@ -279,13 +285,18 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_UPSCALER_DESC] = "Как картинка растягивается, когда окно больше разрешения игры. FSR сохраняет края и " "детали чётче билинейного.", [UI_MENU_UPSCALER_FSR] = "AMD FSR 1", [UI_MENU_UPSCALER_BILINEAR] = "Билинейное", + [UI_MENU_PICTURE_FIT] = "Пропорции картинки", + [UI_MENU_PICTURE_FIT_DESC] = "Когда форма окна отличается от формы разрешения игры (игра 16:9 на экране Steam Deck " + "16:10), сохранять пропорции картинки с чёрными полосами или растягивать её на всё окно.", + [UI_MENU_PICTURE_FIT_KEEP] = "Сохранять (полосы)", [UI_MENU_PICTURE_FIT_STRETCH] = "Растягивать", [UI_MENU_SHARPNESS] = "Резкость FSR", [UI_MENU_SHARPNESS_DESC] = "Повышение резкости после масштабирования FSR; 0 выключает его.", [UI_MENU_FPS_LIMIT] = "Ограничение частоты кадров", [UI_MENU_FPS_LIMIT_DESC] = "Наибольшее число кадров в секунду. Выше 60 — экспериментальный режим, нужна «Скорость " "игры по часам».", - [UI_MENU_FPS_30] = "30 FPS", [UI_MENU_FPS_60] = "60 FPS", [UI_MENU_FPS_120] = "120 FPS", [UI_MENU_FPS_144] = "144 FPS", + [UI_MENU_FPS_30] = "30 FPS", [UI_MENU_FPS_40] = "40 FPS", [UI_MENU_FPS_45] = "45 FPS", + [UI_MENU_FPS_60] = "60 FPS", [UI_MENU_FPS_90] = "90 FPS", [UI_MENU_FPS_120] = "120 FPS", [UI_MENU_FPS_144] = "144 FPS", [UI_MENU_FPS_DISPLAY] = "Как у монитора", [UI_MENU_FPS_DISPLAY_HZ] = "Как у монитора (%.0f Гц)", [UI_MENU_REALTIME] = "Скорость игры по часам", [UI_MENU_REALTIME_DESC] = "Игра идёт по реальному времени, медленный кадр её не замедляет.", diff --git a/runtime/ui_text.h b/runtime/ui_text.h index 6eb805cf..afd1fb5f 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -35,10 +35,12 @@ typedef enum { UI_MENU_OUTPUT_RES, UI_MENU_OUTPUT_RES_DESC, UI_MENU_RENDER_SCALE, UI_MENU_RENDER_SCALE_DESC, UI_MENU_RENDER_SCALE_GAME, UI_MENU_UPSCALER, UI_MENU_UPSCALER_DESC, UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR, + UI_MENU_PICTURE_FIT, UI_MENU_PICTURE_FIT_DESC, UI_MENU_PICTURE_FIT_KEEP, UI_MENU_PICTURE_FIT_STRETCH, UI_MENU_SHARPNESS, UI_MENU_SHARPNESS_DESC, // Game - UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_120, UI_MENU_FPS_144, + UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_40, UI_MENU_FPS_45, UI_MENU_FPS_60, UI_MENU_FPS_90, + UI_MENU_FPS_120, UI_MENU_FPS_144, UI_MENU_FPS_DISPLAY, UI_MENU_FPS_DISPLAY_HZ, UI_MENU_REALTIME, UI_MENU_REALTIME_DESC, UI_MENU_CLOTH_REALTIME, UI_MENU_CLOTH_REALTIME_DESC, diff --git a/runtime/vk.h b/runtime/vk.h index ebc6215e..6abeda53 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -77,11 +77,11 @@ void vk_present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w, in // vk_present_image split in two: vk_present_blit submits the blit and leaves the present waiting, vk_present_flip // queues it. The next blit or a swapchain rebuild queues a waiting present first. void vk_present_blit(VkImage src, VkImageLayout layout, VkFormat fmt, int w, int h, const int crop[4]); -// FSR 1 on the present (vk_fsr.c): records EASU (+ RCAS) of src's crop rectangle {x, y, w, h} into dst, a dw x dh -// swapchain image in TRANSFER_DST; src is in GENERAL and fmt its format. 0 = nothing recorded (the setting says -// bilinear, no upscale is needed, or FSR is not available): the caller blits. +// FSR 1 on the present (vk_fsr.c): records EASU (+ RCAS) of src's crop rectangle {x, y, w, h} into the dw x dh +// rectangle at {dx, dy} of dst, a swapchain image in TRANSFER_DST; src is in GENERAL and fmt its format. 0 = nothing +// recorded (the setting says bilinear, no upscale is needed, or FSR is not available): the caller blits. int vk_fsr_record(VkCommandBuffer cb, unsigned slot, VkImage src, VkFormat fmt, int sw, int sh, const int crop[4], - VkImage dst, uint32_t dw, uint32_t dh); + VkImage dst, int dx, int dy, uint32_t dw, uint32_t dh); void vk_fsr_release(void); // before the device goes away void vk_present_flip(void); // Every submission to ctx->gfx_queue (and xfer_queue when shared) takes this lock; vk_present_image and the swapchain @@ -90,6 +90,9 @@ void vk_queue_lock(void); void vk_queue_unlock(void); // Copy of the last presented swapchain image, for probes: on, the next presents read the image back into a host buffer // and wait for the GPU. *px stays valid until the next present; the format is the swapchain's. Returns 0 with no frame. +// The rectangle {x, y, w, h} of a dw x dh swapchain image a cw x ch picture is presented in (gfx_present.c, +// TOTK_PICTURE_FIT); the rest is black. +void gfx_fit_rect(int cw, int ch, int dw, int dh, int out[4]); void vk_present_capture(int on); int vk_present_captured(const uint8_t **px, int *w, int *h, VkFormat *fmt); diff --git a/runtime/vk_fsr.c b/runtime/vk_fsr.c index b5612d28..60f351f5 100644 --- a/runtime/vk_fsr.c +++ b/runtime/vk_fsr.c @@ -152,7 +152,7 @@ static void bind_pass(VkCommandBuffer cb, VkPipeline p, VkImageView in, VkImageV } int vk_fsr_record(VkCommandBuffer cb, unsigned slot, VkImage src, VkFormat fmt, int sw, int sh, const int crop[4], - VkImage dst, uint32_t dw, uint32_t dh) { + VkImage dst, int dx, int dy, uint32_t dw, uint32_t dh) { int cw = crop[2], ch = crop[3]; if (strcmp(cfg_value("TOTK_UPSCALER"), "fsr") || (dw <= (uint32_t)cw && dh <= (uint32_t)ch) || !fmt) return 0; VkCtx *c = vk_ctx(); @@ -204,7 +204,7 @@ int vk_fsr_record(VkCommandBuffer cb, unsigned slot, VkImage src, VkFormat fmt, VkImageBlit region = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .srcOffsets = {{0, 0, 0}, {(int)dw, (int)dh, 1}}, .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, - .dstOffsets = {{0, 0, 0}, {(int)dw, (int)dh, 1}}}; + .dstOffsets = {{dx, dy, 0}, {dx + (int)dw, dy + (int)dh, 1}}}; vkCmdBlitImage(cb, F.img[last], VK_IMAGE_LAYOUT_GENERAL, dst, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion, VK_FILTER_NEAREST); return 1; diff --git a/totk.ini.example b/totk.ini.example index f8213a99..f9461e06 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -1,10 +1,11 @@ # totk.ini: settings for totk.exe. Copy this file to totk.ini next to totk.exe and remove the '#' of a line to change it. -# Each line shows the default. A TOTK_* environment variable of the same name (TOTK_FPS_LIMIT for fps_limit) overrides the -# file. Keys are case-insensitive; '#' and ';' start a comment; [sections] only group lines. +# Each line shows the default; on a Steam Deck the device profile ([display]) changes a few of them. A TOTK_* +# environment variable of the same name (TOTK_FPS_LIMIT for fps_limit) overrides the file. Keys are case-insensitive; +# '#' and ';' start a comment; [sections] only group lines. [frame rate] -# Frame rate limit: 30, 60, 120, 144, any whole rate from 30 to 360, or display (the refresh rate of the window's -# monitor). Above 60 is experimental and needs realtime = 1. Changes while the game runs take effect at once. +# Frame rate limit: 30, 40, 45, 60, 90, 120, 144, any whole rate from 30 to 360, or display (the refresh rate of the +# window's monitor). Above 60 is experimental and needs realtime = 1. Changes while the game runs take effect at once. # fps_limit = 60 # Older key, read only while fps_limit is unset: fps60 = 0 means a limit of 30. # fps60 = 1 @@ -93,6 +94,10 @@ # vk_subgroup_pin = 1 [display] +# Device profile: auto (the Steam Deck when this is one), desktop or deck. On a Steam Deck the keys this file does not +# set default to fullscreen = 1, window_size = 1280x800, output_res = 1280x720, render_scale = game, vk_present = fifo +# and fps_limit = 40 (starting points, not measured yet). Read at start. +# device_profile = auto # Presentation mode: mailbox (default when the driver offers it, vsync otherwise), fifo (vsync) or immediate. # vk_present = mailbox # Window client area in pixels (640x360 to 7680x4320), and borderless fullscreen. F11 switches fullscreen and saves it @@ -100,7 +105,7 @@ # window_size = 1920x1080 # fullscreen = 0 # Performance overlay in the top right corner: off, fps, or full (frame rate, mean and longest frame time). F10 -# cycles the modes in game. +# cycles the modes in game, as do both stick clicks (L3 + R3) on a controller. # perf_overlay = off # Which GPU to use: its index in the log, or part of its name. Default: the first discrete GPU with Vulkan 1.3. # gpu_index = 0 @@ -115,6 +120,9 @@ # from 0 (off) to 100. Changes while the game runs take effect at once. # upscaler = fsr # sharpness = 80 +# Picture shape when the window's differs from the game resolution's (a 16:9 game on a 16:10 screen): keep (its +# proportions, with black bars) or stretch (over the whole window). Changes take effect at once. +# picture_fit = keep [language] # Language: a Windows locale such as de-DE, or a Switch code (en-US, ja, zh-Hant, ...). Default: the Windows locale.