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.