Merge branch 'dev' into task/vloc

This commit is contained in:
Valiantsin Dzerakh committed 2026-11-13 20:11:40 +03:00
commit 1a1f21ebe0
84 files changed
+5274 -569

No files matched your search

+1 -1
View File
@@ -36,7 +36,7 @@ Open pull requests against `dev`. Branch from the current `dev` and rebase on it
### Before you start
- Search the open pull requests and issues on the topic. When another pull request already covers it, improve that one or say in yours how they differ.
- Fixes are reviewed before features, in order of how many players the bug hits. A feature with a design in [docs/milestones/](docs/milestones/) (mods, cheats, the menu) follows that design. For a feature without one, open an issue first.
- Fixes are reviewed before features, in order of how many players the bug hits. A feature with a design in `docs/milestones/` (mods, cheats, the menu) follows that design. For a feature without one, open an issue first.
- Find out where the bug reproduces: OS, GPU vendor and generation, driver, game update, settings. Put that in the description.
### What the change must keep
+4 -3
View File
@@ -10,10 +10,10 @@ Code copied or adapted from another project is listed here with its source, the
| MacNativeGames TotK host runtime: dynamic linking, identity check, module permissions, guest memory and SVCs, threads, IPC, audio renderer, system services, RomFS and save storage, boot sequence, the NVN proc name list | https://github.com/ly05010419/MacNativeGames @ `b75be8cfa704df3701e86130c8ced268e79d6b11` (`games/totk/runtime/`, `games/totk/scripts/prepare_runtime.py`), Copyright (c) 2026 MacNativeGames contributors | MIT | `runtime/loader.c`, `runtime/memory.c`; `runtime/kernel.c`, `runtime/svc.c`, `runtime/ipc.c`, `runtime/ipc.h`, `runtime/audren.c`, `runtime/audren.h`, `runtime/audio_mixer.c`, `runtime/audio_effects.c`, `runtime/audio_effects.h`, `runtime/audio_reverb.c`, `runtime/audio_reverb.h` (SDL3 output replaces CoreAudio), `runtime/ov_system.c` (also `shared_font.c`: the BFTTF layout behind nn::pl), `runtime/ov_input.c` (also `hid_feedback.c`: vibration and six-axis handles and calls), `runtime/motion_fusion.c` (six-axis fusion of `motion_fusion.c`), `runtime/ov_media.c` (hardware Opus decoder over libopus), `runtime/swkbd_win.c` (`swkbd_host.c`: ShowKeyboardArg offsets, UTF-8/UTF-16 conversion, disabled-key filter, result codes; Win32 window replaces the macOS text bar), `runtime/ov_gfx.c`, `runtime/romfs.c`, `runtime/romfs_path.h`, `runtime/fs_host.c`, `runtime/fs.h`, `runtime/boot.c`; `runtime/gfx_window.c`; `tools/gen_nvn_procs.py`, `runtime/nvn_procs.inc` (`NVN/names.txt` and the `NVN_EXTRA` names of `totk_nvn_ext.c`) |
| MacNativeGames TotK frame-rate patches: 60 fps present-interval controller, real-time frame step and its present sampling, hair and cloth clock, trampoline slow-motion check (instruction words and 1.2.1 sites), player position chain; quick-menu capture background RomFS overlay | https://github.com/ly05010419/MacNativeGames @ `ebe621de99bfc48f3c42f2d2aa73e04fbcc6eae2` (`games/totk/runtime/game_patches.c`, `game_version.h`, `world_survey.c`, `games/totk/scripts/make_romfs_patches.py`), Copyright (c) 2026 MacNativeGames contributors | MIT | `runtime/frame_rate.c`, `recomp/patches-v121.txt`, `tools/make_romfs_patches.py` |
| MacNativeGames TotK 1.4.3 fade fix: the four distance / LOD and pre-actor fade sites, their instruction words and the floor of the fade step at 1 | https://github.com/ly05010419/MacNativeGames @ `3e9e7f67fdfdd3404134dcfa0f24969a9425a33f` (`games/totk/runtime/game_patches_v143.c` patch_fade_increment), Copyright (c) 2026 MacNativeGames contributors | MIT | `recomp/patches-v143.txt` (set fade; the floor without flags, clz >> 5, as in pull request #78) |
| MacNativeGames TotK 1.2.1 cursor and aim steps: the map cursor, vertical Ultrahand aim and vertical gyro aim sites, their instruction words and the step scaled by the frame ratio | https://github.com/ly05010419/MacNativeGames @ `363a6eb50434387f7d623349934bcf1e910be48f` (`games/totk/runtime/game_patches.c` patch_cursor_speed), Copyright (c) 2026 MacNativeGames contributors | MIT | `recomp/patches-v121.txt` (set cursor) |
| MacNativeGames TotK aspect ratio: the camera and viewport sites that hand the perspective projection its aspect ratio, and the UI layout edits for a canvas wider than 16:9 | https://github.com/ly05010419/MacNativeGames @ `933b6a0d1438de160208a0a13eb5e8d7a2cb8094` (`games/totk/runtime/aspect_patch.h`, `aspect_math.h`, `game_patches_v143.c`, `games/totk/scripts/ultrawide_layout.py`), Copyright (c) 2026 MacNativeGames contributors | MIT | `recomp/patches-v143.txt` (set aspect), `tools/ultrawide_layout.py`, `tools/make_romfs_patches.py` (--aspect) |
| MacNativeGames TotK 1.2.1 cursor and aim steps: the map cursor, vertical Ultrahand aim and vertical gyro aim sites, their instruction words and the step scaled by the frame ratio | https://github.com/ly05010419/MacNativeGames @ `363a6eb50434387f7d623349934bcf1e910be48f` (`games/totk/runtime/game_patches.c` patch_cursor_speed), Copyright (c) 2026 MacNativeGames contributors | MIT | `recomp/patches-v121.txt`, `recomp/patches-v110.txt` (set cursor) |
| MacNativeGames TotK aspect ratio: the camera and viewport sites that hand the perspective projection its aspect ratio, and the UI layout edits for a canvas wider than 16:9 | https://github.com/ly05010419/MacNativeGames @ `933b6a0d1438de160208a0a13eb5e8d7a2cb8094` (`games/totk/runtime/aspect_patch.h`, `aspect_math.h`, `game_patches_v143.c`, `games/totk/scripts/ultrawide_layout.py`), Copyright (c) 2026 MacNativeGames contributors | MIT | `recomp/patches-v110.txt`, `recomp/patches-v143.txt` (set aspect), `tools/ultrawide_layout.py`, `tools/make_romfs_patches.py` (--aspect) |
| MacNativeGames TotK button icons: the Xbox controller's shoulder buttons, triggers, Menu, View and d-pad drawn with letters from the game's own text fonts, the .bfotf key, the button guide's images and their block-linear layout, the resource size table raised for the archives that grew | https://github.com/ly05010419/MacNativeGames @ `933b6a0d1438de160208a0a13eb5e8d7a2cb8094` (`games/totk/scripts/make_button_icons.py`), Copyright (c) 2026 MacNativeGames contributors | MIT | `tools/button_icons.py`, `tools/make_romfs_patches.py` (--prompts) |
| RenoDX TotK mod (game mod by souperman9, tonemapper by Musa, RenoDX framework by ShortFuse, RenoVK fork by Ritsu): the approach of the HDR tonemap (the game's 1 - e^-x curve kept below a pivot and continued along its tangent above it, the saturation grade applied to the colour scaled into 0..1) and the observation that the passes after the tonemap keep values above 1. No code copied; the shader is our own | https://github.com/clshortfuse/renodx @ `b6f87272ad1bfdc0e6444910a93606815944a085` (`src/games/totk/tonemap.slang`, `addon.cpp`), Copyright (c) 2025 Carlos Lopez Jr. | MIT | `runtime/shaders/hdr_tonemap.frag`, `runtime/vk_hdr.c` |
| RenoDX TotK mod (game mod by souperman9, tonemapper by Musa, RenoDX framework by ShortFuse, RenoVK fork by Ritsu): the HDR tonemap's colour reconstruction (the game's 1 - e^-x curve continued along its tangent above 0.18, the SDR result as hue and purity donor through MacLeod-Boynton in BT.2020, the saturation grade on a Neutwo-compressed colour, per-channel Neutwo to the peak in BT.2020, the sRGB to gamma 2.2 correction) adapted into GLSL, and the observation that the passes after the tonemap keep values above 1 | https://github.com/clshortfuse/renodx @ `43c067b755a6a741f6500b2b936570f1462dcfbe` (`src/games/totk/tonemap.slang`, `src/games/totk/macleod_boynton.hlsli`, `src/shaders/colorcorrect.hlsl`, `src/shaders/tonemap/neutwo.hlsl`), Copyright (c) 2025 Carlos Lopez Jr. | MIT | `runtime/shaders/hdr_tonemap.frag`, `runtime/vk_hdr.c` |
| TOTK-Ultrawide, the community mod for emulators: the list of UI panes the ultrawide layout edits and the distances they move (data only, no code copied; the edit code is our own, and MacNativeGames' `ultrawide_layout.py` in the row above already carries the same values). The mod's repository URL and licence version are not recorded in this repository | TOTK-Ultrawide (community mod; URL not recorded here) | GPL (version not recorded here) | `tools/ultrawide_layout.py` (`KEEP_ROOT`, `edits`, `anim_edits`) |
| MacNativeGames TotK virtual-core preemption: asynchronous preemption of an owner in top-level game code, priority inheritance through guest mutexes, the SDK's preemption-disable protocol (TLR+0x100/+0x102, SVC 0x36), the core-wait diagnostics | https://github.com/ly05010419/MacNativeGames @ `33e8fa83052ea1ae09a3583137008e9797e12950` (`games/totk/runtime/threads.c`, commits 8bf0893 and 19730cd), Copyright (c) 2026 MacNativeGames contributors | MIT | `runtime/kernel.c` (SuspendThread and a register-saving stub replace SIGUSR2), `runtime/hostfn.c`, `runtime/svc.c` (host depth) |
| MacNativeGames RomFS index builder (`TOTKRFS1` layout) | https://github.com/ly05010419/MacNativeGames @ `b75be8cfa704df3701e86130c8ced268e79d6b11` (`games/totk/scripts/prepare_romfs_backend.py`), Copyright (c) 2026 MacNativeGames contributors | MIT | `tools/romfs_index.py` |
@@ -41,6 +41,7 @@ Code copied or adapted from another project is listed here with its source, the
| AMD Display Library (ADL) declarations: `AdapterInfo`, `ADLSingleSensorData`, `ADLPMLogDataOutput`, the `ADL_PMLOG_*` sensor numbers and the `ADL2_*` function signatures | https://github.com/GPUOpen-LibrariesAndSDKs/display-library @ `84c881cb2136f04287eb3af12de00a9e2867aa9e` (`include/adl_structures.h`, `include/adl_defines.h`, `include/adl_sdk.h`), Copyright (c) 2016 - 2022 Advanced Micro Devices, Inc. | MIT | `runtime/perfmon.c` |
| Zstandard 1.5.7 (MSYS2 `mingw-w64-ucrt-x86_64-zstd`), static link | https://github.com/facebook/zstd, Copyright (c) Meta Platforms, Inc. and affiliates | BSD-3-Clause | `runtime/resolution.c` (the HeapDef table), `runtime/ov_zstd.c` (the game's zstd frames decoded on the host) |
| musl `fma.c`, `fmaf.c` and `scalbn.c`, adapted into one file for the x86-64-v2 build | https://github.com/kraj/musl @ `5a56ad13e1e0790c06122978aad2a14d6b9efc1a` (mirror of https://git.musl-libc.org/cgit/musl), Copyright (c) 2005-2020 Rich Felker and contributors | MIT | `runtime/fma.c` (the correctly rounded fma/fmaf the FP lowering needs on CPUs without FMA3) |
| MacNativeGames texture pool offset fix: widen the 32-bit texture storage and packaged-data offsets unsigned | https://github.com/ly05010419/MacNativeGames @ `ca311e2d` (`games/totk/runtime/game_patches.c` patch_pool_offset), Copyright (c) 2026 MacNativeGames contributors | MIT | `recomp/patches-v110.txt` (set pooloff; sites located again in 1.1.0) |
## Compiler runtime in a source build
+2
View File
@@ -49,6 +49,8 @@ GPU semantics behind the graphics rows: [maxwell.md](../maxwell.md). The method
| a host core at 100% while the game waits | game spin loops without system calls | profile: which guest function spins |
| crash on world load | sizes the game reads from the driver (command memory used) differ from the console's | the sizes the game asks for against the console's |
| crash with one save only | the save itself; some crash on a real Switch | the same save on another build and, if possible, on hardware |
| random crash after minutes to hours, access violation reading `0xffffffffffffffff` or a small address such as `0x90` in a game function (Windows reports any non-canonical address as `0xffffffffffffffff`) | an invalid value (-1, `0xffff0000ffffffff`) in an optional reference the game checks only for null; in main+0x1bd0138 (Recall / Ultrahand picking a target) also a reused holder whose actor points into other memory. Sets `optref` and `ability` in `recomp/patches-v143.txt` guard both there | the crash dump's faulting host instruction, the register it loads through and the field that register came from; `ability: target dropped` lines in the log |
| crash while using Ultrahand or aiming, in the model scene's report loop (1.4.3 main+0xa22bc..0xa234c) | a report row index read from the report buffer with no bound (Weeping of the Empire #52, #73); set `report` sends a negative handle or an index from 0x8000 to the game's own reset | the faulting address against the report rows base (x12) |
## Device lost, hangs, black window
+29 -5
View File
@@ -29,7 +29,7 @@ The log names the layout in effect (`input: gamepad layout ...`); the menu shows
| Minus | Back | M | map |
| Right stick shaken left and right | shake the right stick | G | detach a fused part from what Ultrahand holds |
Esc is unbound in the game; it opens the settings menu and releases the mouse cursor (see Mouse camera). Z and X duplicate ZL and ZR so menu pages turn with two neighbouring keys; the menu tabs (L, R) are Q and R. T duplicates Y for the game's menus, where the left mouse button is A while the pointer is shown (sort the inventory with T). The mouse wheel zooms the Purah Pad's map and is unbound elsewhere. The bindings are the tables of `input_map` in `runtime/input_map.c`: the keys (platform-neutral key ids) and one gamepad table per layout (gamepad inputs by position); `runtime/input_win.c` translates Win32 virtual keys and SDL buttons.
Esc is unbound in the game; it opens the settings menu and releases the mouse cursor (see Mouse camera). Z and X duplicate ZL and ZR so menu pages turn with two neighbouring keys; the menu tabs (L, R) are Q and R. T duplicates Y for the game's menus, where the left mouse button is A while the pointer is shown (sort the inventory with T). The mouse wheel zooms the Purah Pad's map and its camera, steps the game's menus and the d-pad strips (see Mouse in the game's menus), and is unbound elsewhere. The bindings are the tables of `input_map` in `runtime/input_map.c`: the keys (platform-neutral key ids) and one gamepad table per layout (gamepad inputs by position); `runtime/input_win.c` translates Win32 virtual keys and SDL buttons.
## Xbox button prompts
@@ -65,7 +65,7 @@ At a game resolution of another shape than 16:9 the game loads `romfs-patches-xb
| Switch | Prompt |
|---|---|
| A, B, X, Y | E, Shift, Space, left click |
| A, B, X, Y | E, Shift, Space, left click (T in text prompts) |
| L, R, ZL, ZR | Q, R, right click, F |
| Plus, Minus | Tab, M |
| D-pad | 1 (left), 2 (up), 3 (right), 4 (down), as a cross or the keys of the directions meant |
@@ -74,7 +74,8 @@ At a game resolution of another shape than 16:9 the game loads `romfs-patches-xb
- The glyphs keep the width of the game's own, so the right-aligned guides do not run into their text. A key is a rounded square with its label cut out in the game's own text fonts (Shift: an arrow over its name); a mouse button is a mouse with that button filled and the others hollow.
- The button guide in play draws every button from images of the Common archive (`Nt_KeyTexA/B/X/Y/L/ZL_00`, `Nt_KeyTexLSt_00` and `_01`, the stick tilted and pressed): all of them are painted with the same icons. The letters of the action prompt's diamond are one character of the Normal font each: E, an arrow for Shift, a bar for Space, L and R for the mouse buttons.
- Like the Xbox prompts they follow the defaults and not the bindings. `--binds <totk.ini>` draws the first key of each `bind_` line of that file instead, for a folder made by hand.
- Y has two keys, the left mouse button and T. The button guide in play and the action prompt show the left button, which attacks there; the prompts in text (the menus' guides such as *Sort*, the dialogue log's) show T, because while a menu has the pointer the left button is that menu's A, and T presses Y everywhere (`PC_TEXT_KEYS` in `tools/button_icons.py`). With a `bind_y` line, the text prompts take its first key that is not a mouse button (its only key when all are mouse buttons).
- They follow the bindings of the install's `totk.ini` as the setup found them: its *Drawing the keyboard and mouse prompts* step passes the file as `--binds` (the first key of each `bind_` line), and the keyboard defaults without one. After a change on the Controls tab run the setup again: that step alone runs, since it is keyed by the `bind_` lines (`PcPrompts` in `installer/steps.py`). The Xbox prompts follow the defaults.
- At a game resolution of another shape than 16:9 the game loads `romfs-patches-pc-<w>x<h>` in place of `romfs-patches-<w>x<h>`: the same prompts with that shape's UI layout, `make_romfs_patches.py --prompts pc --aspect <w>x<h> --reuse <install>\romfs-patches-pc --out <install>\romfs-patches-pc-<w>x<h>`. The setup writes one for each of the fifteen sizes it lays the UI out for, so on a display of one of those shapes the game resolution follows the display with these prompts too. At another size, without that folder, the Switch prompts stay (*off at this game resolution*).
## Window keys
@@ -174,7 +175,8 @@ The horizontal quick lists (D-pad up/left/right: materials, shields and weapons)
with at least 32 ms of neutral between them. At sensitivity 1, 32 horizontal counts request a step; a large flick
cannot queue continued scrolling after the mouse stops. Vertical movement is ignored in these lists. Switching or
releasing a selector resets its cursor/step state without sending the last movement to the camera. Selector input is
not consumed by the direct camera or Ultrahand hooks.
not consumed by the direct camera or Ultrahand hooks. The scroll wheel steps these lists too: each notch is one step,
away from you to the left, towards you to the right.
To detach a fused part from what Ultrahand holds, shake the mouse left and right, or press G (`bind_SHAKE`). A press
swings the right stick left and right for 0.8 s, holding the key keeps it swinging. With `mouse_mode = direct` a shake
of the mouse while Ultrahand holds an object swings the right stick with it: once the swings (10 degrees of camera turn
@@ -199,10 +201,30 @@ The stick direction bits (`StickLLeft` to `StickRDown`) are derived from the sti
## Mouse in the game's menus
On game 1.4.3, while one of the game's menus has its focus box (the frame the d-pad moves: the title, the save list, the inventory and its System tab, Options, shops, dialogue choices), the cursor is released from the mouse camera and shown in the middle of the window. A focus gap of up to 300 ms (a tab switch, a popup opening: the game drops the focus box for a frame or two) keeps the pointer where it is instead of capturing and centring it again. The item under the pointer takes the focus as if the d-pad had moved there, with the game's highlight, sound and description; a left click is A on it, a right click is B. The middle and side mouse buttons keep their bindings (bound to L and R they turn the tabs), and T presses Y (sort). The keys and the pad keep working, and the focus moves only when the pointer moves. This happens only while the keyboard and mouse are the device used last: after a gamepad button press or a stick pushed past half way the menus are as on the console, with no pointer, until the mouse moves or a key is pressed (`input_kbm_last` in `runtime/input.c`). The ability wheel, the d-pad strips, Autobuild and the Purah Pad's camera stay gameplay: the mouse keeps the camera there. The map has no focus box; it is found in `eui::ScreenMgr`'s list of open screens (every 100 ms: the Purah Pad's frame `AppMenuOverlay_00` with `AppMap_00` and the menu background `AppMenuBG_00`), and there the mouse moves the map's cursor as the left stick does, with the cursor still captured, and the scroll wheel zooms: each notch is a full-tilt push of the right stick (the map's zoom) for 100 ms with 50 ms of neutral after it, up (in) for a turn away from you; a fast scroll's notches wait their turn (at most four), a turn the other way drops them. The Scope opens the same map screen without the menu background and keeps the mouse camera. When the menu closes the cursor is captured again.
On game 1.4.3, while one of the game's menus has its focus box (the frame the d-pad moves: the title, the save list, the inventory and its System tab, Options, shops, dialogue choices), the cursor is released from the mouse camera and shown in the middle of the window. A focus gap of up to 300 ms (a tab switch, a popup opening: the game drops the focus box for a frame or two) keeps the pointer where it is instead of capturing and centring it again. The item under the pointer takes the focus as if the d-pad had moved there, with the game's highlight, sound and description; a left click is A on it, a right click is B. The middle and side mouse buttons keep their bindings (bound to L and R they turn the tabs), and T presses Y (sort). The scroll wheel moves the focus up and down, one step a notch (a full-tilt push of the left stick for 70 ms with 50 ms of neutral after it, up for a turn away from you), so a long list of items scrolls without moving the pointer; `menu_cursor = 0` turns this off with the pointer. The keys and the pad keep working, and the focus moves with the pointer only when the pointer moves: after the wheel, a key or the pad moved the focus off the pointer's item, the pointer takes it back once it has moved 6 layout units (the menus' 1280 x 720: about 9 window pixels at 1080p, 18 at 4K) from where it was then (`DEAD_ZONE` in `runtime/menu_cursor.c`), so a hand resting on the mouse does not undo a scroll; a click acts at once. With `pointer_image = 1` (off by default) the game window shows a pointer of its own while the cursor is not captured, a gold arrowhead drawn at the window's DPI (`runtime/cursor_art.c`), in place of the system arrow. This happens only while the keyboard and mouse are the device used last: after a gamepad button press or a stick pushed past half way the menus are as on the console, with no pointer, until the mouse moves or a key is pressed (`input_kbm_last` in `runtime/input.c`). The ability wheel, the d-pad strips, Autobuild and the Purah Pad's camera stay gameplay: the mouse keeps the camera there. The map has no focus box; it is found in `eui::ScreenMgr`'s list of open screens (every 100 ms: the Purah Pad's frame `AppMenuOverlay_00` with `AppMap_00` and the menu background `AppMenuBG_00`), and there the mouse moves the map's cursor as the left stick does, with the cursor still captured, and the scroll wheel zooms: each notch is a full-tilt push of the right stick (the map's zoom) for 100 ms with 50 ms of neutral after it, up (in) for a turn away from you; a fast scroll's notches wait their turn (at most four), a turn the other way drops them. The Scope opens the same map screen without the menu background and keeps the mouse camera. The Purah Pad's camera (the ability wheel's camera) opens the frame and its pointer `CameraPointer_00` without `AppMap_00` (the Scope has it); there the scroll wheel zooms as the camera's guide shows: each notch is a press of the d-pad's up (in, for a turn away from you) or down for 100 ms with 50 ms of release after it (`menu_cursor_camera`). The Scope itself has no zoom; the wheel does nothing there. When the menu closes the cursor is captured again.
`runtime/menu_cursor.c` reads eui's screens at each pad read and moves the focus with the writes `eui::BoxCursorMgr::moveBoxCursor` makes, so no game code is called. `menu_cursor = 0` (`TOTK_MENU_CURSOR=0`, live; the *Mouse in the game's menus* row of the Controls tab) turns it off; `TOTK_MENU_CURSOR_LOG=1` logs every screen it reads (by default the first six), with the layout size, the node count and the hit panes it uses.
### Left click on the map
With `map_click = 1` (off by default, so each key presses one controller button as everywhere else), on game 1.4.3, while the Purah Pad's map is open (found as above; the Scope is not the map), the left mouse button presses A at the map's cursor instead of the button it is bound to (Y by default). A press is A or the binding from the moment the button goes down until it is released, so a button held as the map opens or closes keeps what it pressed (`poll_merged` in `runtime/input.c`). `map_click = 1` (`TOTK_MAP_CLICK=1`, live; the *Left click on the map* row of the Controls tab) turns it on and `0`, the default, leaves the left button on its binding there. The map is found only while `menu_cursor` is on.
### Clicks in dialogue
With `dialogue_click = 1` (off by default, so each key presses one controller button as everywhere else), on game 1.4.3, while a dialogue box is open (the layout `MessageDialog_00`: a character's lines and the game's own messages), the left mouse button presses B and the right one A, instead of the buttons they are bound to. B continues the text as A does and also shows the rest of a line that is still scrolling in; the left button's default, Y, would open the dialogue log there, and the log stays in the way until B closes it. Dialogue choices are a menu with the focus box, so the pointer above takes their clicks and a left click is A on the choice under it: clicking through a conversation fast does not pick the choice the focus starts on. A press is the dialogue's button or the binding from the moment the button goes down until it is released: the click that closes the last box does not become an attack while it is still held, and a button held when the box opens does not skip its first line. Between two lines of a conversation the game closes the box and opens it again, so both buttons stay B and A for 500 ms after the box was last open (`DIALOGUE_GAP_MS`); the first clicks after a conversation fall in that time too, as they do for a player who taps the button through the last line. `TOTK_MENU_CURSOR_LOG=1` logs how long each such gap was. The dialogue window has no focus box of its own: the scan of `eui::ScreenMgr`'s open screens (every 100 ms) finds its screen, and from then on that screen's state is read at every pad read (`dialogue_shown` in `runtime/menu_cursor.c`), so the first click after a box opens is already the dialogue's. `dialogue_click = 1` (`TOTK_DIALOGUE_CLICK=1`, live; the *Clicks in dialogue* row of the Controls tab) turns it on and `0`, the default, leaves both buttons on their bindings; the setting does not depend on `menu_cursor`. The log names the first box it sees (`menu_cursor: a dialogue box is open ...`).
## Gameplay tweaks
With `gameplay_tweaks_enabled = 1` (`TOTK_GAMEPLAY_TWEAKS_ENABLED=1`, live; off by default in `totk.ini`), the mouse wheel and keyboard can drive common gameplay interactions directly:
- **Ultrahand object rotation**: turning the mouse wheel while Ultrahand holds an object rotates it directly without holding R or pressing the D-pad (`gameplay_ultrahand_rotate = 1`, sensitivity `gameplay_rotation_sensitivity = 1`). Holding C while scrolling rotates around the alternate axis (`gameplay_ultrahand_c_axis = 1`).
- **Ultrahand distance**: holding the right mouse button while scrolling pushes or pulls the held object closer or farther (`gameplay_ultrahand_distance = 1`, sensitivity `gameplay_distance_sensitivity = 1`).
- **Free-roam weapon switching**: scrolling the mouse wheel in free roam steps through equipped weapons (`gameplay_weapon_wheel = 1`, sensitivity `gameplay_weapon_sensitivity = 1`). Press E to confirm the chosen weapon; right click or pressing B cancels.
- **Quick-selection menus**: scrolling the mouse wheel browses items while a quick-selection menu (weapons, bows, shields, materials) is open (`gameplay_item_wheel = 1`, sensitivity `gameplay_item_sensitivity = 1`). A and D keys step left and right through the strip (`gameplay_item_ad = 1`).
- **Smooth map zoom**: the mouse wheel performs continuous inertial zooming on the Purah Pad map (`gameplay_map_zoom = 1`, sensitivity `gameplay_map_zoom_sensitivity = 1`).
All sub-toggles default to 1 and sensitivities to 1 (range 0.25 to 4.0), so enabling `gameplay_tweaks_enabled` activates the full suite immediately while allowing individual features to be toggled or tuned.
## Nintendo Switch 2 controllers
Windows does not present the Switch 2 Pro Controller as a gamepad SDL can open (the log says `input: no gamepad`), so it needs a bridge program that wakes it and creates a virtual gamepad. The DS4Windows fork by hbashton ([github.com/hbashton/DS4Windows](https://github.com/hbashton/DS4Windows), tested with release VIIPERRC4.5.1, a pre-release) with the output set to an emulated DualSense gives buttons, rumble, gyro and accelerometer, and reads the sticks through the controller's calibration (they rest at 0 to 2%). The game reads its virtual DualSense directly; the log then shows `input: gamepad "DualSense Wireless Controller" (rumble, gyro and accelerometer, ...)` and `input: motion sensors on`. Its release notes also list Joy-Con 2 support, which is untested here.
@@ -220,6 +242,8 @@ Bridges that output a ViGEm DualShock 4 (ProCon2Windows, connectyourpro as teste
@<ms> <button> [hold_ms] # timed on the world clock
@<ms> LSTICK|RSTICK <x> <y> [hold_ms]
@<ms> MOUSE <dx> <dy>
<frame> WHEEL <notches> # scroll wheel notches, once; + away from the player
@<ms> WHEEL <notches>
```
`<frame>` counts 60 Hz ticks of game time since the first frame (presented frames at 60 fps), so the title menus get the presses at the same game time at any frame limit. `@<ms>` counts milliseconds of the world clock: game time stepped since the end of the first save load (the player leaves the title screen's origin), so a timed event lands at the same game time at any frame rate and load length. A later load, such as fast travel, still shifts what follows. In a script with timed lines the untimed ones stop when the world clock starts, as the load ends at another tick in each run. Each event logs once (`input: script frame N tick T: A`). `tools/input/load_save.txt` loads the first save from the title screen.
+19 -8
View File
@@ -72,23 +72,34 @@ loads the saves 1.4.3 wrote.
`totk.exe --prepare-shaders`) in the install folder, then fold the shader cache's loose files (four per shader, about
117,000) into `shader-cache/shader-cache.pack` (`tools/pack_shader_cache.py`). totk.exe reads the pack first and
writes the translations it makes in play as loose files; running the tool again with the game closed folds those in.
The patches are written four times: `romfs-patches`, `romfs-patches-xbox` and `romfs-patches-xbox-label`
The patches are written three times: `romfs-patches`, `romfs-patches-xbox` and `romfs-patches-xbox-label`
(`--prompts`: Xbox button prompts for `prompts = xbox`, the first for `pad_layout = nintendo`, the second for `xbox`
and `auto`), and `romfs-patches-pc` (keyboard and mouse prompts for `prompts = pc`). Each of the three prompt
folders is then laid out once more for each game resolution of another shape, `romfs-patches-<style>-<w>x<h>`
(`--prompts <style> --aspect`). Those differ from `romfs-patches-<style>` in the UI archive only, and `--reuse`
hard-links the other files from it, so the forty-five folders take seconds and a few MiB each. The prompt folders are optional: when one cannot be made, the
setup warns and finishes.
and `auto`). The prompt folders are optional: when one cannot be made, the setup warns and finishes.
**PC prompts** (step `pc_prompts`): `romfs-patches-pc`, the keyboard and mouse prompts for `prompts = pc`, drawn
from the `bind_` lines of `totk.ini` (`--binds`). Its key holds those lines, so a setup run after a change of the
bindings draws only these again. Optional like the Xbox prompts. All four 16:9 folders are always written, so a
switch of the prompts style at 16:9 needs no setup run.
When the graphics driver crashes while building the shaders, `prepare_shaders.py` runs that part again without the
variants it was building ([building.md](building.md), step 6), and the setup finishes with a warning that names how
many were left out.
7. **DLSS** (the window's tick box, on by default, or `--dlss`; Windows with an NVIDIA RTX GPU): download
7. **Shapes**: the UI laid out for each screen shape this player needs, `romfs-patches-<w>x<h>`
(`--aspect`), and with Xbox or PC prompts in `totk.ini` that layout with those prompts too,
`romfs-patches-<style>-<w>x<h>` (`--prompts <style> --aspect --reuse romfs-patches-<style>`, which hard-links every
file but the UI archive; for `pc` with the same `--binds` as the PC prompts step, whose key the step follows). The shapes are those of every connected display (Windows: `EnumDisplayDevices`; Linux:
`xrandr`, else the DRM connectors), of the `output_res` the game defaults to on each, and of the `totk.ini`
`output_res` (`installer/screens.py`). One folder per shape, named after the shape's size in `ASPECT_SIZES` (the
closest within 1%; `5120x2160` uses `2560x1080`); `runtime/romfs.c` `overlay_init` maps the game resolution the
same way, and a folder of the exact size from an older setup still wins. A 16:9 player gets none. The step runs
again when the displays, the prompts or the patches change; at a game resolution whose shape has no folder the
game draws 16:9 with bars, and the settings menu marks such sizes and can write the shape's folders in the
background for the next start.
8. **DLSS** (the window's tick box, on by default, or `--dlss`; Windows with an NVIDIA RTX GPU): download
`nvngx_dlss.dll` from NVIDIA's own DLSS SDK repository (github.com/NVIDIA/DLSS, a pinned tag, NVIDIA RTX SDK
license) into the install folder and check its size and SHA-256 (`steps.py`, `Dlss`). The release does not ship
the library; NGX loads it from the folder of totk.exe for `dlaa` and the DLSS modes. A DLSS library already in the
folder (a newer one the player put there) is kept. Without an RTX GPU the step only logs and does nothing; a failed
download warns, the game runs without DLSS, and the next run of the setup tries again.
8. **Clean up** the temp folder, except the generated C and the objects (about 1.3 GB), and write
9. **Clean up** the temp folder, except the generated C and the objects (about 1.3 GB), and write
`build-cache/rebuild.txt` in the install folder.
A cancelled or failed setup resumes from the last finished step (`totk-install.json`).
+1 -1
View File
@@ -35,7 +35,7 @@ Source shorthands:
|---|---|---|---|---|
| 1.1 | **Colour target the fragment shader does not write keeps its old texel**, even with blending enabled. | Undefined value written/blended. | NXN: zero write mask and no blend for unwritten outputs (`reflection colors`). Already fixed here. | NXN; MNG `games/totk/tests/metal_semantics/probe.m:5` |
| 1.2 | **Unwritten vertex outputs read as (0, 0, 0, 1)** in the next stage, including the unwritten components of a partly written output (VS writes xyz, FS divides by w). | FS input with no VS output: interface mismatch, value undefined; an unwritten component of a written output is undefined (AMD: whatever the register holds, often 0). | Ryujinx initialises exactly the components the next stage reads, but only when stages are linked (`Translation/Translator.cs:212-227`, `NextInputAttributesComponents`); position starts (0,0,0,1) (`:259`). NXN Link's Awakening: sun shadow lookups divided by w = 0, scene dim, no shadows. Ours: missing outputs padded with (0, 0, 0, 1), unlinked outputs initialised by translator patch 0006 (section 7, check 2). | NXN |
| 1.3 | **Clears honour the scissor and the clear's own channel / stencil write mask**, and may come between draws inside a pass. `SET_CLEAR_SURFACE_CONTROL` (0x10f8) has `RESPECT_STENCIL_MASK`, `USE_CLEAR_RECT`, `USE_SCISSOR0`, `USE_VIEWPORT_CLIP0`. | `vkCmdClearAttachments` takes a rect but **ignores the colour write mask**; load-op clears are whole-attachment. | NXN/MNG draw a triangle with the clear's mask (`clear_color_tri`, `clear_ds_tri`); TotK uses mid-pass, partial-mask and partial-scissor clears (NXN). yuzu: "red dot" was clears hitting the wrong RT index (YZ-2305, PR 10243). Hardware recipe (DK3D): `CLEAR_BUFFERS` (`0x674` = 0x19d0) carries the colour channel mask (bits 2-5), depth (0), stencil (1), target id (6-9) and layer (10-20) in one word; `ClearBufferFlags` (`0x43E` = 0x10f8) is set once to `StencilMask | Scissor` (`maxwell/gpu_3d_base.cpp:69`), so every clear is cut by scissor 0 and its stencil bits by the stencil front write mask register, and DK3D's colour clear does not program `ColorWriteMask` (`0x680`). A stencil clear writes `StencilFrontMask` (`0x4E7`) and `ClearStencil` (`0x368`) just before the clear and restores the shadowed state after (`gpu_3d_base.cpp:497-510`). Multisample raster is switched off around a colour clear (`:459, :465`). Arrays: an MME macro repeats the clear for every layer (`maxwell/clear_buffers.mme:5-22`). No pass concept: clears sit between draws. Ours: masked colour and stencil clears are **skipped** (check 3). | OGD 0x10f8; NXN; DK3D `maxwell/gpu_3d_base.cpp:444-512`, `engine_3d.def:305, 644` |
| 1.3 | **Clears honour the scissor and the clear's own channel / stencil write mask**, and may come between draws inside a pass. `SET_CLEAR_SURFACE_CONTROL` (0x10f8) has `RESPECT_STENCIL_MASK`, `USE_CLEAR_RECT`, `USE_SCISSOR0`, `USE_VIEWPORT_CLIP0`. | `vkCmdClearAttachments` takes a rect but **ignores the colour write mask**; load-op clears are whole-attachment. | NXN/MNG draw a triangle with the clear's mask (`clear_color_tri`, `clear_ds_tri`); TotK uses mid-pass, partial-mask and partial-scissor clears (NXN). yuzu: "red dot" was clears hitting the wrong RT index (YZ-2305, PR 10243). Hardware recipe (DK3D): `CLEAR_BUFFERS` (`0x674` = 0x19d0) carries the colour channel mask (bits 2-5), depth (0), stencil (1), target id (6-9) and layer (10-20) in one word; `ClearBufferFlags` (`0x43E` = 0x10f8) is set once to `StencilMask \| Scissor` (`maxwell/gpu_3d_base.cpp:69`), so every clear is cut by scissor 0 and its stencil bits by the stencil front write mask register, and DK3D's colour clear does not program `ColorWriteMask` (`0x680`). A stencil clear writes `StencilFrontMask` (`0x4E7`) and `ClearStencil` (`0x368`) just before the clear and restores the shadowed state after (`gpu_3d_base.cpp:497-510`). Multisample raster is switched off around a colour clear (`:459, :465`). Arrays: an MME macro repeats the clear for every layer (`maxwell/clear_buffers.mme:5-22`). No pass concept: clears sit between draws. Ours: masked colour and stencil clears are **skipped** (check 3). | OGD 0x10f8; NXN; DK3D `maxwell/gpu_3d_base.cpp:444-512`, `engine_3d.def:305, 644` |
| 1.4 | **Conditional rendering** (`SET_RENDER_ENABLE_A..C` 0x1550-0x1558, NVN `SetRenderEnableConditional`) compares two 64-bit counters at `addr` and `addr+16` on the GPU, in command order. TotK wraps nearly every clear in it. A `TIMESTAMP` report writes 0 to the counter field. | `VK_EXT_conditional_rendering` tests one 32-bit word against zero. | NXN: honouring it fixed the black 3D scene (light-volume depth never cleared). deko3d has no conditional rendering at all (no `SET_RENDER_ENABLE` in `engine_3d.def`), so it cannot settle the compare rule. Ours: evaluated on the CPU at record time; a report from an unfinished submission counts as 0 (check 5). | OGD; NXN |
| 1.5 | **Depth mode** is runtime state: `nvnDeviceSetDepthMode` near = -w (GL, NVN default) or 0. Register `SET_VIEWPORT_Z_CLIP` (0x0d7c) `NEGATIVE_W_TO_POSITIVE_W` / `ZERO_TO_POSITIVE_W`. | Vulkan clips z < 0 unless `VK_EXT_depth_clip_control` `negativeOneToOne`. | Ryujinx infers the mode from the viewport transform, falling back to the register (`GetDepthMode`, RYU-SU). NXN: wrong mode either clips everything (black window) or puts all depth in 0.5..1 (DOF blurs the screen). Ours: `negativeOneToOne` from NVN state. DK3D programs both halves: `SetDepthMode` (`0x35F` = 0xd7c) selects the pre-transform clip range, and the viewport transform maps z to [near, far] itself: scale z = `0.5 * (far - near)` and offset z = `0.5 * (near + far)` for -1..1, scale `far - near` and offset `near` for 0..1 (`maxwell/gpu_3d_base.cpp:143-147, 336-343`). Same maths as Vulkan `negativeOneToOne`. | OGD 0x0d7c; NXN-64, NXN; DK3D `maxwell/gpu_3d_base.cpp:136-147, 321-362` |
| 1.6 | **Depth clamp / clip**: `SET_VIEWPORT_CLIP_CONTROL` (0x193c) has separate `PIXEL_MIN_Z`/`PIXEL_MAX_Z` CLIP or CLAMP and geometry-clip modes. | `depthClampEnable` also disables z clipping (unless `VK_EXT_depth_clip_enable`). RADV had a dynamic depth clamp driver bug causing TotK vertex explosions. | Ryujinx: clamp = `!(clip & DepthClampDisabled)` (RYU-SU `UpdateDepthClampState`). yuzu disabled dynamic depth clamp on affected RADV (YZ-2305, PR 10262). DK3D has one switch, `depthClampEnable`, and writes `VIEW_VOLUME_CLIP_CONTROL` (`0x64F` = 0x193c) with `0x101A` when on and `0x181D` when off (default at setup is `0x181D`); it labels the bits "todo: figure out what this actually does". Bits 3-4 (`DepthClampNear/Far`) are set in both values, bits 0-2 and 11 differ. There is no separate depth-clip toggle. The viewport near/far registers (`Viewport` array words 2-3) carry the clamp range and are swapped when far < near (`:349-350`). Vulkan clamp to [min, max] of the viewport depth matches. | OGD 0x193c; DK3D `maxwell/gpu_3d_state.cpp:42`, `gpu_3d_base.cpp:135-139, 349-350`, `engine_3d.def:621` |
+1 -1
View File
@@ -111,7 +111,7 @@ keeps its textures at a quarter of the size.
| On the Mods tab | Why | What to do |
|---|---|---|
| This folder has no romfs, exefs or cheats files. | The archive was unpacked one level too deep (`mods\Mod\Mod\romfs`), or it holds no game files. | Move the folders up so `romfs` sits directly in the mod's folder. |
| ... files are made for another game version and are left out. | The mod's files carry another update's version in their names (`.Product.<number>.`). | Download the mod's release for your game update. |
| ... files carry another game version in their names. | The files are named for another update (`.Product.<number>.`) and the game's own files have no such name. They are still served under those names, as on a console, because the game sometimes asks for one; another update's resource size table is the exception and only lends its entries. | Nothing if the mod works. If it does nothing, download its release for your game update. |
| Its code patches (exefs) are made for another game version. | The patch files name another update's build id. | Same: get the release for your update. |
| This mod brings its own game code (a subsdk plugin or a replaced main). | Mods such as UltraCam ship compiled Switch code. The port cannot load it. | No workaround; the whole mod stays off. |
| This mod patches the game code (exefs) in a way the port cannot apply. | The patch writes the game's data, not its code, or changes code in a form the port cannot build. | No workaround; the reason follows on the row. |
+41
View File
@@ -0,0 +1,41 @@
# Game 1.1.0 patch coverage
The built-in table is [recomp/patches-v110.txt](../recomp/patches-v110.txt). These sites were located in the local 1.1.0 main and checked against its original instruction words, rather than applying a version-wide address shift. The generator rejects a different word or an invalid spin back-edge.
## Added coverage
| Set | Sites added | Runtime control |
| --- | ---: | --- |
| realtime | 1 | Equipment-switch cooldown: step every positive remainder, including values below FLT_EPSILON. Follows the existing real-time clock switch. |
| cursor | 3 | Scale map panning, vertical ability aim and vertical gyro aim by the 30 Hz ratio; follows `TOTK_HIGHFPS_FIX`. |
| aspect | 4 | The two camera and two viewport projections read page +56. The resolution code enables it for non-16:9 output. |
| fov | 2 | The two camera projections multiply their vertical angle by page +60. The field-of-view setting is live; 100 leaves the original path. |
| pooloff | 2 | Widen texture-pool offsets unsigned, covering 2..4 GiB without changing offsets below 2 GiB. Enabled by default; `TOTK_POOL_OFFSET_PATCH=0` retains the original path. |
| shadow | 1 | The sun shadow map takes its fixed size from page +92 before rounding. The shadow-resolution setting enables it; `shadow_res=game` leaves the game's sizing. |
| cascade | 4 | Read the four sun shadow cascade defaults from page +64..76. Shadow range 100 leaves the original constructor. |
The table has 12 sets and 50 instruction sites in total. Its existing 889 spin back-edges are unchanged. The new sets use the existing runtime page and settings; no new setting, allocator or renderer path is introduced.
The camera sites were cross-checked by normalized instruction-window matching from the local 1.0.0 main. The viewport routine has two matching copies: both are patched. Other sites were checked through their data flow: the equipment timer and its gate, the map clock, the ability clock, the NVN texture storage/package calls, the shadow size publication and the cascade parameter constructor. FOV's s8 is overwritten by the next original instruction; x10 is saved. The cursor sites use the same scratch registers as their 1.2.1 counterparts.
## Deliberately separate
- Direct mouse: 1.1.0 continues to use stick emulation. Porting the complete camera hook set also needs the runtime layout and load-site table; matching an individual store or one camera mode is not sufficient. No partial set is enabled here.
- Fade: the four 1.4.3 sites are not presumed to exist in 1.1.0. An equivalent zero-increment path has not been established.
- Native Zstandard: the existing host bridge calls back to hard-coded 1.4.3 decoder entry points on fallback. Adding only the BL patches to 1.1.0 would be incorrect.
- Live DLSS scene sizing and game-menu mouse input retain their existing version restrictions. They are not patch-table parity work.
## Validation
Run with Python's numpy, lz4, capstone and unicorn dependencies and a runtime-supported Clang:
```sh
# CC selects the Clang used by the differential harness.
python tests/patches_v110_check.py
python tests/patches_v110_check.py --cflags=-march=x86-64-v2
python tests/patches_v110_check.py --exefs <local ExeFS directory>
```
Without ExeFS, the test uses synthetic memory and the patch table only. It compares the complete integer/SIMD register state, SP and NZCV of the lifted C and Unicorn for all 17 additions, on and off, at 30/60/120 Hz, including pool offsets immediately below and above 2 GiB and at the end of the 32-bit range. Windows test mappings respect its 64 KiB allocation granularity. With ExeFS it additionally validates every original word and spin target. Extracted images and generated C are local build artifacts, never repository content.
These checks establish instruction and code-generation contracts. World-scene visual acceptance, texture packs allocating a pool above 2 GiB, physical gyro and comparisons of shadow quality still require gameplay checks.
+1 -1
View File
@@ -75,7 +75,7 @@ A PR touching these needs stronger proof.
| #519, #582 amiibo | rewritten by us | took the data-format fixes; left out the features and the Linux event rework |
| #483 vs #585 | #585's mapping kept | #483's stick glyph mapping was rewritten unasked while #585 already had it right |
| #528 rain | taken after a check | code review fine, merged only after a run on a rain save |
| #767 | taken with our fix | the default was skipped with `prompts = xbox|pc` when those folders did not exist |
| #767 | taken with our fix | the default was skipped with `prompts = xbox\|pc` when those folders did not exist |
| #625 frame queue | taken, off by default | a new frame queue, one field run with it on |
| #743 UB overlay | waiting | +25% in a Depths fight on an RTX 4080; needs review, fight runs x2 and shots on AMD |
+5
View File
@@ -93,6 +93,7 @@ Many rows below are developer tools that only act together with another setting
| --- | --- | --- | --- |
| `amiibo_dir` | Folder the Amiibo tab starts in; the tab saves the folder you last browsed here. | Only changes which folder the tab lists first. | Safe |
| `exefs` | Folder of the game's ExeFS (with `main.npdm`); a relative path is relative to `totk.exe`'s folder. | Without it, an `exefs` folder next to `totk.exe` is used, else the path set at build time. The game code is compiled into `totk.exe`, and the loader checks the files here by SHA-256, so files from another build or game version stop the start with a message. | Caution |
| `menu_font_fontconfig` (default `1`) | On Linux, `1` asks fontconfig which font file draws each menu language's name, and `0` keeps the fixed distribution paths (`/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc` and four more). The menu merges that file into its font atlas. | `0` is for a system whose fontconfig resolves to a font the menu's parser cannot read; the log then says `menu: system font ... left out`. Has no effect on Windows, where the file names are fixed, and none on a language the ASCII font already draws. The atlas is rebuilt when the window size or the menu language changes. `TOTK_MENU_FONT` names a file directly and wins over both. | Safe |
| `mods_dir` (default `mods`) | Folder that holds one subfolder per player mod, beside `totk.exe`. | Mods found there replace game files; see `docs/mods.md`. | Caution |
| `mods_disabled` | Names of mods that are switched off, separated by `\|`. | Listed mods are not applied; the Mods tab writes this line. | Safe |
| `mods_order` | Mod names, top first, separated by `\|`; the top mod wins a file that two mods replace. | Changes which mod's file the game gets; unlisted mods go below the listed ones, by name. | Safe |
@@ -178,6 +179,7 @@ Many rows below are developer tools that only act together with another setting
| `mvprev_grow` (default `1`) | `0` keeps only three banks in the previous-frame tables. | Object motion that depends on the other banks is no longer tracked. | Caution |
| `mvprev_skip` | Hex bank mask of banks left out of the previous-frame copy, replacing the default. | Different banks are tracked, which changes object motion. | Caution |
| `mvprev_trust` | Hex bank mask of banks whose found previous-frame copy is taken without the check. | A copy that does not match is used anyway, which can give wrong motion. | Caution |
| `reflex` (default `off`) | `off`, `on`, or `boost`; enables NVIDIA Reflex Low Latency (`VK_NV_low_latency2`) to reduce system input latency. Read at start. | On NVIDIA GPUs supporting the extension, coordinates simulation and presentation cadence to lower latency; `boost` keeps GPU clocks high in CPU-bound scenes. Has no effect on non-NVIDIA GPUs. | Safe |
## Scheduling and host
@@ -207,9 +209,12 @@ These names are code patch sets built into the generated game code (`recomp/patc
| Setting | What it does | Effect of changing it | Safety |
| --- | --- | --- | --- |
| `ability_guard` (default `1`) | Patch set that checks the target a Recall or Ultrahand pick hands to the game (1.4.3 main+0x1bd01c4, 1.2.1 main+0x1622bf0) and drops it for that frame where the game's own code would fault on it: the holder, the actor or its component unreadable, or the word the game's reference writes not writable (`runtime/ov_ability.c`). Every other target goes on unchanged; a target that fails UltraTears' live-actor test is only logged (`ability: target kept although ...`). | `0` runs the game's code as shipped: the random crash reading `0xffffffffffffffff` during an ability pick can return. | Risky |
| `aspect_patch` (default `0`) | Patch set that feeds the camera the output's aspect ratio when it is not 16:9. | The resolution code switches this set on or off itself at start, so a value here is replaced; the code does not settle what a manual value does. | Unknown |
| `fixed_res_patch` (default `0`) | Patch set that holds the game's dynamic resolution at 100 percent (the scene tier). | The resolution code switches this set from `dynamic_res` (on at `0`); a manual value is replaced. | Unknown |
| `fov_patch` (default `0`) | Patch set that scales the camera's vertical view angle by the field-of-view setting. | The resolution code switches this set itself whenever the field of view is not 100 percent; a manual value is replaced. | Unknown |
| `mouse_direct_patch` (default `1`) | Patch set of the hooks in the game's camera code behind `mouse_mode = direct` on game 1.4.3. | `0` stops `mouse_mode = direct` from taking effect; other mouse modes are unaffected. | Safe |
| `optref_guard` (default `1`) | Patch set that treats a negative value in the optional reference at object +0x6b0 (1.4.3 main+0x1bd01c0, 1.2.1 main+0x1622bec) as absent instead of loading through it (#1005). | `0` runs the game's code as shipped: the random crash reading `0xffffffffffffffff` after minutes to hours of play can return. | Risky |
| `patch_output` (default `0`) | Patch set that makes the game use the configured output size for its swapchain and display configuration. | The resolution code switches this set whenever the output differs from the base size; a manual value is replaced. | Unknown |
| `patch_scene` (default `0`) | Patch set that makes the game use the configured scene render size. | The resolution code switches this set from the render size setting; a manual value is replaced. | Unknown |
| `report_guard` (default `1`) | Patch set on 1.4.3 only: in the model scene's report loop (main+0xa22d8, main+0xa2310) an object whose report handle is negative or whose row index is 0x8000 or more gets coverage 0 for that frame and its handle reset, the path the game takes after every read, instead of reading past the report rows. On valid rows the game's code runs unchanged. | `0` runs the game's code as shipped: a bad row index reads far past the rows and crashes, the class Weeping of the Empire met while using Ultrahand and aiming. | Risky |
+1 -1
View File
@@ -619,7 +619,7 @@ class App:
# ---- self test ---------------------------------------------------------------------------------------------------
SAMPLE_START = {'type': 'start', 'release': 'selftest', 'mode': 'install', 'dest': 'Z:/selftest/TotK', 'log': 'D:\\log.txt',
'steps': ['check', 'fonts', 'extract', 'lift', 'compile', 'prepare', 'dlss', 'cleanup']}
'steps': ['check', 'fonts', 'extract', 'lift', 'compile', 'prepare', 'pc_prompts', 'shapes', 'dlss', 'cleanup']}
SAMPLE_RUN = [
SAMPLE_START,
{'type': 'plan', 'run': ['check', 'fonts', 'extract'], 'skip': {}},
+1 -1
View File
@@ -27,7 +27,7 @@ TEXT = Path(__file__).resolve().parent / 'text'
UI_LANGUAGES = ('en', 'ru', 'pt-BR', 'zh-Hans')
# what the language switch in the window's corner shows for each
UI_LANGUAGE_LABELS = {'en': 'English', 'ru': 'Русский', 'pt-BR': 'Português (Brasil)', 'zh-Hans': '简体中文'}
STEP_ORDER = ('check', 'fonts', 'extract', 'lift', 'compile', 'prepare', 'dlss', 'cleanup')
STEP_ORDER = ('check', 'fonts', 'extract', 'lift', 'compile', 'prepare', 'pc_prompts', 'shapes', 'dlss', 'cleanup')
# message parameter -> catalog id prefix of the names that replace its raw values
PARAM_NAMES = {'lang': 'lang.', 'known': 'lang.', 'step': 'step.', 'input': 'param.input.'}
LANG_RU = 0x19 # primary language id of Russian in a Windows LANGID
+174
View File
@@ -0,0 +1,174 @@
"""The screen shapes and button prompts this player needs RomFS patch folders for (steps.Shapes).
A game resolution of another shape than 16:9 takes romfs-patches-<w>x<h>, the UI laid out for that shape
(tools/make_romfs_patches.py --aspect), and the prompts' folder of that shape (romfs-patches-<style>-<w>x<h>). The
layout depends only on the aspect ratio (tools/ultrawide_layout.py apply), so the setup writes one folder per shape,
named after the shape's size in ASPECT_SIZES (shape_size); runtime/romfs.c overlay_init maps the game resolution the
same way (cfg.c cfg_shape_size). It writes them only for the shapes of the connected displays and the totk.ini
output_res, and the prompts' ones only for the style totk.ini selects (prompts_style).
"""
import ctypes
import os
import re
import shutil
import subprocess
from pathlib import Path
# The game resolutions of another shape than 16:9 that runtime/ui/menu.cpp row_output_res lists, in the order of
# runtime/cfg.c SHAPED: 21:9 and 32:9 monitors, 16:10 screens (the Steam Deck's 1280x800, handhelds and laptops) and 3:2
# screens (Surface and Framework laptops and tablets)
ASPECT_SIZES = ('2560x1080', '3440x1440', '3840x1600', '5120x2160', '3840x1080', '5120x1440',
'1280x800', '1680x1050', '1920x1200', '2560x1600',
'1920x1280', '2160x1440', '2256x1504', '2880x1920', '3000x2000')
SHAPED = tuple(tuple(int(v) for v in s.split('x')) for s in ASPECT_SIZES)
TOLERANCE = 0.01 # cfg.c and resolution.c res_is_16x9: shapes within 1% are the same
def is_16x9(w, h):
return abs((w / h) / (16 / 9) - 1) <= TOLERANCE
def shape_size(w, h):
"""The folder size of w x h's shape: of ASPECT_SIZES within 1% of its aspect ratio, the closest, the first of equal
ones (5120x2160 is 2560x1080's shape). None for 16:9 and for a shape the setup has no layout for. The same rule as
runtime/cfg.c cfg_shape_size."""
if not w or not h or is_16x9(w, h):
return None
r, best, err = w / h, None, None
for sw, sh in SHAPED:
e = abs(sw / sh / r - 1)
if e <= TOLERANCE and (err is None or e < err):
best, err = f'{sw}x{sh}', e
return best
def default_size(w, h):
"""The output_res the game picks on a display of w x h while totk.ini sets none (runtime/cfg.c screen_default): of
ASPECT_SIZES within 1% of its shape, the smallest at least 1080 high that fits, else the largest that fits."""
if not w or not h or is_16x9(w, h):
return None
r, best, fit = w / h, None, None
for sw, sh in SHAPED:
if abs(sw / sh / r - 1) > TOLERANCE or sw > w or sh > h:
continue
if fit is None or sw > fit[0]:
fit = (sw, sh)
if sh >= 1080 and (best is None or sw < best[0]):
best = (sw, sh)
best = best or fit
return f'{best[0]}x{best[1]}' if best else None
# ---- the connected displays, as (width, height) of their current mode, the long side first (a portrait monitor or
# the Steam Deck's panel reports its height first; the game window is landscape)
class DISPLAY_DEVICEW(ctypes.Structure):
_fields_ = [('cb', ctypes.c_uint32), ('DeviceName', ctypes.c_wchar * 32), ('DeviceString', ctypes.c_wchar * 128),
('StateFlags', ctypes.c_uint32), ('DeviceID', ctypes.c_wchar * 128), ('DeviceKey', ctypes.c_wchar * 128)]
ATTACHED_TO_DESKTOP = 0x1
ENUM_CURRENT_SETTINGS = -1
DEVMODEW_SIZE = 220 # DEVMODEW: dmSize at 68, dmPelsWidth at 172, dmPelsHeight at 176
DEVMODE_PELS = 172
def windows_displays():
"""Every display attached to the desktop: EnumDisplayDevicesW over the adapters, EnumDisplaySettingsW for the
current mode, which is in pixels whatever the DPI awareness of this process."""
user32 = ctypes.WinDLL('user32')
out, i = [], 0
while True:
dev = DISPLAY_DEVICEW()
dev.cb = ctypes.sizeof(dev)
if not user32.EnumDisplayDevicesW(None, i, ctypes.byref(dev), 0):
break
i += 1
if not dev.StateFlags & ATTACHED_TO_DESKTOP:
continue
mode = ctypes.create_string_buffer(DEVMODEW_SIZE)
ctypes.c_uint16.from_buffer(mode, 68).value = DEVMODEW_SIZE
if user32.EnumDisplaySettingsW(dev.DeviceName, ENUM_CURRENT_SETTINGS, mode):
out.append((ctypes.c_uint32.from_buffer(mode, DEVMODE_PELS).value,
ctypes.c_uint32.from_buffer(mode, DEVMODE_PELS + 4).value))
return out
XRANDR = re.compile(r'\sconnected\s+(?:primary\s+)?(\d+)x(\d+)\+')
def linux_displays():
"""xrandr's connected outputs (X11 and XWayland); without xrandr the preferred mode of each connected DRM
connector."""
if shutil.which('xrandr'):
try:
text = subprocess.run(['xrandr', '--current'], capture_output=True, text=True, timeout=10).stdout
found = [(int(w), int(h)) for w, h in XRANDR.findall(text)]
if found:
return found
except (OSError, subprocess.SubprocessError):
pass
out = []
for conn in sorted(Path('/sys/class/drm').glob('card*-*')):
try:
if (conn / 'status').read_text().strip() != 'connected':
continue
m = re.match(r'(\d+)x(\d+)', (conn / 'modes').read_text())
except OSError:
continue
if m:
out.append((int(m.group(1)), int(m.group(2))))
return out
def displays():
try:
found = windows_displays() if os.name == 'nt' else linux_displays()
except (OSError, AttributeError, ValueError):
found = []
return sorted({(max(w, h), min(w, h)) for w, h in found if w and h})
# ---- totk.ini (runtime/cfg.c reads the same keys, in any section, with or without the totk_ prefix)
def ini_value(text, name):
value = None
for line in text.splitlines():
m = re.match(rf'^\s*(?:totk_)?{name}\s*=\s*([^\s#;]*)', line, re.IGNORECASE)
if m:
value = m.group(1)
return value
def prompts_style(text):
"""The prompts' folder suffix the settings select, as runtime/input_map.c input_prompts_pick and
input_prompts_folder pick it at start: 'pc', 'xbox' (Nintendo pad layout), 'xbox-label' (any other) or None for the
game's own prompts, the default without a totk.ini."""
p, layout = ini_value(text, 'prompts'), (ini_value(text, 'pad_layout') or '').lower()
if p and p.lower() == 'pc':
return 'pc'
if not (p.lower() == 'xbox' if p else layout == 'xbox_prompts'):
return None
return 'xbox' if layout in ('nintendo', 'xbox_prompts') else 'xbox-label'
def wanted(dest, screens=None):
"""(sizes, style): the shape sizes to write layouts for, sorted, and the prompts style. A shape is wanted for each
display's own size and for the output_res the game defaults to there, and for the totk.ini output_res."""
screens = displays() if screens is None else screens
try:
text = (Path(dest) / 'totk.ini').read_text(encoding='utf-8-sig', errors='replace')
except OSError:
text = ''
sizes = set()
for w, h in screens:
w, h = max(w, h), min(w, h)
sizes.add(shape_size(w, h))
d = default_size(w, h)
if d:
sizes.add(shape_size(*(int(v) for v in d.split('x'))))
m = re.fullmatch(r'(\d+)x(\d+)', (ini_value(text, 'output_res') or '').lower())
if m:
sizes.add(shape_size(int(m.group(1)), int(m.group(2))))
sizes.discard(None)
return sorted(sizes, key=ASPECT_SIZES.index), prompts_style(text)
+138 -43
View File
@@ -1,4 +1,5 @@
"""The eight setup steps of docs/installer.md: check, fonts, extract, lift, compile, prepare, dlss, cleanup.
"""The ten setup steps of docs/installer.md: check, fonts, extract, lift, compile, prepare, pc_prompts, shapes, dlss,
cleanup.
Extraction runs in this process through tools/extract.py (the package's sibling tools/, which ships with it); fonts
runs the vendored extract_shared_fonts.py on the firmware folder; lift, compile and prepare run the bundled Python on
@@ -8,8 +9,8 @@ with the bundled clang (hostcheck.c).
Install folder: exefs/, romfs/ (romfs.bin, index.json), profile/, shared-fonts/ (Chinese and Korean text), totk.exe
and its DLLs, nvngx_dlss.dll (with --dlss), romfs-index.bin, romfs-patches/, romfs-patches-xbox/,
romfs-patches-xbox-label/, romfs-patches-pc/, romfs-patches-<style>-<w>x<h>/ (each of the three for each shaped size),
totk_xlate.exe, the
romfs-patches-xbox-label/, romfs-patches-pc/, romfs-patches-<w>x<h>/ and romfs-patches-<style>-<w>x<h>/ (for the
screen shapes and the prompts style this player needs, installer/screens.py), totk_xlate.exe, the
shader state of totk.exe --prepare-shaders, totk.ini, totk-install.json.
Temp folder (<temp>/<dest name>-<hash>): check/ (ExeFS of both inputs, the host check), unpacked/ (the NSP of an NSZ
or XCZ input until the extraction is done), gen/ (C), build/ (objects), logs/. The cleanup keeps gen/, build/ and
@@ -36,7 +37,7 @@ import time
import urllib.request
from pathlib import Path
from . import ini
from . import ini, screens
from .layout import EXE, SUPPORTED, version_tag
from .runner import InstallError, Step
@@ -140,6 +141,17 @@ def linux_kernel():
return (int(m.group(1)), int(m.group(2))) if m else None
def link_output_locked(log):
"""Whether a build failed because another program holds the exe the linker writes: ld.lld cannot write it and clang
cannot remove it (Permission denied). A game started from the temp build folder does that, and so does an
antivirus that flagged or quarantined the new totk.exe there (#1122)."""
try:
text = Path(log).read_text(encoding='utf-8', errors='replace')
except OSError:
return False
return 'failed to write output' in text and 'Permission denied' in text
def run_tool(ctx, step, script, args, parse=None, cwd=None):
"""Run a tool script with the bundled Python. Its output goes to <temp>/logs/<step>-<script>.log and, line by line,
to parse(line). Returns (exit code, log path)."""
@@ -1009,6 +1021,8 @@ class Compile(Step):
'--exefs', dest / 'exefs', '--romfs', dest / 'romfs',
'--profile', dest / 'profile'], parse)
exe = build / ('totk' + EXE)
if code and link_output_locked(log):
raise InstallError('compile.exe_locked', path=str(exe), log=str(log))
if code or not exe.is_file():
raise InstallError('compile.failed', code=code, log=str(log))
try:
@@ -1029,12 +1043,7 @@ TRANSLATED = re.compile(r'gfx_shader: prepare: (\d+) of (\d+) pairs')
SKIPPED = re.compile(r'prepare-shaders: (\d+) variants skipped: the graphics driver crashed')
# The game resolutions of another shape than 16:9 that runtime/ui/menu.cpp row_output_res lists: 21:9 and 32:9 monitors,
# 16:10 screens (the Steam Deck's 1280x800, handhelds and laptops) and 3:2 screens (Surface and Framework laptops and
# tablets)
ASPECT_SIZES = ('2560x1080', '3440x1440', '3840x1600', '5120x2160', '3840x1080', '5120x1440',
'1280x800', '1680x1050', '1920x1200', '2560x1600',
'1920x1280', '2160x1440', '2256x1504', '2880x1920', '3000x2000')
ASPECT_SIZES = screens.ASPECT_SIZES
class Prepare(Step):
@@ -1084,24 +1093,14 @@ class Prepare(Step):
dest / 'romfs-patches'])
if code:
raise InstallError('prepare.romfs_patches_failed', code=code, log=str(log))
# The same overlay with the UI laid out for each game resolution of another shape the settings menu offers
# (runtime/romfs.c overlay_init picks the one that matches; the camera's side is the patch set aspect,
# recomp/patches-v<ver>.txt).
for size in ASPECT_SIZES:
remove(dest / f'romfs-patches-{size}')
code, log = run_tool(ctx, 'prepare', layout.tools / 'make_romfs_patches.py',
['--version', version_tag(game_version(ctx)), '--romfs', dest / 'romfs', '--out',
dest / f'romfs-patches-{size}', '--aspect', size])
if code:
raise InstallError('prepare.romfs_patches_failed', code=code, log=str(log))
# The same with Xbox button icons in the prompts, for prompts = xbox (make_romfs_patches.py --prompts):
# romfs-patches-xbox for the Nintendo pad layout, romfs-patches-xbox-label for xbox and auto (runtime/input_map.c
# input_prompts_folder). Both are written on every install, so the menu choices work without another run of
# the setup. Optional: when one fails, the game keeps the Switch prompts with that layout and the menu says the
# files are missing, so the setup warns once and goes on. romfs-patches-pc likewise, with keyboard and mouse
# prompts for prompts = pc.
# files are missing, so the setup warns once and goes on. The keyboard and mouse prompts are the PcPrompts
# step's: they follow totk.ini's bindings.
failed = None
for style in ('xbox', 'xbox-label', 'pc'):
for style in ('xbox', 'xbox-label'):
out = dest / f'romfs-patches-{style}'
remove(out)
code, log = run_tool(ctx, f'prepare-{style}', layout.tools / 'make_romfs_patches.py',
@@ -1110,25 +1109,6 @@ class Prepare(Step):
if code:
remove(out)
failed = failed or (code, log)
# Each prompts' folder once more for each shape of ASPECT_SIZES, romfs-patches-<style>-<w>x<h> with that
# shape's UI layout (--prompts <style> --aspect), which runtime/romfs.c overlay_init loads in place of
# romfs-patches-<w>x<h>: without it a player with Xbox or PC prompts on a screen that is not 16:9 chose between
# the prompts and the screen's shape. Only the Common archive differs from romfs-patches-<style>; --reuse links
# the fonts, messages and size table from there instead of compressing them again, so each folder takes
# seconds and a few MiB. Optional like romfs-patches-<style>, and skipped without it.
for style in ('xbox', 'xbox-label', 'pc'):
plain = dest / f'romfs-patches-{style}'
for size in ASPECT_SIZES:
out = dest / f'romfs-patches-{style}-{size}'
remove(out)
if not (plain / 'manifest.tsv').is_file():
continue
code, log = run_tool(ctx, f'prepare-{style}-{size}', layout.tools / 'make_romfs_patches.py',
['--version', version_tag(game_version(ctx)), '--romfs', dest / 'romfs', '--out',
out, '--prompts', style, '--aspect', size, '--reuse', plain])
if code:
remove(out)
failed = failed or (code, log)
if failed:
rep.warning('warn.xbox_prompts_failed', code=failed[0], log=str(failed[1]))
@@ -1167,6 +1147,121 @@ class Prepare(Step):
return {'xlate_sha256': file_sha256(xlate)}
# ---- 6b. Keyboard and mouse prompts
def bind_lines(dest):
"""The bind_ lines of the install's totk.ini (the Controls tab writes them), '' without the file."""
try:
text = (dest / 'totk.ini').read_text(encoding='utf-8', errors='replace')
except OSError:
return ''
return '\n'.join(s for s in (line.split('#')[0].split(';')[0].strip() for line in text.splitlines())
if s.lower().startswith('bind_'))
def pc_binds(dest):
"""make_romfs_patches.py's --binds argument for the keyboard and mouse prompts: totk.ini when it has bind_ lines."""
return ['--binds', dest / 'totk.ini'] if bind_lines(dest) else []
class PcPrompts(Step):
"""romfs-patches-pc (16:9), for prompts = pc: the prompts drawn as the keys and mouse buttons of totk.ini's bind_
lines (make_romfs_patches.py --prompts pc --binds), the keyboard defaults without them. Its own step, keyed by those
lines, so running the setup again after a change of the bindings draws the prompts again and leaves the shaders
alone. The shaped romfs-patches-pc-<w>x<h> are the Shapes step's, which follows this key. Optional like the Xbox
prompts: a failure warns, and the game keeps the Switch prompts."""
id = 'pc_prompts'
def key(self, ctx):
layout = ctx.layout
tools = [layout.tools / n for n in ('make_romfs_patches.py', 'ultrawide_layout.py', 'button_icons.py')]
return fingerprint('pc-prompts-1', ctx.keys['extract'], *tools, bind_lines(ctx.dest))
def current(self, ctx, record):
return record.get('failed') or (ctx.dest / 'romfs-patches-pc' / 'manifest.tsv').is_file()
def run(self, ctx):
layout, rep, dest = ctx.layout, ctx.reporter, ctx.dest
rep.progress('pc_prompts', 'draw', force=True)
plain = dest / 'romfs-patches-pc'
remove(plain)
code, log = run_tool(ctx, 'prepare-pc', layout.tools / 'make_romfs_patches.py',
['--version', version_tag(game_version(ctx)), '--romfs', dest / 'romfs', '--out', plain,
'--prompts', 'pc', *pc_binds(dest)])
if code:
remove(plain)
rep.warning('warn.xbox_prompts_failed', code=code, log=str(log))
return {'failed': True}
return {}
# ---- 6b. screen shapes
SHAPED_FOLDER = re.compile(r'^romfs-patches(?:-xbox|-xbox-label|-pc)?-\d+x\d+$')
class Shapes(Step):
"""romfs-patches-<w>x<h> (the UI laid out for a shape, make_romfs_patches.py --aspect) and, with Xbox or PC prompts
in totk.ini, romfs-patches-<style>-<w>x<h> (that layout with those prompts), for the shapes this player needs:
those of the connected displays and of the totk.ini output_res, one folder per shape (installer/screens.py; the
game maps its resolution to the folder in runtime/romfs.c overlay_init). A setup before this step wrote all 15
sizes for every prompts style, 64 folders. The key holds the shapes and the style, so a run of the setup after a
monitor or settings change (or its rebuild mode) writes only these again; the game's settings menu can also start
the generator for the shape in use (runtime/ui/menu.cpp row_output_res)."""
id = 'shapes'
def wanted(self, ctx):
if not hasattr(ctx, 'shapes_wanted'):
ctx.shapes_wanted = screens.wanted(ctx.dest)
return ctx.shapes_wanted
def key(self, ctx):
sizes, style = self.wanted(ctx)
# The pc prompts' shaped folders are drawn from the same bindings as romfs-patches-pc, so they follow its key
prompts = ctx.keys.get('pc_prompts', '') if style == 'pc' else ''
return fingerprint('shapes-2', ctx.keys.get('prepare', ''), prompts, style or 'nintendo', *sizes)
def current(self, ctx, record):
return all((ctx.dest / name / 'manifest.tsv').is_file() for name in record.get('folders', []))
def run(self, ctx):
layout, rep, dest = ctx.layout, ctx.reporter, ctx.dest
sizes, style = self.wanted(ctx)
rep.log(f'shapes: displays {screens.displays()}, layouts for {sizes or "none"}, prompts {style or "nintendo"}')
for old in dest.iterdir() if dest.is_dir() else ():
if old.is_dir() and SHAPED_FOLDER.match(old.name):
remove(old)
version = version_tag(game_version(ctx))
plain = dest / f'romfs-patches-{style}' if style else None
folders, failed = [], None
for i, size in enumerate(sizes):
rep.progress('shapes', 'layouts', i, len(sizes), 'shapes', force=True)
out = dest / f'romfs-patches-{size}'
code, log = run_tool(ctx, 'shapes', layout.tools / 'make_romfs_patches.py',
['--version', version, '--romfs', dest / 'romfs', '--out', out, '--aspect', size])
if code:
raise InstallError('prepare.romfs_patches_failed', code=code, log=str(log))
folders.append(out.name)
# Only the Common archive differs from romfs-patches-<style>: --reuse links the fonts, messages and size
# table from there. Optional like that folder: the game keeps the Switch prompts with this layout.
if not plain or not (plain / 'manifest.tsv').is_file():
continue
out = dest / f'romfs-patches-{style}-{size}'
code, log = run_tool(ctx, f'shapes-{style}', layout.tools / 'make_romfs_patches.py',
['--version', version, '--romfs', dest / 'romfs', '--out', out, '--prompts', style,
'--aspect', size, '--reuse', plain, *(pc_binds(dest) if style == 'pc' else ())])
if code:
remove(out)
failed = failed or (code, log)
else:
folders.append(out.name)
rep.progress('shapes', 'layouts', len(sizes), len(sizes), 'shapes', force=True)
if failed:
rep.warning('warn.xbox_prompts_failed', code=failed[0], log=str(failed[1]))
return {'folders': folders, 'sizes': sizes, 'style': style}
# ---- 7. NVIDIA DLSS
# NVIDIA's DLSS library, which NGX loads from the folder of totk.exe (runtime/vk_dlaa.c). The setup does not ship it:
@@ -1310,4 +1405,4 @@ def romfs_problem(romfs, expected):
def all_steps():
return [Check(), Fonts(), Extract(), Lift(), Compile(), Prepare(), Dlss(), Cleanup()]
return [Check(), Fonts(), Extract(), Lift(), Compile(), Prepare(), PcPrompts(), Shapes(), Dlss(), Cleanup()]
+5
View File
@@ -5,6 +5,8 @@
"step.lift": "Translating the game code to C",
"step.compile": "Compiling {game_exe}",
"step.prepare": "Preparing the shaders",
"step.pc_prompts": "Drawing the keyboard and mouse prompts",
"step.shapes": "Laying out the game screens for your displays",
"step.dlss": "Downloading NVIDIA DLSS",
"step.cleanup": "Cleaning up",
@@ -29,10 +31,12 @@
"phase.compile.compile": "Compiling",
"phase.compile.link": "Linking {game_exe}",
"phase.prepare.romfs_patches": "Writing the 60 fps game data patches",
"phase.pc_prompts.draw": "Drawing the keyboard and mouse button prompts from totk.ini's bindings",
"phase.prepare.seed": "Reading the shaders from the game data",
"phase.prepare.translate": "Translating the shaders",
"phase.prepare.libraries": "Building the shaders for the graphics driver",
"phase.prepare.pack": "Packing the shader cache into one file",
"phase.shapes.layouts": "Writing the screen layouts and button prompts for each display shape",
"phase.dlss.download": "Downloading nvngx_dlss.dll from NVIDIA's DLSS SDK",
"phase.cleanup.ini": "Writing totk.ini",
"phase.cleanup.temp": "Removing temporary files",
@@ -91,6 +95,7 @@
"lift.failed": "Translating the game code failed (exit code {code}). Details: {log}",
"compile.failed": "Compiling {game_exe} failed (exit code {code}). Details: {log}",
"compile.exe_in_use": "{path} is in use. Close the game and run the installer again.",
"compile.exe_locked": "{path} cannot be written: another program holds it, a game started from that folder or an antivirus that flagged the file. Close the game, add the setup's folder and the install folder to the antivirus exclusions, restart Windows, then run the installer again. Details: {log}",
"prepare.xlate_in_use": "{path} is in use. Close the game, end any totk_xlate process left from an earlier run, then run the installer again.",
"prepare.shader_list_missing": "The shader list is missing.",
"prepare.romfs_patches_failed": "Writing the game data patches failed (exit code {code}). Details: {log}",
+5
View File
@@ -5,6 +5,8 @@
"step.lift": "Traduzindo o código do jogo para C",
"step.compile": "Compilando o {game_exe}",
"step.prepare": "Preparando os shaders",
"step.pc_prompts": "Desenhando os ícones de teclado e mouse",
"step.shapes": "Ajustando as telas do jogo aos seus monitores",
"step.dlss": "Baixando o NVIDIA DLSS",
"step.cleanup": "Finalizando",
@@ -29,10 +31,12 @@
"phase.compile.compile": "Compilando",
"phase.compile.link": "Ligando o {game_exe}",
"phase.prepare.romfs_patches": "Gravando os patches de 60 fps nos dados do jogo",
"phase.pc_prompts.draw": "Desenhando os ícones de teclas e botões do mouse a partir das atribuições do totk.ini",
"phase.prepare.seed": "Lendo os shaders dos dados do jogo",
"phase.prepare.translate": "Traduzindo os shaders",
"phase.prepare.libraries": "Montando os shaders para o driver de vídeo",
"phase.prepare.pack": "Juntando o cache de shaders num único arquivo",
"phase.shapes.layouts": "Gravando os layouts de tela e os botões para cada formato de monitor",
"phase.dlss.download": "Baixando o nvngx_dlss.dll do DLSS SDK da NVIDIA",
"phase.cleanup.ini": "Gravando o totk.ini",
"phase.cleanup.temp": "Removendo os arquivos temporários",
@@ -91,6 +95,7 @@
"lift.failed": "Falha ao traduzir o código do jogo (código de saída {code}). Detalhes: {log}",
"compile.failed": "Falha ao compilar o {game_exe} (código de saída {code}). Detalhes: {log}",
"compile.exe_in_use": "{path} está em uso. Feche o jogo e execute o instalador de novo.",
"compile.exe_locked": "Não é possível gravar {path}: outro programa o está usando, um jogo aberto dessa pasta ou um antivírus que marcou o arquivo. Feche o jogo, adicione a pasta do instalador e a pasta de instalação às exceções do antivírus, reinicie o Windows e execute o instalador de novo. Detalhes: {log}",
"prepare.xlate_in_use": "{path} está em uso. Feche o jogo, encerre qualquer processo totk_xlate que tenha sobrado de uma execução anterior e execute o instalador de novo.",
"prepare.shader_list_missing": "A lista de shaders está faltando.",
"prepare.romfs_patches_failed": "Falha ao gravar os patches nos dados do jogo (código de saída {code}). Detalhes: {log}",
+5
View File
@@ -5,6 +5,8 @@
"step.lift": "Перевод кода игры в C",
"step.compile": "Сборка {game_exe}",
"step.prepare": "Подготовка шейдеров",
"step.pc_prompts": "Рисование подсказок клавиатуры и мыши",
"step.shapes": "Раскладка экранов игры под ваши мониторы",
"step.dlss": "Загрузка NVIDIA DLSS",
"step.cleanup": "Уборка",
@@ -29,10 +31,12 @@
"phase.compile.compile": "Компиляция",
"phase.compile.link": "Компоновка {game_exe}",
"phase.prepare.romfs_patches": "Запись патчей данных игры для 60 кадров/с",
"phase.pc_prompts.draw": "Рисование подсказок клавиш и кнопок мыши по назначениям из totk.ini",
"phase.prepare.seed": "Чтение шейдеров из данных игры",
"phase.prepare.translate": "Трансляция шейдеров",
"phase.prepare.libraries": "Сборка шейдеров для драйвера видеокарты",
"phase.prepare.pack": "Упаковка кэша шейдеров в один файл",
"phase.shapes.layouts": "Запись раскладок экрана и кнопок для каждой формы монитора",
"phase.dlss.download": "Загрузка nvngx_dlss.dll из DLSS SDK от NVIDIA",
"phase.cleanup.ini": "Запись totk.ini",
"phase.cleanup.temp": "Удаление временных файлов",
@@ -91,6 +95,7 @@
"lift.failed": "Не удалось перевести код игры (код выхода {code}). Подробности: {log}",
"compile.failed": "Не удалось собрать {game_exe} (код выхода {code}). Подробности: {log}",
"compile.exe_in_use": "Файл {path} занят. Закройте игру и запустите установку снова.",
"compile.exe_locked": "Файл {path} не удаётся записать: его держит другая программа — игра, запущенная из этой папки, или антивирус, который пометил файл. Закройте игру, добавьте папку установщика и папку установки в исключения антивируса, перезагрузите Windows и запустите установку снова. Подробности: {log}",
"prepare.xlate_in_use": "Файл {path} занят. Закройте игру, завершите процесс totk_xlate, оставшийся от прошлого запуска, и запустите установку снова.",
"prepare.shader_list_missing": "Нет списка шейдеров.",
"prepare.romfs_patches_failed": "Не удалось записать патчи данных игры (код выхода {code}). Подробности: {log}",
+5
View File
@@ -5,6 +5,8 @@
"step.lift": "将游戏代码转换为 C 代码",
"step.compile": "编译 {game_exe}",
"step.prepare": "准备着色器",
"step.pc_prompts": "绘制键盘和鼠标按键提示",
"step.shapes": "为你的显示器调整游戏画面布局",
"step.dlss": "下载 NVIDIA DLSS",
"step.cleanup": "清理",
@@ -29,10 +31,12 @@
"phase.compile.compile": "编译",
"phase.compile.link": "链接 {game_exe}",
"phase.prepare.romfs_patches": "写入 60 帧游戏数据补丁",
"phase.pc_prompts.draw": "根据 totk.ini 中的按键绑定绘制键盘和鼠标按键提示",
"phase.prepare.seed": "从游戏数据中读取着色器",
"phase.prepare.translate": "转译着色器",
"phase.prepare.libraries": "为显卡驱动构建着色器",
"phase.prepare.pack": "将着色器缓存打包成一个文件",
"phase.shapes.layouts": "为每种显示器比例写入画面布局和按键提示",
"phase.dlss.download": "从 NVIDIA 的 DLSS SDK 下载 nvngx_dlss.dll",
"phase.cleanup.ini": "写入 totk.ini",
"phase.cleanup.temp": "删除临时文件",
@@ -91,6 +95,7 @@
"lift.failed": "游戏代码转换失败(退出代码 {code})。详情:{log}",
"compile.failed": "编译 {game_exe} 失败(退出代码 {code})。详情:{log}",
"compile.exe_in_use": "{path} 正在使用中。请关闭游戏后重新运行安装程序。",
"compile.exe_locked": "无法写入 {path}:另一个程序正在占用它,可能是从该文件夹启动的游戏,或标记了该文件的杀毒软件。请关闭游戏,将安装程序文件夹和安装文件夹加入杀毒软件的排除项,重启 Windows,然后重新运行安装程序。详情:{log}",
"prepare.xlate_in_use": "{path} 正在被占用。请关闭游戏,结束上次残留的 totk_xlate 进程,再重新运行安装程序。",
"prepare.shader_list_missing": "缺少着色器列表。",
"prepare.romfs_patches_failed": "写入游戏数据补丁失败(退出代码 {code})。详情:{log}",
+46
View File
@@ -10,6 +10,8 @@ set cloth TOTK_CLOTH_REALTIME 1
set bounce TOTK_HIGHFPS_FIX 1
set output TOTK_PATCH_OUTPUT 0
set scene TOTK_PATCH_SCENE 0
set shadow TOTK_PATCH_SHADOW 0
set cascade TOTK_PATCH_CASCADE 0
# 60 fps: the adaptive present-interval controller (main+0x8f26c8, 1.0.0 0x8f6bec) gets the minimum interval 1.
site fps60 main 90e978 6b08015f 7100055f # clamp: cmp w10, #1 (was cmp w10, w8 = minimum)
@@ -66,6 +68,50 @@ site scene main cea5e0 5e21d900 @page:x9 # scvtf s0, s8 -> adrp x9, page
site scene main cea5e8 bd0cc660 2d420520 # str s0, [x19, #0xcc4] -> ldp s0, s1, [x9, #16]
site scene main cea5ec 5e21d921 bd0cc660 # scvtf s1, s9 -> str s0, [x19, #0xcc4]
# Equipment-switch cooldown (issue #18): the player update tests state +0x109c against FLT_EPSILON,
# while the equipment gate (main+0x7f0134) blocks changes above zero. Step every positive remainder through
# main+0xa26bb0, including (0, FLT_EPSILON], so a measured frame ratio cannot leave equipment locked.
site realtime main a20518 1e270101 1e2703e1 # fmov s1, w8 (FLT_EPSILON) -> fmov s1, wzr
# Cursor and aim steps (MacNativeGames game_patches.c patch_cursor_speed, 363a6eb): use the same 30 Hz ratio
# already read by these updates for smoothing. x9 / s16 are scratch at the map site; x20 holds the aim clock.
set cursor TOTK_HIGHFPS_FIX 1
site cursor main f31e80 bd400361 f94002e9 bd400930 1e300800 bd400361 # map pan s0 *= [[x23] + 8]
site cursor main 1d55f24 1e2a198c 1e2a198c bd400a90 1e30098c # vertical ability aim s12 *= [x20 + 8]
site cursor main 1d556a4 1e200923 1e200923 bd400a90 1e300863 # vertical gyro aim s3 *= [x20 + 8]
# Camera aspect (Hor+): two camera projection updates and the two copies of the viewport projection routine.
# The camera sites were matched against 1.0.0 by instruction windows; both viewport copies match the same
# 193-word normalized window. Page +56 is set by runtime/resolution.c. Save x10 instead of assuming it dead.
set aspect TOTK_ASPECT_PATCH 0
site aspect main cdbf30 bd414260 f81f0fea @page:x10 bd403940 f84107ea
site aspect main 1261a64 bd414260 f81f0fea @page:x10 bd403940 f84107ea
site aspect main 19c2260 1e211800 f81f0fea @page:x10 bd403940 f84107ea
site aspect main 1ed8fa4 1e211800 f81f0fea @page:x10 bd403940 f84107ea
# Field of view: load the camera's vertical angle as before and multiply by page +60. The following projection
# setup overwrites s8 before reading it; s1 (the half-angle multiplier) stays intact. x10 is saved on the stack.
set fov TOTK_FOV_PATCH 0
site fov main cdbef8 bd413e60 f81f0fea @page:x10 bd413e60 bd403d48 1e280800 f84107ea
site fov main 1261a2c bd413e60 f81f0fea @page:x10 bd413e60 bd403d48 1e280800 f84107ea
# Texture pool offsets above 2 GiB (MacNativeGames game_patches.c patch_pool_offset, ca311e2d): the loader
# passes w25 to SetStorage and SetPackagedTextureData. Widen unsigned to cover the complete 32-bit pool offset.
set pooloff TOTK_POOL_OFFSET_PATCH 1
site pooloff main 9b93a8 93407f22 2a1903e2
site pooloff main 9b93c4 8b39c101 8b394101
# Sun shadow map: the size rounded here is used for width (+0x3d8), height (+0x3f8) and viewport together.
# runtime/resolution.c shadow_init supplies the fixed size at page +92; the default remains the game's size.
site shadow main d0760c 11001d6b @page:x11 b9405d6b 11001d6b
# Sun shadow cascade parameter defaults: depth_shadow_near_0_1..3 and depth_shadow_far_0. The constructor
# stores 20, 40, 80 and 160 metres; runtime/resolution.c res_shadow_range supplies page +64..+76.
site cascade main 1157fb8 52a83408 @page:x8 b9404108
site cascade main 1158040 52a84408 @page:x8 b9404508
site cascade main 11580c8 52a85408 @page:x8 b9404908
site cascade main 115814c 52a86408 @page:x8 b9404d08
# Spin waits, from tools/spin_waits.py --exefs build/extracted/v110/exefs --patches recomp/patches-v110.txt: loops that only
# another thread can end; their back-edges pass rt_spin_gate (runtime/kernel.c), TOTK_SPIN=0 keeps the core.
+25
View File
@@ -10,6 +10,7 @@ set bounce TOTK_HIGHFPS_FIX 1
set output TOTK_PATCH_OUTPUT 0
set scene TOTK_PATCH_SCENE 0
set shadow TOTK_PATCH_SHADOW 0
set grass TOTK_PATCH_GRASS 0
# 60 fps: the adaptive present-interval controller (main+0x8f26c8, 1.0.0 0x8f6bec) gets the minimum interval 1.
site fps60 main 8f273c 6b08015f 7100055f # clamp: cmp w10, #1 (was cmp w10, w8 = minimum)
@@ -1115,3 +1116,27 @@ spin sdk 3d3250 3d3270 # 9 instructions; loads
# goes in just before the rounding, as the community's shadow resolution mods do (1.1.0: mov w11, #1024 over the
# computation). Found by a write watch on the size field (the writer was this function, and no other).
site shadow main cec22c 11001d6b @page:x11 b9405d6b 11001d6b # add w11, w11, #7 -> adrp x11, page; ldr w11, [x11, #92]; add w11, w11, #7
# Grass range (runtime/resolution.c res_grass_range; patches-v143.txt describes the set and the page). The near grass
# map's constructor loads its extent, step and texture sizes at main+0xfe58b4..0xfe5950, and main+0x1a30a28 sets the
# extent to 62.5 or 31.25 m, as on 1.4.3.
site grass main fe58b4 52a84f48 @page:x8 b9408108 # mov w8, #62.5 -> ldr w8, [page+128]
site grass main fe58c0 52a80f48 @page:x8 b9408508 # mov w8, #3.90625 -> ldr w8, [page+132]
site grass main fe58ec 52802002 @page:x2 b9408842 # mov w2, #0x100 -> ldr w2, [page+136]
site grass main fe5950 52801002 @page:x2 b9408c42 # mov w2, #0x80 -> ldr w2, [page+140]
site grass main 1a30a8c 52a84f48 @page:x8 b9408108 # mov w8, #62.5 -> ldr w8, [page+128]
site grass main 1a30a98 52a83f48 @page:x8 b9409108 # mov w8, #31.25 -> ldr w8, [page+144]
# Optional reference with an invalid value (#1005). The same guard as set optref in patches-v143.txt (main+0x1bd01c0),
# here for 1.2.1's main+0x1622bec: ldr x8, [x19, #0x6b0]; cbz x8; ldr x21, [x8]. A negative value counts as absent.
# x8 and x9 are dead at the branch target 0x1622c1c, which loads x8 again.
set optref TOTK_OPTREF_GUARD 1
site optref main 1622bec b4000188 937ffd09 8a290108 b4000188 # cbz x8 -> asr x9, x8, #63; bic x8, x8, x9; cbz x8
# Recall and Ultrahand target that is stale memory: set ability in patches-v143.txt, here for 1.2.1's main+0x1622bf0
# (function main+0x1622b60; the callees main+0x809ecc, 0x842aa4 and 0x842d10 read the same actor offsets). The model
# scene report-row guard (set report there) has no 1.2.1 site: this version does not have that loop's code shape.
set ability TOTK_ABILITY_GUARD 1
site ability main 1622bf0 f9400115 94c424dc # ldr x21, [x8] -> bl page+0xf60
site ability main 1622bf4 b4000155 aa0903f5 b4000155 # cbz x21 -> mov x21, x9; cbz x21 (x9 dead after it)
+53
View File
@@ -12,6 +12,7 @@ set output TOTK_PATCH_OUTPUT 0
set scene TOTK_PATCH_SCENE 0
set shadow TOTK_PATCH_SHADOW 0
set cascade TOTK_PATCH_CASCADE 0
set grass TOTK_PATCH_GRASS 0
# 60 fps: the adaptive present-interval controller (main+0x2db174, 1.2.1 0x8f26c8) gets the minimum interval 1.
site fps60 main 2db204 6b08015f 7100055f # clamp: cmp w10, #1 (was cmp w10, w8 = minimum)
@@ -1102,3 +1103,55 @@ site cascade main 6fad4c 52a86408 @page:x8 b9404d08 # mov w8, #160.0 -> ldr w8
# switches the set off without the real-time step, where the page is not written.
set climb TOTK_CLIMB_FIX 1
site climb main 1f497f4 1e201001 @page:x8 bd400104 1e286884 52946dc8 72a7e528 1e270102 1e241842 52828248 72a7dfe8 1e270103 1e232842 529573e8 72a7b5a8 1e270103 1f040862 1e2a3883 2f00e404 1e246863 1e261004 1f048862 1e241004 1e247842 1e226800 1e201001 1e226821 # fmov s1, #2.0 -> s2 = g(u); s0 = max(s0, s2); s1 = max(2.0, s2)
# Grass range (runtime/resolution.c res_grass_range switches the set on). Grass blades grow from the near grass map, a
# square texture the game draws around the camera (GrassShader.sharcb). Its constructor (main+0xa38e58) gives it a
# 62.5 m extent, a 3.90625 m step (1/16 of it) and 256x256 and 128x128 textures; main+0x206340c later sets the extent
# to 62.5 or 31.25 m. With the set on all of them come from page +128..+144, scaled together so the map keeps its
# texels per metre; resolution.c grows the grass heap of the HeapDef for the larger textures.
site grass main a38e58 52a84f48 @page:x8 b9408108 # mov w8, #62.5 -> ldr w8, [page+128]
site grass main a38e64 52a80f48 @page:x8 b9408508 # mov w8, #3.90625 -> ldr w8, [page+132]
site grass main a38e94 52802002 @page:x2 b9408842 # mov w2, #0x100 -> ldr w2, [page+136]
site grass main a38ef4 52801002 @page:x2 b9408c42 # mov w2, #0x80 -> ldr w2, [page+140]
site grass main 2063454 52a84f48 @page:x8 b9408108 # mov w8, #62.5 -> ldr w8, [page+128]
site grass main 2063460 52a83f48 @page:x8 b9409108 # mov w8, #31.25 -> ldr w8, [page+144]
# Optional reference with an invalid value (#1005). main+0x1bd0138 reads an optional reference at object +0x6b0 (null or
# a holder whose first word is the target, bit 0 a tag) and checks it only for null: ldr x8, [x19, #0x6b0]; cbz x8;
# ldr x21, [x8]. Players' crash reports show the field holding 0xffffffffffffffff after minutes to hours of play, and
# the load of the holder faults. MacNativeGames (games/totk/runtime/loader.c, crash) met the same field holding
# 0xffff0000ffffffff during a save load and treats the reference as absent there. Every valid holder is a heap address
# below 2^63, so the cbz becomes a test for null or negative: x9 = x8 >> 63 (arithmetic, all ones when negative),
# x8 &= ~x9, cbz x8. Both x8 and x9 are dead at the branch target 0x1bd01f0, which loads x8 again and writes x9 before
# any read; on the fall-through path x8 is unchanged.
set optref TOTK_OPTREF_GUARD 1
site optref main 1bd01c0 b4000188 937ffd09 8a290108 b4000188 # cbz x8 -> asr x9, x8, #63; bic x8, x8, x9; cbz x8
# Recall and Ultrahand target that is stale memory. The same function reads the target actor from the holder
# (ldr x21, [x8]) and follows it into main+0x155ec, main+0x9a89d4 and main+0x2b8464 (an atomic write at +0x90). The
# holder can be reused memory by then, so the actor points into .rodata, outside the address space or at other heap
# data, and the game crashes reading 0xffffffffffffffff. UltraTears (kuraeow/ultratears, ability target guard) found
# the class. The load becomes a call to runtime/ov_ability.c host_ability_target (page+0xf60): x21 is the holder's
# first word, or 0 where the game's own code would fault on the target (holder, actor or component unreadable, the
# reference word not writable), which the game's cbz x21 skips for this frame. Every other target goes on unchanged.
# The answer comes back in x9 and the cbz site moves it to x21: the lifted code keeps x21 (callee-saved) in a C local
# across the call. x9 is dead after 0x1bd01c8 on every path (written or clobbered by a bl before any read); x30 is saved by the
# prologue and clobbered by the next bl anyway.
set ability TOTK_ABILITY_GUARD 1
site ability main 1bd01c4 f9400115 947c3f67 # ldr x21, [x8] -> bl page+0xf60
site ability main 1bd01c8 b4000155 aa0903f5 b4000155 # cbz x21 -> mov x21, x9; cbz x21
# Model scene report rows (WoE, daniel-madrid-07/weeping-of-the-empire, MIT, games/totk/patches/sites_v143.py
# reportguard; their #52 and #73: crashes while using Ultrahand and aiming). gsys::ModelScene::calcGPU_ is inlined in
# main+0xa1f84; its per-object loop (0xa22bc..0xa234c) takes the object's report handle h (int16 at obj+0x98 + 2 * side),
# exits for -1 only, reads row 2h+1 and then u32 n from row 2h, and follows n to row 2n with no bound (WoE's crash had
# n = the float 0.05, a read 32 GB past the rows). n indexes a row pair as h does, so a valid one is below 0x8000.
# A negative h (other than -1) or n >= 0x8000 goes to 0xa2340, where the game resets the handle to -1 after every use:
# the object has coverage 0 this frame (stored at 0xa22cc) and the game asks for a new report, as after a normal read.
# WoE's veneers exit at 0xa2344 instead, which keeps the bad handle for the next frames. No flags change; w4 is never
# used in main+0xa1f84; x1, x16, x15 and w13, which 0xa2340 reads, hold what they hold on the game's own path there.
set report TOTK_REPORT_GUARD 1
site report main a22d8 2a010571 2a010571 37f80341 # orr w17, w11, w1, lsl #1; tbnz w1, #31, 0xa2340
site report main a2310 531f7821 530f7c24 531f7821 35000184 # lsr w4, w1, #15; lsl w1, w1, #1; cbnz w4, 0xa2340
+289
View File
@@ -0,0 +1,289 @@
// Sound categories (music, effects, voices) for the volume_music / volume_sfx / volume_voice settings.
//
// The audio renderer only sees sample memory, so the category is learned where the game loads its sounds:
// - RomFS opens and reads of Sound/Resource/ files (romfs.c romfs_open / romfs_read): the file name gives the
// category (BGM_* music, NV_* and *_Vo_* / *Voice* voices, the rest effects);
// - zstd decodes of BARS banks (ov_zstd.c decode): each bank entry's AMTA name refines the bank's category;
// - Opus decodes (ov_media.c ov_decode): the decoded PCM inherits the category of the packet it came from.
// Two tables answer the mixer (audio_mixer.c voice_category):
// - DSP-ADPCM coefficient tables, by a hash of their 32 bytes, read from each BWAV channel header. The game copies
// these coefficients next to the voice, so a voice's own table names its sound wherever its samples live;
// - guest address ranges of loaded or decoded audio, newest first, for PCM voices (Opus output).
// Everything here runs only while one of the three settings is below 100 (audio_cat_active): at the defaults no table
// is written or read. A setting moved during play classifies what loads from then on; sounds loaded before (an area's
// effect banks, a stream opened earlier) are found when their next stream read lands, otherwise they count as effects.
#include "audio_cat.h"
#include "cfg.h"
#include "host.h"
#include "platform/platform.h"
#include <stdatomic.h>
#include <string.h>
#include <strings.h>
#define RANGE_CAP 4096 // address ranges, a ring: the oldest go first. Lookups scan it, so it stays small
#define COEF_CAP 65536 // coefficient tables, open addressing; a full probe run drops the new table (it counts as SFX)
#define COEF_PROBES 64
typedef struct {
uint64_t start, end;
uint8_t cat;
} Range;
static Range ranges[RANGE_CAP];
static uint32_t range_head; // ranges written so far; under range_lock
static PlatMutex range_lock = PLAT_MUTEX_INIT;
typedef struct {
_Atomic uint64_t hash; // 0 = free; a slot is claimed once and never freed
_Atomic uint8_t cat;
} Coef;
static Coef coefs[COEF_CAP];
typedef struct {
uint64_t guest;
uint8_t cat;
} Decoder;
static Decoder decoders[64]; // the category each Opus decoder produced last; under decoder_lock
static unsigned decoder_next;
static PlatMutex decoder_lock = PLAT_MUTEX_INIT;
static _Atomic uint64_t coef_count[4], range_count, bars_count;
int audio_cat_active(void) {
static _Atomic unsigned seen = ~0u;
static _Atomic int on;
unsigned ver = cfg_version();
if (atomic_load_explicit(&seen, memory_order_acquire) != ver) {
int a = cfg_double("TOTK_VOLUME_MUSIC") < 100 || cfg_double("TOTK_VOLUME_SFX") < 100 ||
cfg_double("TOTK_VOLUME_VOICE") < 100;
atomic_store_explicit(&on, a, memory_order_relaxed);
atomic_store_explicit(&seen, ver, memory_order_release);
}
return atomic_load_explicit(&on, memory_order_relaxed);
}
static int ci_str_has(const char *haystack, const char *needle) {
size_t nlen = strlen(needle);
for (; *haystack; haystack++)
if (strncasecmp(haystack, needle, nlen) == 0) return 1;
return 0;
}
static int all_zero32(const uint8_t *p) {
for (int i = 0; i < 32; i++)
if (p[i]) return 0;
return 1;
}
static uint64_t fnv1a32(const uint8_t *p) {
uint64_t h = 14695981039346656037ULL;
for (int i = 0; i < 32; i++) {
h ^= p[i];
h *= 1099511628211ULL;
}
return h ? h : 1;
}
// A table seen under several categories keeps music or voice over effects: one sample shared by a voice line and an
// effect bank follows the voice setting.
static void register_coef32(const uint8_t *coef, int cat) {
if (cat <= AUDIO_CAT_UNKNOWN || cat > AUDIO_CAT_VOICE || all_zero32(coef)) return;
uint64_t h = fnv1a32(coef);
for (uint32_t step = 0; step < COEF_PROBES; step++) {
Coef *e = &coefs[((uint32_t)h + step) & (COEF_CAP - 1)];
uint64_t cur = atomic_load_explicit(&e->hash, memory_order_acquire);
if (cur == 0 && atomic_compare_exchange_strong_explicit(&e->hash, &cur, h, memory_order_acq_rel,
memory_order_acquire)) {
atomic_store_explicit(&e->cat, (uint8_t)cat, memory_order_release);
atomic_fetch_add_explicit(&coef_count[cat], 1, memory_order_relaxed);
return;
}
if (cur == h) {
if (cat != AUDIO_CAT_SFX) atomic_store_explicit(&e->cat, (uint8_t)cat, memory_order_release);
return;
}
}
}
int audio_cat_lookup_coef(uint64_t extra_addr, uint64_t extra_size) {
if (!extra_addr || extra_size < 32 || extra_addr >= RT_ADDRESS_LIMIT || !mem_guest_readable(extra_addr, 32))
return AUDIO_CAT_UNKNOWN;
const uint8_t *p = (const uint8_t *)(uintptr_t)extra_addr;
if (all_zero32(p)) return AUDIO_CAT_UNKNOWN;
uint64_t h = fnv1a32(p);
for (uint32_t step = 0; step < COEF_PROBES; step++) {
Coef *e = &coefs[((uint32_t)h + step) & (COEF_CAP - 1)];
uint64_t cur = atomic_load_explicit(&e->hash, memory_order_acquire);
if (cur == h) return atomic_load_explicit(&e->cat, memory_order_acquire); // 0 while the writer is midway
if (cur == 0) break;
}
return AUDIO_CAT_UNKNOWN;
}
// BWAV: "BWAV", channel count at 0x0E, then 0x4C-byte channel infos from 0x10: codec u16 (1 = DSP-ADPCM) and the 16
// ADPCM coefficients at +0x10.
void audio_cat_scan_bwav(const void *data, uint64_t size, int cat) {
if (!data || size < 0x40 || cat <= AUDIO_CAT_UNKNOWN) return;
const uint8_t *b = data;
uint32_t magic;
uint16_t nch;
memcpy(&magic, b, 4);
memcpy(&nch, b + 0x0E, 2);
if (magic != 0x56415742u || nch == 0 || nch > 16) return;
for (uint16_t ch = 0; ch < nch; ch++) {
uint64_t at = 0x10ull + ch * 0x4Cull;
if (at + 0x30 > size) break;
uint16_t codec;
memcpy(&codec, b + at, 2);
if (codec == 1) register_coef32(b + at + 0x10, cat);
}
}
// Every sound bank and stream of the game is under Sound/Resource/ (Sound/Resource/*.bars.zs, Sound/Resource/Stream/
// *.bwav); everything else is not audio. Creature and player vocal banks (Bokoblin_Voice0, Player_Voice, *_Vo_*)
// count as voices, as do the NV_* character voice lines.
int audio_cat_from_path(const char *path) {
if (!path || strncmp(path, "Sound/Resource/", 15)) return AUDIO_CAT_UNKNOWN;
const char *name = strrchr(path, '/') + 1;
if (!strncasecmp(name, "nv_", 3) || !strncasecmp(name, "vo_", 3)) return AUDIO_CAT_VOICE;
if (ci_str_has(name, "bgm_")) return AUDIO_CAT_MUSIC;
if (ci_str_has(name, "_voice") || ci_str_has(name, "voice_") || ci_str_has(name, "_vo_") ||
ci_str_has(name, "shoutvoice") || ci_str_has(name, "shoutmsg"))
return AUDIO_CAT_VOICE;
return AUDIO_CAT_SFX;
}
void audio_cat_tag_range(uint64_t addr, uint64_t size, int cat) {
if (!addr || !size || cat <= AUDIO_CAT_UNKNOWN || cat > AUDIO_CAT_VOICE) return;
plat_mutex_lock(&range_lock);
// A stream refills the same buffers: the same range read again only changes its category.
uint32_t depth = range_head < 64 ? range_head : 64;
for (uint32_t k = 0; k < depth; k++) {
Range *r = &ranges[(range_head - 1 - k) & (RANGE_CAP - 1)];
if (r->start == addr && r->end == addr + size) {
r->cat = (uint8_t)cat;
plat_mutex_unlock(&range_lock);
return;
}
}
Range *r = &ranges[range_head & (RANGE_CAP - 1)];
r->start = addr;
r->end = addr + size;
r->cat = (uint8_t)cat;
range_head++;
plat_mutex_unlock(&range_lock);
atomic_fetch_add_explicit(&range_count, 1, memory_order_relaxed);
}
// The newest range holding addr; newer loads into reused memory win over older ones.
int audio_cat_lookup(uint64_t addr) {
if (!addr) return AUDIO_CAT_UNKNOWN;
int cat = AUDIO_CAT_UNKNOWN;
plat_mutex_lock_shared(&range_lock);
uint32_t n = range_head < RANGE_CAP ? range_head : RANGE_CAP;
for (uint32_t k = 0; k < n; k++) {
const Range *r = &ranges[(range_head - 1 - k) & (RANGE_CAP - 1)];
if (addr >= r->start && addr < r->end) {
cat = r->cat;
break;
}
}
plat_mutex_unlock_shared(&range_lock);
return cat;
}
// BARS: "BARS", entry count at 0x0C, then count CRC32 name hashes and count (AMTA offset, BWAV offset) pairs. The AMTA
// block holds the entry's name; music and voice names inside an effects bank (a boss bank with its BGM) get their own
// category. ADPCM entries register their coefficients; other entries tag their bytes.
void audio_cat_scan_bars(uint64_t dst, uint64_t size, int fallback_cat) {
if (!dst || size < 16) return;
atomic_fetch_add_explicit(&bars_count, 1, memory_order_relaxed);
if (fallback_cat != AUDIO_CAT_UNKNOWN) audio_cat_tag_range(dst, size, fallback_cat);
const uint8_t *base = (const uint8_t *)(uintptr_t)dst;
uint32_t count;
memcpy(&count, base + 0x0C, 4);
if (count > 16384 || 0x10ull + (uint64_t)count * 12ull > size) return;
const uint8_t *pairs = base + 0x10 + (uint64_t)count * 4;
for (uint32_t k = 0; k < count; k++) {
uint32_t amta_off, bwav_off;
memcpy(&amta_off, pairs + k * 8ull, 4);
memcpy(&bwav_off, pairs + k * 8ull + 4, 4);
if (bwav_off >= size) continue;
int cat = fallback_cat != AUDIO_CAT_UNKNOWN ? fallback_cat : AUDIO_CAT_SFX;
if (amta_off < size) {
uint64_t limit = size - amta_off < 512 ? size - amta_off : 512;
const char *a = (const char *)(base + amta_off);
for (uint64_t s = 0; s + 4 <= limit; s++) {
if (!memcmp(a + s, "BGM_", 4)) { cat = AUDIO_CAT_MUSIC; break; }
if (!memcmp(a + s, "Vo_", 3) || !memcmp(a + s, "NV_", 3)) { cat = AUDIO_CAT_VOICE; break; }
if (s + 5 <= limit && !memcmp(a + s, "Voice", 5)) { cat = AUDIO_CAT_VOICE; break; }
}
}
const uint8_t *w = base + bwav_off;
uint32_t magic = 0;
uint16_t codec = 0;
if (bwav_off + 0x40 <= size) {
memcpy(&magic, w, 4);
memcpy(&codec, w + 0x10, 2);
}
if (magic == 0x56415742u) audio_cat_scan_bwav(w, size - bwav_off, cat);
if (cat == fallback_cat || (magic == 0x56415742u && codec == 1)) continue;
// The entry ends where the next BWAV starts: one pass over the offsets, only for the few entries tagged here.
uint64_t next = size;
for (uint32_t j = 0; j < count; j++) {
uint32_t o;
memcpy(&o, pairs + j * 8ull + 4, 4);
if (o > bwav_off && o < next) next = o;
}
audio_cat_tag_range(dst + bwav_off, next - bwav_off, cat);
}
}
// The PCM out of one Opus packet takes the packet's category, else the decoder's last one, else effects. Consecutive
// packets of one decoder fill one buffer, so the output grows the newest matching range instead of adding one each.
void audio_cat_on_opus_decode(uint64_t decoder_guest, uint64_t in_addr, uint64_t out_addr, uint64_t out_size) {
if (!out_addr || !out_size) return;
int cat = audio_cat_lookup(in_addr);
plat_mutex_lock(&decoder_lock);
int slot = -1;
for (int i = 0; i < 64 && decoder_guest; i++)
if (decoders[i].guest == decoder_guest) slot = i;
if (cat == AUDIO_CAT_UNKNOWN && slot >= 0) cat = decoders[slot].cat;
if (cat == AUDIO_CAT_UNKNOWN) cat = AUDIO_CAT_SFX;
if (decoder_guest) {
if (slot < 0) {
slot = (int)(decoder_next++ & 63);
decoders[slot].guest = decoder_guest;
}
decoders[slot].cat = (uint8_t)cat;
}
plat_mutex_unlock(&decoder_lock);
plat_mutex_lock(&range_lock);
uint32_t depth = range_head < 32 ? range_head : 32;
for (uint32_t k = 0; k < depth; k++) {
Range *r = &ranges[(range_head - 1 - k) & (RANGE_CAP - 1)];
if (r->cat != (uint8_t)cat) continue;
uint64_t lo = r->start > 65536 ? r->start - 65536 : 0, hi = r->end + 65536;
if (out_addr >= lo && out_addr + out_size <= hi) {
if (out_addr < r->start) r->start = out_addr;
if (out_addr + out_size > r->end) r->end = out_addr + out_size;
plat_mutex_unlock(&range_lock);
return;
}
}
plat_mutex_unlock(&range_lock);
audio_cat_tag_range(out_addr, out_size, cat);
}
void audio_cat_log_tables(void) {
rt_log("audio: categories known: coefficient tables music %llu, sfx %llu, voice %llu; address ranges %llu "
"(ring %d); BARS banks scanned %llu",
(unsigned long long)atomic_load(&coef_count[AUDIO_CAT_MUSIC]),
(unsigned long long)atomic_load(&coef_count[AUDIO_CAT_SFX]),
(unsigned long long)atomic_load(&coef_count[AUDIO_CAT_VOICE]), (unsigned long long)atomic_load(&range_count),
RANGE_CAP, (unsigned long long)atomic_load(&bars_count));
}
+30
View File
@@ -0,0 +1,30 @@
// Sound categories for the music / effects / voice volume settings (audio_cat.c).
#ifndef TOTK_AUDIO_CAT_H
#define TOTK_AUDIO_CAT_H
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
enum {
AUDIO_CAT_UNKNOWN = 0,
AUDIO_CAT_MUSIC = 1,
AUDIO_CAT_SFX = 2,
AUDIO_CAT_VOICE = 3,
};
int audio_cat_active(void); // one of volume_music / volume_sfx / volume_voice is below 100
int audio_cat_from_path(const char *path); // a RomFS-relative path; UNKNOWN outside Sound/Resource/
void audio_cat_tag_range(uint64_t addr, uint64_t size, int cat);
void audio_cat_scan_bars(uint64_t dst, uint64_t size, int fallback_cat);
void audio_cat_scan_bwav(const void *data, uint64_t size, int cat);
void audio_cat_on_opus_decode(uint64_t decoder_guest, uint64_t in_addr, uint64_t out_addr, uint64_t out_size);
int audio_cat_lookup(uint64_t addr);
int audio_cat_lookup_coef(uint64_t extra_addr, uint64_t extra_size);
void audio_cat_log_tables(void);
#ifdef __cplusplus
}
#endif
#endif
+64 -2
View File
@@ -28,6 +28,7 @@
#include "cfg.h"
#include "audio_effects.h"
#include "audio_reverb.h"
#include "audio_cat.h"
#include "audren.h"
#include "host.h"
#include "ipc.h"
@@ -83,6 +84,64 @@ static float host_volume(void) {
v = (float)((pct < 0 ? 0 : pct > 100 ? 100 : pct) / 100);
return v;
}
// TOTK_VOLUME_MUSIC / _SFX / _VOICE: per-category volumes in percent on top of TOTK_VOLUME, live like it. Render thread
// only.
static float category_volume(int cat) {
static const char *const names[4] = {NULL, "TOTK_VOLUME_MUSIC", "TOTK_VOLUME_SFX", "TOTK_VOLUME_VOICE"};
static float v[4] = {1, 1, 1, 1};
static unsigned seen = ~0u;
unsigned ver = cfg_version();
if (ver != seen) {
seen = ver;
for (int k = 1; k < 4; k++) {
double pct = cfg_double(names[k]);
v[k] = (float)((pct < 0 ? 0 : pct > 100 ? 100 : pct) / 100);
}
}
return v[cat >= AUDIO_CAT_MUSIC && cat <= AUDIO_CAT_VOICE ? cat : AUDIO_CAT_SFX];
}
// What the voice plays (audio_cat.c): an ADPCM voice by its coefficient table, any voice by the newest loaded or decoded
// range holding its current wave buffer, else effects. Kept per voice until it moves to another buffer or table, so a
// table lookup runs once per wave buffer, not once per frame. The counts feed category_report.
static uint64_t cat_counts[4], cat_by_coef, cat_by_range, cat_ns;
static int voice_category(ServerVoice *v) {
uint64_t addr = v->buffers[v->index].address, extra = v->in.extra_address;
if (v->cat && v->cat_address == addr && v->cat_extra == extra) return v->cat;
uint64_t t0 = kern_now_ns();
int cat = AUDIO_CAT_UNKNOWN;
if (v->in.sample_format == FMT_ADPCM) cat = audio_cat_lookup_coef(extra, v->in.extra_size);
if (cat != AUDIO_CAT_UNKNOWN) cat_by_coef++;
else if ((cat = audio_cat_lookup(addr)) != AUDIO_CAT_UNKNOWN) cat_by_range++;
else cat = AUDIO_CAT_SFX;
cat_counts[cat]++;
v->cat = (uint8_t)cat;
v->cat_address = addr;
v->cat_extra = extra;
cat_ns += kern_now_ns() - t0;
return cat;
}
// While a category volume is set, once a minute: how the wave buffers played were classified and what it cost.
static void category_report(void) {
static uint64_t next;
uint64_t now = kern_now_ns();
if (!next) next = now + 60000000000ull;
if (now < next) return;
next = now + 60000000000ull;
uint64_t n = cat_counts[AUDIO_CAT_MUSIC] + cat_counts[AUDIO_CAT_SFX] + cat_counts[AUDIO_CAT_VOICE];
rt_log("audio: categories over the last minute: %llu wave buffers, music %llu, sfx %llu, voice %llu; by coefficients "
"%llu, by address %llu, unmatched (played as sfx) %llu; %.1f us classifying",
(unsigned long long)n, (unsigned long long)cat_counts[AUDIO_CAT_MUSIC],
(unsigned long long)cat_counts[AUDIO_CAT_SFX], (unsigned long long)cat_counts[AUDIO_CAT_VOICE],
(unsigned long long)cat_by_coef, (unsigned long long)cat_by_range,
(unsigned long long)(n - cat_by_coef - cat_by_range), cat_ns / 1000.0);
audio_cat_log_tables();
memset(cat_counts, 0, sizeof cat_counts);
cat_by_coef = cat_by_range = cat_ns = 0;
}
static unsigned audio_revision(const AudioRenderer *r) { unsigned byte = r->revision >> 24; return byte >= '0' ? byte - '0' : 0; }
static void report_once(Mixer *m, unsigned bit, const char *msg, int value) {
if (m->reported & (1u << bit)) return;
@@ -812,10 +871,13 @@ void audio_mixer_render(AudioRenderer *r, double seconds) {
if (at > m->nbuf) { rt_log("audio: mixes use %d buffers, renderer has %d", at, m->nbuf); rt_fatal("audio mix buffer layout"); }
float (*vs)[MAX_FRAME]=m->voice_scratch,*filtered=m->filter_scratch;
const int by_category = audio_cat_active(); // the defaults (all 100) skip the category lookups
if (by_category) category_report();
for (int i = 0; i < r->param.voice_count; i++) {
ServerVoice *v = &r->voices[i];
if (!v->in.in_use || v->state != SV_STARTED || !v->in.sample_rate || !v->valid[v->index]) continue;
int cc = (int)v->in.channel_count; if (cc < 1 || cc > 6) { report_once(m, 2, "voice channel count unsupported", cc); continue; }
const float vvol = by_category ? v->in.volume * category_volume(voice_category(v)) : v->in.volume;
voice_render(r, v, vs, frames);
for (int f = 0; f < 2; f++) if (v->in.biquads[f].enable) {
const AudrenBiquad *b = &v->in.biquads[f];
@@ -841,13 +903,13 @@ void audio_mixer_render(AudioRenderer *r, double seconds) {
SplitDest *d = &m->dest[s->ids[k]];
if (!d->used || !mix_valid(r, d->dest)) continue;
const float *source=splitter_filter(d,vs[c],filtered,frames);
for (int b = 0; b < r->mixes[d->dest].buffer_count && b < 24; b++) accumulate(m, m->offset[d->dest] + b, source, d->vol[b] * v->in.volume, frames);
for (int b = 0; b < r->mixes[d->dest].buffer_count && b < 24; b++) accumulate(m, m->offset[d->dest] + b, source, d->vol[b] * vvol, frames);
}
} else if (mix_valid(r, v->in.mix_id)) {
for (int c = 0; c < cc; c++) {
int32_t id = v->in.channel_ids[c]; if (id < 0 || id >= r->param.voice_count * 6) continue;
const AudrenChannelIn *ch = &r->channels[id];
for (int b = 0; b < r->mixes[v->in.mix_id].buffer_count && b < 24; b++) accumulate(m, m->offset[v->in.mix_id] + b, vs[c], ch->mix[b] * v->in.volume, frames);
for (int b = 0; b < r->mixes[v->in.mix_id].buffer_count && b < 24; b++) accumulate(m, m->offset[v->in.mix_id] + b, vs[c], ch->mix[b] * vvol, frames);
}
}
}
+1
View File
@@ -86,6 +86,7 @@ static void voice_reset(ServerVoice *v) {
v->loops_done = 0;
memset(&v->adpcm, 0, sizeof v->adpcm);
memset(v->biquad_state, 0, sizeof v->biquad_state);
v->cat = 0;
}
static void update_voice(AudioRenderer *r, const AudrenVoiceIn *in) {
+2
View File
@@ -145,6 +145,8 @@ typedef struct {
uint32_t consumed, drops;
struct { int16_t history[2]; int32_t buffer; uint64_t at; } adpcm; // DSP-ADPCM decode cursor (buffer slot, next sample) and history
float biquad_state[2][6][2]; // filter, channel: transposed direct-form II delays
uint64_t cat_address, cat_extra; // the wave buffer and coefficients voice_category (audio_mixer.c) last classified
uint8_t cat; // their AUDIO_CAT_*, 0 until classified; voice_reset clears it
} ServerVoice;
enum { SV_STOPPED, SV_STARTED, SV_PAUSED, SV_STOPPING };
+2 -1
View File
@@ -22,7 +22,7 @@
#include "nvn_api.h"
#include "platform/platform.h"
#include "vk.h"
#include "platform/platform.h"
#include "gameplay_tweaks.h"
#define SYM_INIT_START "_ZN2nn4init5StartEmmPFvvES2_S2_"
// main: return addresses of nnMain's SetFocusHandlingMode call (1.1.0 and 1.2.1 from this port's analysis of main;
@@ -347,6 +347,7 @@ void rt_boot(void) {
rt_patches_init();
mods_exefs_switch(); // after the patch sets' settings: an enabled mod's ExeFS patches on
frame_step_init();
gameplay_tweaks_init();
res_init();
cheats_init(); // after the patch sets: a cheat's set follows its setting
cb_addr[0] = hostfn_register("<rtld loader_ready>", cb_loader_ready);
+70 -21
View File
@@ -32,7 +32,7 @@ static int save_ok = 1; // the last cfg_save_to wrote (o
// logged as unknown. A new variable goes here too, or its ini key logs a harmless "unknown key" line, and gets a
// description in totk.ini.example or docs/settings.md (tests/settings_doc_check.py checks both).
static const char *const known[] = {
"AB", "AMIIBO_DIR", "ANISO", "APP_POOL", "ASPECT", "ASPECT_PATCH", "ASSUME_FOCUS", "ASTC", "ASTC_BC", "ASTC_TIME", "ASYNC_PREEMPT", "AUDIO", "AUDIO_CHANNELS", "AUDIO_OFF", "AUDIO_PREFILL_MS",
"AB", "ABILITY_GUARD", "AMIIBO_DIR", "ANISO", "APP_POOL", "ASPECT", "ASPECT_PATCH", "ASSUME_FOCUS", "ASTC", "ASTC_BC", "ASTC_TIME", "ASYNC_PREEMPT", "AUDIO", "AUDIO_CHANNELS", "AUDIO_OFF", "AUDIO_PREFILL_MS",
"BACKGROUND_WINDOW", "BIND_A", "BIND_B", "BIND_DOWN", "BIND_L", "BIND_LCLICK", "BIND_LEFT", "BIND_LSTICK_DOWN", "BIND_LSTICK_LEFT",
"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",
@@ -40,27 +40,32 @@ static const char *const known[] = {
"BIND_SKIP", "BIND_STATS", "BIND_UP", "BIND_X", "BIND_Y",
"BIND_ZL", "BIND_ZR", "BLOCK_VIEWS_3D", "CLIMB_FIX", "CLOTH_REALTIME", "COLOR_BRIGHTNESS", "COLOR_CONTRAST", "COLOR_GAMMA",
"COLOR_PRESET", "COLOR_SATURATION", "CONTACT_DEBUG", "CONTACT_SHADOWS", "CORE_DIAG", "CRIT", "CRIT_OUT",
"DESC_TEMPLATE", "DESWIZZLE", "DEVICE_PROFILE", "DISCORD_APP_ID", "DISCORD_IMAGE", "DISCORD_RPC", "DLAA", "DLAA_JITTER", "DLAA_MV", "DLAA_MASKDEBUG", "DLAA_MVDEBUG", "DLAA_OBJMV", "DLAA_SURVEY", "DLAA_TIMES", "DLSS", "DLSS_CHAR_MASK", "DLSS_PRESET", "DLSS_REACTIVE", "DUMP", "DUMP_BUF", "DUMP_DIR",
"DESC_TEMPLATE", "DESWIZZLE", "DEVICE_PROFILE", "DIALOGUE_CLICK", "DISCORD_APP_ID", "DISCORD_IMAGE", "DISCORD_RPC", "DLAA", "DLAA_JITTER", "DLAA_MV", "DLAA_MASKDEBUG", "DLAA_MVDEBUG", "DLAA_OBJMV", "DLAA_SURVEY", "DLAA_TIMES", "DLSS", "DLSS_CHAR_MASK", "DLSS_PRESET", "DLSS_REACTIVE", "DUMP", "DUMP_BUF", "DUMP_DIR",
"DUMP_LOG", "DYNAMIC_RES", "DYN_DELTA", "EXEFS", "FEEDBACK", "FIXED_RES_PATCH", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES",
"FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FLUSH_SPAN", "FOV", "FOV_PATCH", "FPS60", "FPS_LIMIT", "FRAME_QUEUE",
"FREEZE_IDLE", "FREE_CORES",
"FULLSCREEN", "FXAA", "GPL", "GPL_DRAW_BUILD", "GPU", "GPU_INDEX", "GPU_NAME", "HDR", "HDR_GAME_NITS", "HDR_HUE",
"FULLSCREEN", "FXAA",
"GAMEPLAY_DISTANCE_SENSITIVITY", "GAMEPLAY_ITEM_AD", "GAMEPLAY_ITEM_SENSITIVITY", "GAMEPLAY_ITEM_WHEEL",
"GAMEPLAY_MAP_ZOOM", "GAMEPLAY_MAP_ZOOM_SENSITIVITY", "GAMEPLAY_ROTATION_SENSITIVITY", "GAMEPLAY_TWEAKS_ENABLED",
"GAMEPLAY_ULTRAHAND_C_AXIS", "GAMEPLAY_ULTRAHAND_DISTANCE", "GAMEPLAY_ULTRAHAND_ROTATE", "GAMEPLAY_WEAPON_SENSITIVITY",
"GAMEPLAY_WEAPON_WHEEL",
"GPL", "GPL_DRAW_BUILD", "GPU", "GPU_INDEX", "GPU_NAME", "GRASS_RANGE", "HDR", "HDR_GAME_NITS", "HDR_HUE",
"HDR_PEAK_NITS", "HDR_UI_NITS", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "KSPIN_US", "LANG", "LIB_PREBUILD",
"LIB_PREBUILD_KEEP", "LIB_PREBUILD_THREADS", "LOCALE", "LOD_GUARD", "LSTICK_DEADZONE", "MEMORY", "MENU_LANG", "MENU_TEST",
"LIB_PREBUILD_KEEP", "LIB_PREBUILD_THREADS", "LOCALE", "LOD_GUARD", "LSTICK_DEADZONE", "MAP_CLICK", "MEMORY", "MENU_LANG", "MENU_TEST", "MENU_FONT_FONTCONFIG",
"MEM_RESERVE_MIB", "MENU_CURSOR", "MENU_CURSOR_LOG", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MODS_DIR", "MODS_DISABLED", "MODS_ORDER", "MODS_REBUILD", "MOTION", "MOUSE_AIM_SCALE", "MOUSE_MODE", "MOUSE_DIRECT_PATCH", "MOUSE_SENS", "MOVIE_ASPECT", "MOVIE_HOST", "MOVIE_PACE",
"MVOBJ_ALL", "MVOBJ_BANKS", "MVOBJ_EQUAL", "MVOBJ_EXACT", "MVOBJ_EXEC", "MVOBJ_NOC4", "MVOBJ_ONLY", "MVOBJ_TIMES", "MVPREV_CHECK", "MVPREV_GROW", "MVPREV_SKIP", "MVPREV_TRUST", "MV_CHECK",
"MV_SURVEY",
"ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PASS_CRUMBS", "PATCH_OUTPUT", "PATCH_SCENE", "PCORE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT",
"ONE_PER_CORE", "OPERATION_MODE", "OPTREF_GUARD", "OUTPUT_RES", "PAD_LAYOUT", "PASS_CRUMBS", "PATCH_OUTPUT", "PATCH_SCENE", "PCORE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", "POINTER_IMAGE",
"PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_BENCH", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES",
"PROFILE_MAIN", "PROFILE_RENDER", "PROMPTS", "PUSH_SKIP", "PUSH_STAGE", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REC_ASYNC", "REC_END", "REC_SPIN_US", "REEXEC",
"PROFILE_MAIN", "PROFILE_RENDER", "PROMPTS", "PUSH_SKIP", "PUSH_STAGE", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REC_ASYNC", "REC_END", "REC_SPIN_US", "REEXEC", "REFLEX",
"RENDER_SCALE", "REPLAY_ASYNC", "REPLAY_CHUNKS", "REPLAY_CHUNK_DRAWS", "REPLAY_SKEW_US", "REPLAY_STATE_CHECK", "REPLAY_WORKERS",
"REPLAY_CHECK", "RESOLVE_CHECK", "RESTART_WAIT", "ROMFS", "ROMFS_INDEX", "ROMFS_MMAP", "ROMFS_MODS", "ROMFS_PATCHES",
"REPLAY_CHECK", "REPORT_GUARD", "RESOLVE_CHECK", "RESTART_WAIT", "ROMFS", "ROMFS_INDEX", "ROMFS_MMAP", "ROMFS_MODS", "ROMFS_PATCHES",
"ROMFS_PROOF_DIR", "ROMFS_VERIFY", "RSTICK_DEADZONE", "RUMBLE", "RUMBLE_CURVE", "RUMBLE_STRENGTH", "RUMBLE_TRIGGERS", "SHADER_CACHE",
"SHADER_MEMO", "SHADOW_DEFER", "SHADOW_RANGE", "SHADOW_RES", "SHADOW_SCALE", "SHADOW_SNAP", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR",
"SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "STICK_DEADZONE", "STICK_SENS",
"SWKBD_ANSWER", "SYNC_AHEAD",
"SWKBD_TEST", "TEST_OOM", "TEST_PAD", "TEST_PREPARE_SHADERS", "TEX_ALIAS", "TEX_BLOCK_MIB", "TEX_HEAP_EXTRA_MB", "TEX_MEMO", "TEX_RELEASED_MIB", "TEX_VRAM_PRESSURE", "TIMER_1MS", "TRACE", "TXD_TRANSPOSE", "UBO_SNAPSHOT", "UB_OVERLAY", "UB_OVERLAY_OUT", "UPSCALER", "VB_USED", "VK_DYN_A2C", "VK_DYN_VERTEX", "VK_NO_FLOAT64",
"VK_PRESENT", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VMA_BLOCK_MIB", "VOLUME", "VRAM_HEADROOM", "VRAM_LIMIT_MIB", "VS_OUTS",
"VK_PRESENT", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VMA_BLOCK_MIB", "VOLUME", "VOLUME_MUSIC", "VOLUME_SFX", "VOLUME_VOICE", "VRAM_HEADROOM", "VRAM_LIMIT_MIB", "VS_OUTS",
"WALK_KEY", "WALK_SCALE", "WB_EXACT", "WB_FENCE_LIMIT", "WB_MERGE", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_KEEP", "XLATE_PROCS",
"ZSTD_CHECK", "ZSTD_NATIVE",
};
@@ -77,19 +82,19 @@ static const struct { const char *key, *section; } sections[] = {
{"COLOR_BRIGHTNESS", "display"}, {"COLOR_CONTRAST", "display"}, {"COLOR_SATURATION", "display"},
{"COLOR_GAMMA", "display"}, {"HDR", "display"}, {"HDR_PEAK_NITS", "display"}, {"HDR_GAME_NITS", "display"},
{"HDR_UI_NITS", "display"}, {"HDR_HUE", "display"}, {"SHADOW_RES", "display"},
{"DLAA", "display"}, {"DLSS", "display"}, {"DLSS_PRESET", "display"}, {"DLSS_CHAR_MASK", "display"}, {"FXAA", "display"},
{"DLAA", "display"}, {"DLSS", "display"}, {"DLSS_PRESET", "display"}, {"DLSS_CHAR_MASK", "display"}, {"REFLEX", "display"}, {"FXAA", "display"},
{"DEVICE_PROFILE", "display"}, {"ASSUME_FOCUS", "display"},
{"DISCORD_RPC", "discord"}, {"DISCORD_APP_ID", "discord"}, {"DISCORD_IMAGE", "discord"},
{"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"CONTACT_SHADOWS", "display"},
{"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"GRASS_RANGE", "display"}, {"CONTACT_SHADOWS", "display"},
{"PCSS", "display"},
{"MODS_DIR", "mods"}, {"MODS_ORDER", "mods"}, {"MODS_DISABLED", "mods"}, {"MODS_REBUILD", "mods"},
{"TEX_HEAP_EXTRA_MB", "mods"},
{"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"},
{"VOLUME", "audio"}, {"AUDIO_CHANNELS", "audio"},
{"MENU_LANG", "language"}, {"MENU_FONT_FONTCONFIG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"},
{"VOLUME", "audio"}, {"VOLUME_MUSIC", "audio"}, {"VOLUME_SFX", "audio"}, {"VOLUME_VOICE", "audio"}, {"AUDIO_CHANNELS", "audio"},
{"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"},
{"PAD_LAYOUT", "input"}, {"PROMPTS", "input"}, {"STICK_DEADZONE", "input"}, {"LSTICK_DEADZONE", "input"}, {"RSTICK_DEADZONE", "input"},
{"STICK_SENS", "input"},
{"MENU_CURSOR", "input"}, {"MOUSE_MODE", "input"}, {"MOUSE_SENS", "input"}, {"MOUSE_AIM_SCALE", "input"}, {"WALK_KEY", "input"}, {"WALK_SCALE", "input"}, {"INPUT_RECORD", "input"},
{"MENU_CURSOR", "input"}, {"MAP_CLICK", "input"}, {"DIALOGUE_CLICK", "input"}, {"POINTER_IMAGE", "input"}, {"MOUSE_MODE", "input"}, {"MOUSE_SENS", "input"}, {"MOUSE_AIM_SCALE", "input"}, {"WALK_KEY", "input"}, {"WALK_SCALE", "input"}, {"INPUT_RECORD", "input"},
{"BIND_A", "input"}, {"BIND_B", "input"}, {"BIND_X", "input"}, {"BIND_Y", "input"}, {"BIND_LCLICK", "input"},
{"BIND_RCLICK", "input"}, {"BIND_L", "input"}, {"BIND_R", "input"}, {"BIND_ZL", "input"}, {"BIND_ZR", "input"},
{"BIND_PLUS", "input"}, {"BIND_MINUS", "input"}, {"BIND_LEFT", "input"}, {"BIND_UP", "input"},
@@ -104,9 +109,17 @@ static const struct { const char *key, *section; } sections[] = {
{"BIND_SKIP", "performance"}, {"SHADER_MEMO", "performance"}, {"PIPE_MEMO", "performance"}, {"TEX_MEMO", "performance"}, {"VB_USED", "performance"}, {"DESC_TEMPLATE", "performance"},
{"SYNC_AHEAD", "performance"}, {"SHADOW_DEFER", "performance"}, {"PUSH_SKIP", "performance"}, {"SPLIT_DRAWS", "performance"}, {"SPLIT_US", "performance"}, {"VK_VALIDATION", "performance"},
{"VK_DYN_VERTEX", "performance"}, {"VK_DYN_A2C", "performance"}, {"VK_SUBGROUP_PIN", "performance"},
{"OPTREF_GUARD", "performance"}, {"ABILITY_GUARD", "performance"}, {"REPORT_GUARD", "performance"},
{"TRACE", "diagnostics"}, {"FLIGHT", "diagnostics"}, {"PASS_CRUMBS", "diagnostics"}, {"FLIGHT_SPIKE_MS", "diagnostics"},
{"WB_FENCE_LIMIT", "diagnostics"}, {"WB_MERGE", "diagnostics"}, {"WB_EXACT", "diagnostics"},
{"MV_SURVEY", "diagnostics"},
{"GAMEPLAY_TWEAKS_ENABLED", "gameplay tweaks"}, {"GAMEPLAY_ULTRAHAND_ROTATE", "gameplay tweaks"},
{"GAMEPLAY_ULTRAHAND_C_AXIS", "gameplay tweaks"}, {"GAMEPLAY_ULTRAHAND_DISTANCE", "gameplay tweaks"},
{"GAMEPLAY_ITEM_WHEEL", "gameplay tweaks"}, {"GAMEPLAY_ITEM_AD", "gameplay tweaks"},
{"GAMEPLAY_MAP_ZOOM", "gameplay tweaks"}, {"GAMEPLAY_MAP_ZOOM_SENSITIVITY", "gameplay tweaks"},
{"GAMEPLAY_ROTATION_SENSITIVITY", "gameplay tweaks"}, {"GAMEPLAY_DISTANCE_SENSITIVITY", "gameplay tweaks"},
{"GAMEPLAY_ITEM_SENSITIVITY", "gameplay tweaks"},
{"GAMEPLAY_WEAPON_WHEEL", "gameplay tweaks"}, {"GAMEPLAY_WEAPON_SENSITIVITY", "gameplay tweaks"},
};
// The settings the menu shows: the value in effect when the key is unset, and what the key accepts. The only place a
@@ -124,7 +137,7 @@ static const CfgMeta metas[] = {
{"UPSCALER", "fsr", "fsr|bilinear", LIVE}, {"SHARPNESS", "80", "0..100", LIVE},
{"DLAA", "0", "0|1", RESTART}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance|ultra_performance", LIVE},
{"DLSS_PRESET", "default", "default|k|j", LIVE},
{"DLSS_CHAR_MASK", "65", "0|35|65|100", LIVE}, {"FXAA", "1", "0|1", LIVE},
{"DLSS_CHAR_MASK", "65", "0|35|65|100", LIVE}, {"REFLEX", "off", "off|on|boost", RESTART}, {"FXAA", "1", "0|1", LIVE},
{"ASPECT", "fit", "fit|stretch", LIVE}, {"MOVIE_ASPECT", "keep", "keep|stretch", LIVE}, {"FOV", "100", "70..140", LIVE},
{"ANISO", "game", "game|2|4|8|16", RESTART}, // vk_texture.c sampler_features
// colour adjustment (vk_color.c); the preset is the menu's, the four values are what the present uses
@@ -133,11 +146,11 @@ static const CfgMeta metas[] = {
{"COLOR_GAMMA", "1", "0.8..1.2", LIVE},
// HDR output (vk_hdr.c): on at start (the tonemap shader is swapped as shaders load); the nits apply at once
{"HDR", "0", "0|1", RESTART}, {"HDR_PEAK_NITS", "1000", "400..10000", LIVE}, {"HDR_GAME_NITS", "203", "80..500", LIVE},
{"HDR_UI_NITS", "203", "80..500", LIVE}, {"HDR_HUE", "80", "0..100", LIVE},
{"HDR_UI_NITS", "203", "80..500", LIVE}, {"HDR_HUE", "70", "0..100", LIVE},
{"DEVICE_PROFILE", "auto", "auto|desktop|deck", RESTART},
{"SHADOW_RES", "game", "game|256|512|768|1024|1536|2048", RESTART},
{"SHADOW_SCALE", "1", "1..4", RESTART},
{"SHADOW_RANGE", "100", "50..400", RESTART}, {"CONTACT_SHADOWS", "0", "0..100", RESTART},
{"SHADOW_RANGE", "100", "50..400", RESTART}, {"GRASS_RANGE", "100", "50..400", RESTART}, {"CONTACT_SHADOWS", "0", "0..100", RESTART},
{"PCSS", "0", "0..200", RESTART},
// Game
{"FPS_LIMIT", "60", "30|40|45|60|90|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"FRAME_QUEUE", "0", "0|1", LIVE},
@@ -148,7 +161,7 @@ static const CfgMeta metas[] = {
{"OPERATION_MODE", "docked", "docked|handheld", RESTART},
{"ASSUME_FOCUS", "1", "0|1", LIVE}, // read on every focus change (ov_system.c)
// Sound, Controls, Menu
{"VOLUME", "100", "0..100", LIVE}, {"AUDIO_CHANNELS", "stereo", "auto|stereo|5.1", RESTART},
{"VOLUME", "100", "0..100", LIVE}, {"VOLUME_MUSIC", "100", "0..100", LIVE}, {"VOLUME_SFX", "100", "0..100", LIVE}, {"VOLUME_VOICE", "100", "0..100", LIVE}, {"AUDIO_CHANNELS", "stereo", "auto|stereo|5.1", RESTART},
{"MOTION", "1", "0|1", LIVE}, {"RUMBLE_STRENGTH", "130", "0..300", LIVE}, {"RUMBLE_CURVE", "0.6", "0.2..1.5", LIVE},
{"RUMBLE_TRIGGERS", "0", "0|1", LIVE}, {"PAD_LAYOUT", "auto", "auto|nintendo|xbox", LIVE},
{"PROMPTS", "nintendo", "nintendo|xbox|pc", RESTART},
@@ -156,8 +169,22 @@ static const CfgMeta metas[] = {
{"LSTICK_DEADZONE", "", "0..50", LIVE}, {"RSTICK_DEADZONE", "", "0..50", LIVE},
{"MOUSE_MODE", "direct", "stick|direct", LIVE},
{"MOUSE_SENS", "1", "0..10", LIVE}, {"MOUSE_AIM_SCALE", "1", "0.1..3", LIVE}, {"MENU_CURSOR", "1", "0|1", LIVE},
{"MAP_CLICK", "0", "0|1", LIVE}, // input.c: the left mouse button is A on the Purah Pad's map
{"DIALOGUE_CLICK", "0", "0|1", LIVE}, // menu_cursor.c: in a dialogue box left click is B, right click A
{"POINTER_IMAGE", "0", "0|1", LIVE}, // input_win.c / input_sdl.c: the game window's own pointer (cursor_art.c)
{"WALK_KEY", "none", NULL, LIVE}, {"WALK_SCALE", "0.51", "0.2..0.9", LIVE},
// Gameplay Tweaks
{"GAMEPLAY_TWEAKS_ENABLED", "0", "0|1", LIVE},
{"GAMEPLAY_ULTRAHAND_ROTATE", "1", "0|1", LIVE}, {"GAMEPLAY_ULTRAHAND_C_AXIS", "1", "0|1", LIVE},
{"GAMEPLAY_ULTRAHAND_DISTANCE", "1", "0|1", LIVE}, {"GAMEPLAY_ITEM_WHEEL", "1", "0|1", LIVE},
{"GAMEPLAY_ITEM_AD", "1", "0|1", LIVE}, {"GAMEPLAY_MAP_ZOOM", "1", "0|1", LIVE},
{"GAMEPLAY_MAP_ZOOM_SENSITIVITY", "1", "0.25..4", LIVE}, {"GAMEPLAY_ROTATION_SENSITIVITY", "1", "0.25..4", LIVE},
{"GAMEPLAY_DISTANCE_SENSITIVITY", "1", "0.25..4", LIVE}, {"GAMEPLAY_ITEM_SENSITIVITY", "1", "0.25..4", LIVE},
{"GAMEPLAY_WEAPON_WHEEL", "1", "0|1", LIVE}, {"GAMEPLAY_WEAPON_SENSITIVITY", "1", "0.25..4", LIVE},
{"MENU_LANG", "", "en|ru|pt-BR|zh-Hans", LIVE},
// plat_font_path on Linux: 1 asks fontconfig which file draws the language, 0 keeps the fixed distribution
// paths. A rebuild of the atlas reads it, so a change shows on the next window size or language switch.
{"MENU_FONT_FONTCONFIG", "1", "0|1", LIVE},
{"AMIIBO_DIR", "", NULL, LIVE},
// Discord Rich Presence (discord_rpc.c): off by default, the Menu tab of the settings menu switches it.
{"DISCORD_RPC", "0", "0|1", LIVE},
@@ -178,6 +205,8 @@ static const CfgMeta metas[] = {
{"ASTC", "auto", "auto|gpu|native|cpu", RESTART}, {"MEMORY", "auto", "auto|import|mirror|verify", RESTART},
{"TEX_ALIAS", "1", "0|1", RESTART}, {"TEX_VRAM_PRESSURE", "90", "0..100", RESTART},
{"TEX_RELEASED_MIB", "256", "0..65536", RESTART}, {"TEX_BLOCK_MIB", "64", "0..1024", RESTART}, {"VMA_BLOCK_MIB", "64", "0..1024", RESTART}, {"ASTC_BC", "", "0|1", RESTART}, {"ZSTD_NATIVE", "1", "0|1", RESTART}, {"ZSTD_CHECK", "0", "0|1", RESTART},
// crash guards: code patch sets (recomp/patches-v*.txt) over game reads that crash on stale data
{"OPTREF_GUARD", "1", "0|1", RESTART}, {"ABILITY_GUARD", "1", "0|1", RESTART}, {"REPORT_GUARD", "1", "0|1", RESTART},
// render fixes
{"LOD_GUARD", "1", "0|1", RESTART}, {"FIX_C0", "1", "0|1", RESTART}, {"FIX_ZERO", "1", "0|1", RESTART},
{"BIND_SKIP", "1", "0|1", RESTART}, {"SHADER_MEMO", "1", "0|1", RESTART}, {"PIPE_MEMO", "1", "0|1", RESTART}, {"TEX_MEMO", "1", "0|1", RESTART},
@@ -344,16 +373,36 @@ static const char *raw_get(const char *name) {
// picture between black bars. The sizes are the ones the installer lays the HUD out for (installer/steps.py
// ASPECT_SIZES, ui/menu.cpp row_output_res): of the display's shape within 1%, the smallest at least 1080 high that fits
// the display, else the largest that fits. A 16:9 display, an unknown one or one of another shape keeps 1920x1080.
// Xbox and keyboard prompts have a folder for each of these sizes (romfs-patches-xbox-<w>x<h>, -xbox-label-<w>x<h>,
// -pc-<w>x<h>, installer/steps.py Prepare): they keep 1920x1080 only when the one for the display's size is missing,
// as in a source build without make_romfs_patches.py --prompts <style> --aspect or an install by an older setup,
// where a default of another shape would trade the prompts the player chose for the Switch ones.
// Xbox and keyboard prompts need their folder for that size's shape too (romfs-patches-xbox-<w>x<h>, -xbox-label-,
// -pc-, written by installer/steps.py Shapes for the style totk.ini selects and the connected displays' shapes): they
// keep 1920x1080 when it is missing, as in a source build without make_romfs_patches.py --prompts <style> --aspect or
// after a switch of prompts in the menu, where a default of another shape would trade the prompts the player chose for
// the Switch ones.
static const unsigned SHAPED[][2] = {
{2560, 1080}, {3440, 1440}, {3840, 1600}, {5120, 2160}, // 21:9
{3840, 1080}, {5120, 1440}, // 32:9
{1280, 800}, {1680, 1050}, {1920, 1200}, {2560, 1600}, // 16:10
{1920, 1280}, {2160, 1440}, {2256, 1504}, {2880, 1920}, {3000, 2000}, // 3:2
};
// The folder size of w x h's shape: of SHAPED within 1% of its aspect ratio, the closest, the first of equal ones
// (5120x2160 takes 2560x1080). The UI layout depends on the aspect ratio alone (tools/ultrawide_layout.py apply), so
// the setup writes one romfs-patches-<w>x<h> per shape, named after this size (installer/screens.py shape_size, the
// same rule), and romfs.c overlay_init looks for it. 0 for 16:9 and for a shape without a layout.
int cfg_shape_size(unsigned w, unsigned h, unsigned out[2]) {
if (!w || !h) return 0;
double r = (double)w / h, err = 0;
if (fabs(r / (16.0 / 9.0) - 1) <= 0.01) return 0;
int best = -1;
for (int i = 0; i < (int)(sizeof SHAPED / sizeof *SHAPED); i++) {
double e = fabs((double)SHAPED[i][0] / SHAPED[i][1] / r - 1);
if (e <= 0.01 && (best < 0 || e < err)) best = i, err = e;
}
if (best < 0) return 0;
out[0] = SHAPED[best][0], out[1] = SHAPED[best][1];
return 1;
}
static char screen_res[16]; // set once by cfg_init, "" for none
// romfs-patches-xbox-, romfs-patches-xbox-label- and romfs-patches-pc-<screen_res> have a manifest (set once by
// cfg_init)
+3
View File
@@ -23,6 +23,9 @@ unsigned cfg_version(void);
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 folder size of w x h's shape (cfg.c SHAPED: the closest aspect ratio within 1%, the first of equal ones), the
// one romfs-patches-<w>x<h> the setup writes for it. 0 for 16:9 and for a shape without a UI layout.
int cfg_shape_size(unsigned w, unsigned h, unsigned out[2]);
// 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).
+32
View File
@@ -339,6 +339,38 @@ int probe_cfg(void) {
CHECK(a_east == EQ(input_prompts_folder(PROMPTS_XBOX, layouts[i]), "romfs-patches-xbox"),
"prompts: the folder names A as B exactly when the layout puts A on the button labelled B");
}
// One folder per screen shape (cfg.c cfg_shape_size, installer/screens.py shape_size): the closest aspect ratio of
// SHAPED within 1%, the first of equal ones; 16:9 and unlisted shapes have none.
unsigned sz[2] = {0, 0};
CHECK(cfg_shape_size(5120, 2160, sz) && sz[0] == 2560 && sz[1] == 1080, "shape: 5120x2160 takes 2560x1080's folder");
CHECK(cfg_shape_size(3440, 1440, sz) && sz[0] == 3440 && sz[1] == 1440, "shape: 3440x1440 keeps its own (0.8% off 2560x1080)");
CHECK(cfg_shape_size(1920, 800, sz) && sz[0] == 3840 && sz[1] == 1600, "shape: 1920x800 takes 3840x1600's folder");
CHECK(cfg_shape_size(2560, 1600, sz) && sz[0] == 1280 && sz[1] == 800 && cfg_shape_size(3000, 2000, sz) &&
sz[0] == 1920 && sz[1] == 1280 && cfg_shape_size(5120, 1440, sz) && sz[0] == 3840 && sz[1] == 1080,
"shape: 16:10, 3:2 and 32:9 take their first size");
CHECK(!cfg_shape_size(1920, 1080, sz) && !cfg_shape_size(2560, 1440, sz) && !cfg_shape_size(1024, 768, sz),
"shape: none for 16:9 and 4:3");
// romfs.c shaped_name: the exact size's folder (an older setup wrote every size) wins, else the shape's
{
char dir[1100], f[1200];
snprintf(dir, sizeof dir, "%.*scfg-probe-shapes", (int)(cut + 1 - path), path);
static const char *const made[] = {"romfs-patches-2560x1080", "romfs-patches-xbox-5120x2160"};
for (int i = 0; i < 2; i++) {
snprintf(f, sizeof f, "%s/%s", dir, made[i]);
plat_file_mkdir_p(f);
snprintf(f, sizeof f, "%s/%s/manifest.tsv", dir, made[i]);
plat_file_write(f, "#\n", 2);
}
snprintf(f, sizeof f, "%s/romfs-index.bin", dir);
plat_setenv("TOTK_ROMFS_INDEX", f);
CHECK(romfs_shaped_ready(2560, 1080) && romfs_shaped_ready(5120, 2160) && !romfs_shaped_ready(3440, 1440),
"shape: 5120x2160 finds 2560x1080's layout folder, 3440x1440 does not");
CHECK(romfs_shaped_prompts_ready("romfs-patches-xbox", 5120, 2160) &&
!romfs_shaped_prompts_ready("romfs-patches-xbox", 2560, 1080) &&
!romfs_shaped_prompts_ready("romfs-patches-pc", 5120, 2160),
"shape: an older install's exact-size prompts folder serves that size only");
plat_setenv("TOTK_ROMFS_INDEX", NULL);
}
uint8_t pd[PAD_COUNT] = {0};
pd[PAD_SOUTH] = pd[PAD_NORTH] = 1;
CHECK(input_map_pad_buttons(pd, PAD_LAYOUT_NINTENDO) == (1ull << B_B | 1ull << B_X) &&
+89
View File
@@ -0,0 +1,89 @@
// The mouse pointer's image in the game window while the cursor is not captured (the game's menus, the settings menu):
// a gold arrowhead with a notched back, a dark outline, a turquoise gem and a soft shadow, drawn here at the size the
// window's DPI asks for instead of the Windows arrow. input_win.c and input_sdl.c make the system cursor from it.
// Nothing comes from the game's files.
#include <math.h>
#include <stdint.h>
#include "input_wsys.h"
typedef struct { float x, y; } V;
// In units of a 32-pixel cursor: the tip at the top left (the hotspot), the wings to the right and below, the notch
// between them
static const V SHAPE[] = {{1.5f, 1.5f}, {25.0f, 10.5f}, {14.5f, 14.5f}, {10.5f, 25.0f}};
static const V GEM[] = {{10.4f, 7.6f}, {13.0f, 10.2f}, {10.4f, 12.8f}, {7.8f, 10.2f}};
#define OUTLINE 1.7f // the dark edge's width
#define SHADOW 1.6f // the shadow's offset to the bottom right
static float seg_dist(V p, V a, V b) {
float dx = b.x - a.x, dy = b.y - a.y, t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / (dx * dx + dy * dy);
t = t < 0 ? 0 : t > 1 ? 1 : t;
float ex = a.x + t * dx - p.x, ey = a.y + t * dy - p.y;
return sqrtf(ex * ex + ey * ey);
}
// Distance to the polygon's edge, negative inside (even-odd: the shapes are simple)
static float poly_sdf(V p, const V *v, int n) {
float d = 1e9f;
int in = 0;
for (int i = 0, j = n - 1; i < n; j = i++) {
float e = seg_dist(p, v[j], v[i]);
if (e < d) d = e;
if ((v[i].y > p.y) != (v[j].y > p.y) && p.x < (v[j].x - v[i].x) * (p.y - v[i].y) / (v[j].y - v[i].y) + v[i].x)
in = !in;
}
return in ? -d : d;
}
// One sample's colour (straight r, g, b in 0..1) and coverage
static float sample(V p, float *r, float *g, float *b) {
float d = poly_sdf(p, SHAPE, 4);
if (d < 0) {
if (-d < OUTLINE) { *r = 0.17f, *g = 0.11f, *b = 0.04f; return 1; }
if (poly_sdf(p, GEM, 4) < 0) { // the gem, lighter towards its top left
float t = (p.x + p.y - 20.4f) / 5.2f + 0.5f;
t = t < 0 ? 0 : t > 1 ? 1 : t;
*r = 0.62f - 0.42f * t, *g = 0.98f - 0.22f * t, *b = 0.92f - 0.12f * t;
return 1;
}
// gold, pale at the tip and deeper at the wings; a thin light line inside the outline
float t = (p.x + p.y) / 34.0f;
t = t < 0 ? 0 : t > 1 ? 1 : t;
float rim = -d < OUTLINE + 1.0f ? 0.12f : 0;
*r = fminf(1, 1.00f - 0.12f * t + rim), *g = fminf(1, 0.93f - 0.32f * t + rim),
*b = fminf(1, 0.70f - 0.52f * t + rim);
return 1;
}
V s = {p.x - SHADOW, p.y - SHADOW};
float ds = poly_sdf(s, SHAPE, 4);
if (ds < 0.8f) { // the shadow, soft at its edge
*r = *g = *b = 0;
float a = ds < -0.8f ? 1 : (0.8f - ds) / 1.6f;
return 0.38f * a;
}
return 0;
}
void cursor_art(uint32_t *argb, int size, int *hot) {
float k = 32.0f / (float)size;
enum { SS = 4 }; // 4 x 4 samples a pixel
for (int y = 0; y < size; y++)
for (int x = 0; x < size; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int sy = 0; sy < SS; sy++)
for (int sx = 0; sx < SS; sx++) {
V p = {(x + (sx + 0.5f) / SS) * k, (y + (sy + 0.5f) / SS) * k};
float sr, sg, sb, c = sample(p, &sr, &sg, &sb);
r += sr * c, g += sg * c, b += sb * c, a += c;
}
uint32_t px = 0;
if (a > 0) { // straight alpha, as Windows and SDL take it
r /= a, g /= a, b /= a, a /= SS * SS;
px = (uint32_t)lrintf(a * 255) << 24 | (uint32_t)lrintf(r * 255) << 16 |
(uint32_t)lrintf(g * 255) << 8 | (uint32_t)lrintf(b * 255);
}
argb[y * size + x] = px;
}
*hot = (int)(1.5f / k);
}
+8
View File
@@ -47,6 +47,14 @@ enum { ROMFS_PROMPTS_OK, ROMFS_PROMPTS_MISSING, ROMFS_PROMPTS_FAILED, ROMFS_PROM
ROMFS_PROMPTS_PATCHES };
const char *romfs_prompts(void);
int romfs_prompts_ready(const char *folder);
// 1 when the game resolution w x h is of another shape whose folders are missing: the UI layout, or that of
// prompts_folder (a prompts' folder that is there at 16:9; NULL for the game's own prompts). romfs.c shaped_name.
int romfs_shape_missing(unsigned w, unsigned h, const char *prompts_folder);
// 1 when build-cache/rebuild.txt names the setup's Python and tools/make_romfs_patches.py and both exist, with romfs/.
int romfs_shape_can_prepare(void);
// Starts the generator for w x h's shape (its layout, and prompts_folder's when that is there at 16:9 and lacks it) as
// child processes the game does not wait for; the next start loads the result. 1 when every one started.
int romfs_shape_prepare(unsigned w, unsigned h, const char *prompts_folder);
int romfs_prompts_off(const char *folder);
const char *romfs_overlay(size_t k, const char **file, uint64_t *size, int *is_added); // RomFS path of overlay k
void fs_trace(const char *what, const char *path); // TOTK_TRACE=fs: one line per open
+474
View File
@@ -0,0 +1,474 @@
// Mouse wheel and keyboard gameplay tweaks with independent live settings.
// The game's native R + D-pad object rotation and D-pad distance controls remain authoritative.
#include "gameplay_tweaks.h"
#include "cfg.h"
#include "host.h"
#include "input.h"
#include "input_map.h"
#include "input_wsys.h"
#include "platform/platform.h"
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define BIT(x) (1ull << (x))
#define HOLD_FRAMES 3
#define GAP_FRAMES 1
#define MAX_QUEUED 16
enum { NONE, ROTATE, DISTANCE, ITEMS, MAP_ZOOM, WEAPONS };
enum { W_IDLE = 0, W_PRIME, W_HOLD, W_GAP, W_WAIT };
#define WEAPON_PRIME_MIN_NS 75000000ull
#define WEAPON_PRIME_MAX_NS 135000000ull
#define WEAPON_HOLD_NS 42000000ull
#define WEAPON_GAP_NS 36000000ull
static PlatMutex lock = PLAT_MUTEX_INIT;
static unsigned seen = UINT_MAX;
static struct {
int available, rotate, c_axis, distance, wheel, keys, map_zoom, weapon_wheel;
double rotation_speed, distance_speed, item_speed, map_zoom_speed, weapon_speed;
} options;
static struct {
int kind, axis, direction, queued, hold, gap, primed, valid;
double fraction;
uint64_t frame, buttons;
int32_t rx;
} pulse;
static struct {
int active, phase, direction, scroll_dir, queued, polls_in_phase;
int confirm_pending;
double fraction;
uint64_t phase_until_ns, prime_start_ns, last_frame;
int32_t rx;
} weapon;
static double map_zoom_velocity;
static int held_a, held_d;
static int consumed_c, consumed_right;
static int was_e_down, consumed_e;
static uint64_t physical_buttons;
static void clear_weapon_locked(void) { memset(&weapon, 0, sizeof weapon); }
static void clear_locked(void) { memset(&pulse, 0, sizeof pulse); clear_weapon_locked(); map_zoom_velocity = 0; }
static void refresh_locked(void) {
unsigned version = cfg_version();
if (seen == version) return;
options.available = cfg_bool("TOTK_GAMEPLAY_TWEAKS_ENABLED");
options.rotate = cfg_bool("TOTK_GAMEPLAY_ULTRAHAND_ROTATE");
options.c_axis = cfg_bool("TOTK_GAMEPLAY_ULTRAHAND_C_AXIS");
options.distance = cfg_bool("TOTK_GAMEPLAY_ULTRAHAND_DISTANCE");
options.wheel = cfg_bool("TOTK_GAMEPLAY_ITEM_WHEEL");
options.keys = cfg_bool("TOTK_GAMEPLAY_ITEM_AD");
options.map_zoom = cfg_bool("TOTK_GAMEPLAY_MAP_ZOOM");
options.weapon_wheel = cfg_bool("TOTK_GAMEPLAY_WEAPON_WHEEL");
options.rotation_speed = cfg_double("TOTK_GAMEPLAY_ROTATION_SENSITIVITY");
options.distance_speed = cfg_double("TOTK_GAMEPLAY_DISTANCE_SENSITIVITY");
options.item_speed = cfg_double("TOTK_GAMEPLAY_ITEM_SENSITIVITY");
options.map_zoom_speed = cfg_double("TOTK_GAMEPLAY_MAP_ZOOM_SENSITIVITY");
options.weapon_speed = cfg_double("TOTK_GAMEPLAY_WEAPON_SENSITIVITY");
if (!isfinite(options.rotation_speed) || options.rotation_speed < .25 || options.rotation_speed > 4) options.rotation_speed = 1;
if (!isfinite(options.distance_speed) || options.distance_speed < .25 || options.distance_speed > 4) options.distance_speed = 1;
if (!isfinite(options.item_speed) || options.item_speed < .25 || options.item_speed > 4) options.item_speed = 1;
if (!isfinite(options.map_zoom_speed) || options.map_zoom_speed < .25 || options.map_zoom_speed > 4) options.map_zoom_speed = 1;
if (!isfinite(options.weapon_speed) || options.weapon_speed < .25 || options.weapon_speed > 4) options.weapon_speed = 1;
seen = version;
clear_locked();
}
static int item_menu(uint64_t buttons) {
if (buttons & BIT(B_L)) return 0;
const uint64_t held = BIT(B_LEFT) | BIT(B_UP) | BIT(B_RIGHT) | BIT(B_DOWN);
return input_camera_context() == INPUT_CAM_MENU_WHEEL || (buttons & held) != 0;
}
static int object_context(uint64_t buttons) {
const uint64_t menus = BIT(B_L) | BIT(B_LEFT) | BIT(B_UP) | BIT(B_RIGHT) | BIT(B_DOWN) |
BIT(B_B) | BIT(B_PLUS) | BIT(B_MINUS);
return input_camera_context() == INPUT_CAM_ULTRAHAND_OBJECT && !(buttons & menus);
}
static int map_zoom_allowed(uint64_t buttons) {
if (!options.map_zoom) return 0;
if (object_context(buttons) || item_menu(buttons)) return 0;
if (buttons & (BIT(B_L) | BIT(B_ZL) | BIT(B_ZR) | BIT(B_R))) return 0;
int ctx = input_camera_context();
if (ctx == INPUT_CAM_AIM || ctx == INPUT_CAM_SCOPE ||
ctx == INPUT_CAM_ULTRAHAND_OBJECT || ctx == INPUT_CAM_LOCK_ON) {
return 0;
}
// Only the map menu_cursor.c finds: with menu_cursor = 0 (or on 1.2.1) the map is not read, and a fallback to
// "allowed" would push the right stick's Y in free roam, where it tilts the camera.
return menu_cursor_map();
}
static int weapon_wheel_allowed(uint64_t buttons, int right_down, int already_active) {
if (!options.available || !options.weapon_wheel) return 0;
if (right_down) return 0;
if (!ikb_captured() || menu_cursor_map() || menu_cursor_pointer()) return 0;
const uint64_t forbidden = BIT(B_L) | BIT(B_R) | BIT(B_ZL) | BIT(B_ZR) |
BIT(B_LEFT) | BIT(B_UP) | BIT(B_RIGHT) | BIT(B_DOWN) |
BIT(B_PLUS) | BIT(B_MINUS);
if (buttons & forbidden) return 0;
if (!already_active) {
if (menu_cursor_shortcut() == 1 || menu_cursor_strip() || menu_cursor_camera() || menu_cursor_menu())
return 0;
}
int ctx = input_camera_context();
if (!already_active) {
// Opening needs a camera the mouse_direct hooks saw this moment: an unclassified one is also a paused menu,
// 1.2.1's menus or any screen menu_cursor.c does not read, where D-pad right and the right stick would move
// the menu instead.
if (ctx != INPUT_CAM_FREE_ROAM && ctx != INPUT_CAM_LOCK_ON && ctx != INPUT_CAM_VEHICLE)
return 0;
} else {
if (ctx != INPUT_CAM_UNCLASSIFIED && ctx != INPUT_CAM_MENU_WHEEL &&
ctx != INPUT_CAM_FREE_ROAM && ctx != INPUT_CAM_LOCK_ON && ctx != INPUT_CAM_VEHICLE)
return 0;
}
return 1;
}
int gameplay_tweaks_available(void) {
plat_mutex_lock(&lock);
refresh_locked();
int available = options.available;
plat_mutex_unlock(&lock);
return available;
}
int gameplay_tweaks_capture_needed(void) {
plat_mutex_lock(&lock);
refresh_locked();
int active = options.available && (options.rotate || options.distance || options.wheel ||
options.keys || options.map_zoom || options.weapon_wheel);
plat_mutex_unlock(&lock);
return active;
}
int gameplay_tweaks_map_zoom(void) {
plat_mutex_lock(&lock);
refresh_locked();
int active = options.available && options.map_zoom;
plat_mutex_unlock(&lock);
return active;
}
int gameplay_tweaks_strip_wheel(uint64_t buttons) {
plat_mutex_lock(&lock);
refresh_locked();
int active = options.available && (weapon.active || (options.wheel && item_menu(buttons)));
plat_mutex_unlock(&lock);
return active;
}
void gameplay_tweaks_init(void) {
gameplay_tweaks_available();
}
void gameplay_tweaks_reset(void) {
plat_mutex_lock(&lock);
clear_locked();
held_a = held_d = 0;
physical_buttons = 0;
was_e_down = consumed_e = 0;
plat_mutex_unlock(&lock);
}
void gameplay_tweaks_wheel(double delta, int c_down, int right_down) {
if (!isfinite(delta) || delta == 0) return;
if (delta > MAX_QUEUED) delta = MAX_QUEUED;
if (delta < -MAX_QUEUED) delta = -MAX_QUEUED;
plat_mutex_lock(&lock);
refresh_locked();
if (!options.available) {
clear_locked();
plat_mutex_unlock(&lock);
return;
}
int kind = NONE, axis = 0;
double sensitivity = 1;
if (object_context(physical_buttons)) {
if (right_down && options.distance) {
kind = DISTANCE;
sensitivity = options.distance_speed;
} else if (options.rotate) {
kind = ROTATE;
axis = options.c_axis && c_down;
sensitivity = options.rotation_speed;
}
} else if ((physical_buttons & (BIT(B_LEFT) | BIT(B_UP) | BIT(B_RIGHT) | BIT(B_DOWN))) &&
options.wheel && item_menu(physical_buttons)) {
kind = ITEMS;
sensitivity = options.item_speed;
} else if (map_zoom_allowed(physical_buttons)) {
kind = MAP_ZOOM;
sensitivity = options.map_zoom_speed;
} else if (weapon_wheel_allowed(physical_buttons, right_down, weapon.active)) {
kind = WEAPONS;
}
if (!kind) {
clear_locked();
plat_mutex_unlock(&lock);
return;
}
if (kind == MAP_ZOOM) {
if (weapon.active) clear_weapon_locked();
map_zoom_velocity -= delta * sensitivity * 16000.0;
if (map_zoom_velocity > 65536.0) map_zoom_velocity = 65536.0;
if (map_zoom_velocity < -65536.0) map_zoom_velocity = -65536.0;
plat_mutex_unlock(&lock);
return;
}
if (kind == WEAPONS) {
uint64_t now = plat_now_ns();
int new_dir = delta > 0 ? 1 : -1;
if (weapon.scroll_dir != 0 && new_dir != weapon.scroll_dir) {
weapon.fraction = 0;
weapon.queued = 0;
if (weapon.active && weapon.phase == W_HOLD) {
weapon.phase = W_GAP;
weapon.rx = 0;
weapon.polls_in_phase = 0;
weapon.phase_until_ns = now + WEAPON_GAP_NS;
}
}
weapon.scroll_dir = new_dir;
weapon.fraction += delta * options.weapon_speed;
int steps = (int)trunc(weapon.fraction);
if (steps != 0) {
weapon.confirm_pending = 0;
weapon.fraction -= steps;
weapon.direction = steps > 0 ? 1 : -1;
weapon.queued += (steps > 0 ? steps : -steps);
if (weapon.queued > MAX_QUEUED) weapon.queued = MAX_QUEUED;
if (!weapon.active) {
weapon.active = 1;
weapon.phase = W_PRIME;
weapon.polls_in_phase = 0;
weapon.prime_start_ns = now;
weapon.phase_until_ns = now + WEAPON_PRIME_MAX_NS;
weapon.rx = 0;
} else if (weapon.phase == W_WAIT) {
weapon.phase = W_HOLD;
weapon.polls_in_phase = 0;
weapon.phase_until_ns = now + WEAPON_HOLD_NS;
weapon.rx = 32767 * weapon.direction;
if (weapon.queued > 0) weapon.queued--;
}
}
plat_mutex_unlock(&lock);
return;
}
if (weapon.active) clear_weapon_locked();
if (kind != pulse.kind || axis != pulse.axis ||
(delta > 0 && pulse.direction < 0) || (delta < 0 && pulse.direction > 0)) {
clear_locked();
}
pulse.kind = kind;
pulse.axis = axis;
pulse.fraction += delta * sensitivity;
int steps = (int)trunc(pulse.fraction);
if (steps) {
pulse.fraction -= steps;
pulse.direction = steps > 0 ? 1 : -1;
if (!pulse.queued && !pulse.hold && !pulse.gap) pulse.valid = 0;
pulse.queued += steps > 0 ? steps : -steps;
if (pulse.queued > MAX_QUEUED) pulse.queued = MAX_QUEUED;
}
plat_mutex_unlock(&lock);
}
void gameplay_tweaks_prepare_keys(uint8_t *down, uint64_t pad_buttons) {
plat_mutex_lock(&lock);
refresh_locked();
held_a = held_d = 0;
int c = down[KEY_C], right = down[KEY_MOUSE_R];
int e = down[KEY_E];
int e_pressed = e && !was_e_down;
was_e_down = e;
if (!e) consumed_e = 0;
if (!c) consumed_c = 0;
if (!right) consumed_right = 0;
if (options.available) {
if (input_camera_context() == INPUT_CAM_ULTRAHAND_OBJECT) {
if (options.rotate && options.c_axis && !(options.distance && right) && c) consumed_c = 1;
if (options.distance && right) consumed_right = 1;
if (pulse.kind == ROTATE && pulse.axis != (options.c_axis && c)) clear_locked();
}
if (weapon.active && e_pressed) {
consumed_e = 1;
weapon.confirm_pending = 1;
}
if (consumed_e) down[KEY_E] = 0;
if (consumed_c) down[KEY_C] = 0;
if (consumed_right) down[KEY_MOUSE_R] = 0;
uint64_t buttons = pad_buttons | input_map_buttons(down);
if (options.keys && item_menu(buttons) && !weapon.active) {
held_a = down[KEY_A];
held_d = down[KEY_D];
down[KEY_A] = down[KEY_D] = 0;
}
} else {
consumed_c = consumed_right = consumed_e = 0;
}
plat_mutex_unlock(&lock);
}
static void sample_locked(uint64_t frame) {
if (pulse.valid && pulse.frame == frame) return;
pulse.buttons = 0;
pulse.rx = 0;
if (pulse.queued || pulse.hold || pulse.gap) {
if (pulse.kind == ROTATE) pulse.buttons = BIT(B_R);
if (pulse.kind == ROTATE && !pulse.primed) pulse.primed = 1;
else if (pulse.gap) pulse.gap--;
else {
if (!pulse.hold && pulse.queued) {
pulse.queued--;
pulse.hold = HOLD_FRAMES;
}
if (pulse.hold) {
if (pulse.kind == ROTATE)
pulse.buttons |= pulse.axis ? (pulse.direction > 0 ? BIT(B_DOWN) : BIT(B_UP)) :
(pulse.direction > 0 ? BIT(B_RIGHT) : BIT(B_LEFT));
else if (pulse.kind == DISTANCE)
pulse.buttons = pulse.direction < 0 ? BIT(B_UP) : BIT(B_DOWN);
else pulse.rx = 32767 * pulse.direction;
if (!--pulse.hold) pulse.gap = GAP_FRAMES;
}
}
} else pulse.primed = 0;
pulse.valid = 1;
pulse.frame = frame;
}
void gameplay_tweaks_apply(uint64_t frame, int active, uint64_t *buttons,
int32_t *lx, int32_t *ly, int32_t *rx, int32_t *ry) {
(void)lx;
(void)ly;
plat_mutex_lock(&lock);
refresh_locked();
physical_buttons = *buttons;
if (!active || !options.available) {
clear_locked();
held_a = held_d = 0;
plat_mutex_unlock(&lock);
return;
}
int right = ikb_down(KEY_MOUSE_R);
if (weapon.active) {
if (!weapon_wheel_allowed(physical_buttons, right, 1) || (physical_buttons & BIT(B_B))) {
clear_weapon_locked();
}
}
if (weapon.active) {
uint64_t now = plat_now_ns();
if (weapon.last_frame != frame) {
weapon.last_frame = frame;
weapon.polls_in_phase++;
}
switch (weapon.phase) {
case W_PRIME: {
uint64_t elapsed = now - weapon.prime_start_ns;
int shortcut = (menu_cursor_shortcut() == 1);
int ready = (elapsed >= WEAPON_PRIME_MIN_NS && weapon.polls_in_phase >= 3 && shortcut) ||
(elapsed >= WEAPON_PRIME_MAX_NS && weapon.polls_in_phase >= 4);
if (ready) {
if (weapon.queued > 0) {
weapon.phase = W_HOLD;
weapon.polls_in_phase = 0;
weapon.phase_until_ns = now + WEAPON_HOLD_NS;
weapon.rx = 32767 * weapon.direction;
weapon.queued--;
} else if (weapon.confirm_pending) {
clear_weapon_locked();
} else {
weapon.phase = W_WAIT;
weapon.polls_in_phase = 0;
weapon.rx = 0;
}
}
break;
}
case W_HOLD: {
if (now >= weapon.phase_until_ns && weapon.polls_in_phase >= 2) {
weapon.phase = W_GAP;
weapon.polls_in_phase = 0;
weapon.phase_until_ns = now + WEAPON_GAP_NS;
weapon.rx = 0;
}
break;
}
case W_GAP: {
if (now >= weapon.phase_until_ns && weapon.polls_in_phase >= 2) {
if (weapon.queued > 0) {
weapon.phase = W_HOLD;
weapon.polls_in_phase = 0;
weapon.phase_until_ns = now + WEAPON_HOLD_NS;
weapon.rx = 32767 * weapon.direction;
weapon.queued--;
} else if (weapon.confirm_pending) {
clear_weapon_locked();
} else {
weapon.phase = W_WAIT;
weapon.polls_in_phase = 0;
weapon.rx = 0;
}
}
break;
}
case W_WAIT: {
if (weapon.confirm_pending) {
clear_weapon_locked();
}
break;
}
default:
clear_weapon_locked();
break;
}
}
if (weapon.active) {
*buttons |= BIT(B_RIGHT);
*rx = weapon.rx;
*ry = 0;
} else {
int object = object_context(*buttons), items = item_menu(*buttons);
if ((pulse.kind == ROTATE && (!object || !options.rotate || (right && options.distance))) ||
(pulse.kind == DISTANCE && (!object || !right || !options.distance)) ||
(pulse.kind == ITEMS && (!items || !options.wheel))) {
clear_locked();
}
sample_locked(frame);
if (!map_zoom_allowed(*buttons)) {
map_zoom_velocity = 0;
} else if (fabs(map_zoom_velocity) > 50.0) {
int32_t stick_y = (int32_t)map_zoom_velocity;
if (stick_y > 32767) stick_y = 32767;
if (stick_y < -32767) stick_y = -32767;
if (abs(stick_y) > abs(*ry)) *ry = stick_y;
map_zoom_velocity *= 0.78;
if (fabs(map_zoom_velocity) < 100.0) map_zoom_velocity = 0;
}
if (pulse.kind == ROTATE || pulse.kind == DISTANCE) {
*buttons |= pulse.buttons;
// Distance D-pad pulses do not own the look stick. R rotation does,
// because the game's rotation mode would otherwise rotate both axes.
if (pulse.kind == ROTATE && pulse.buttons) *rx = *ry = 0;
} else if (pulse.kind == ITEMS && (pulse.queued || pulse.hold || pulse.gap || pulse.rx)) {
*rx = pulse.rx;
*ry = 0;
} else if (items && options.keys && (held_a || held_d)) {
*rx = ((held_d != 0) - (held_a != 0)) * 32767;
*ry = 0;
}
}
plat_mutex_unlock(&lock);
}
+14
View File
@@ -0,0 +1,14 @@
// Mouse wheel and keyboard gameplay tweaks: Ultrahand rotation and distance, item and weapon wheel, map zoom.
#pragma once
#include <stdint.h>
int gameplay_tweaks_available(void);
int gameplay_tweaks_capture_needed(void);
int gameplay_tweaks_map_zoom(void);
int gameplay_tweaks_strip_wheel(uint64_t buttons);
void gameplay_tweaks_init(void);
void gameplay_tweaks_reset(void);
void gameplay_tweaks_wheel(double delta, int c_down, int right_down);
void gameplay_tweaks_prepare_keys(uint8_t *down, uint64_t pad_buttons);
void gameplay_tweaks_apply(uint64_t frame, int active, uint64_t *buttons,
int32_t *lx, int32_t *ly, int32_t *rx, int32_t *ry);
+6
View File
@@ -24,6 +24,12 @@ uint64_t gfx_vsync_time_ns(uint64_t tick); // kern_now_ns() time
double gfx_window_refresh_hz(void); // refresh rate of the window's monitor; 0 unknown
int gfx_window_focused(void);
int gfx_picture_rect(float out[4]); // where the last present put the picture, fractions of the swapchain (x, y, w, h); 0 before one
// NVIDIA Reflex (gfx_present.c, VK_NV_low_latency2): the NVN front end and the input service mark a frame's stages.
// The markers and the sleep return at once with Reflex off or unsupported.
void vk_reflex_marker(int marker, uint64_t present_id); // present_id: the frame's (vk_reflex_frame_begin)
uint64_t vk_reflex_frame_begin(void); // SIMULATION_START: the new frame's present ID
uint64_t vk_reflex_frame(void); // the ID of the frame the game simulates now
void vk_reflex_sleep(void); // before SIMULATION_START: the driver's latency sleep
// ---- shader service client (gfx_shader.c)
enum { GFX_STAGE_VS, GFX_STAGE_TCS, GFX_STAGE_TES, GFX_STAGE_GS, GFX_STAGE_FS, GFX_STAGE_CS };
+214 -3
View File
@@ -239,6 +239,8 @@ unsigned gfx_window_focus_messages(void) { return (unsigned)g_focus_msgs; }
// Present path (g_pl held): a settings change (cfg_version) reaches the window thread, which applies a changed size or
// fullscreen; a changed TOTK_VK_PRESENT rebuilds the swapchain at this present.
static void reflex_apply_locked(void);
static void window_settings_live(void) {
static unsigned seen;
static int started;
@@ -254,9 +256,185 @@ static void window_settings_live(void) {
if (started) plat_xchg32(&g_dirty, 1);
}
if (started) gfx_window_apply_settings();
reflex_apply_locked();
started = 1;
}
// ---- NVIDIA Reflex Low Latency (VK_NV_low_latency2)
static PFN_vkSetLatencySleepModeNV g_reflex_set_mode;
static PFN_vkLatencySleepNV g_reflex_sleep;
static PFN_vkSetLatencyMarkerNV g_reflex_marker;
static VkSemaphore g_reflex_sem;
static uint64_t g_reflex_val;
// Present IDs (VK_KHR_present_id, VK_NV_low_latency2): each frame gets its ID once, when the game acquires its window
// texture (SIMULATION_START, vk_reflex_frame_begin), and the frame carries it to its input sample, its submissions
// (vk_reflex_submit_id: the game thread's current frame, or the frame a replay or present thread set for the work it
// does) and its present (PresentJob.pid, vk_reflex_present_frame, flip_locked), so the driver can match every marker
// of a frame to the present of that frame.
static uint64_t g_reflex_frame_next; // the last ID handed out
static uint64_t g_reflex_frame; // the frame the game simulates now
static _Thread_local uint64_t t_reflex_submit; // the frame whose work this thread submits; 0: g_reflex_frame
static uint64_t g_blit_pid, g_flip_pid; // the frame of the blit being made and of the present waiting (g_pl)
static uint64_t g_last_pid; // the last present ID presented (g_pl): present IDs only go up
static int g_reflex_mode = -1; // 0=off, 1=on, 2=boost
static uint32_t g_reflex_min_us = 1;
static int reflex_mode_from_cfg(void) {
const char *v = cfg_value("TOTK_REFLEX");
if (!v || !strcmp(v, "off") || !strcmp(v, "0")) return 0;
if (!strcmp(v, "boost") || !strcmp(v, "2")) return 2;
return 1;
}
static void reflex_apply_locked(void) {
VkCtx *c = vk_ctx();
if (!c || !c->has_nv_reflex || !g_sc) return;
if (!g_reflex_set_mode) {
g_reflex_set_mode = (PFN_vkSetLatencySleepModeNV)vkGetDeviceProcAddr(c->device, "vkSetLatencySleepModeNV");
g_reflex_sleep = (PFN_vkLatencySleepNV)vkGetDeviceProcAddr(c->device, "vkLatencySleepNV");
g_reflex_marker = (PFN_vkSetLatencyMarkerNV)vkGetDeviceProcAddr(c->device, "vkSetLatencyMarkerNV");
}
if (!g_reflex_set_mode) return;
if (!g_reflex_sem) {
VkSemaphoreTypeCreateInfo ti = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
.initialValue = 0
};
VkSemaphoreCreateInfo si = {.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, .pNext = &ti};
if (vkCreateSemaphore(c->device, &si, NULL, &g_reflex_sem) != VK_SUCCESS) return;
}
int mode = reflex_mode_from_cfg();
uint32_t min_us = 0;
int limit = cfg_int("TOTK_FPS_LIMIT");
if (limit > 0) min_us = (uint32_t)(1000000 / limit);
if (mode == g_reflex_mode && min_us == g_reflex_min_us) return;
g_reflex_mode = mode;
g_reflex_min_us = min_us;
VkLatencySleepModeInfoNV mi = {
.sType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV,
.lowLatencyMode = mode > 0 ? VK_TRUE : VK_FALSE,
.lowLatencyBoost = mode == 2 ? VK_TRUE : VK_FALSE,
.minimumIntervalUs = min_us
};
VkResult r = g_reflex_set_mode(c->device, g_sc, &mi);
rt_log("REFLEX: NVIDIA Reflex Low Latency -> %s (minInterval=%u us, VK_NV_low_latency2=%s)",
mode == 2 ? "ON + BOOST" : mode == 1 ? "ON" : "OFF", min_us, r == VK_SUCCESS ? "OK" : "ERR");
}
int vk_has_reflex(void) {
VkCtx *c = vk_ctx();
return c && c->has_nv_reflex;
}
// TOTK_TRACE=perf, every LAT_EVERY presents: the time from a frame's start (its window texture acquired) to its
// present call on the host, with Reflex off or on, and with Reflex on the driver's own reports of the same frames
// (vkGetLatencyTimingsNV): how many came back with every marker matched to their present, and their simulation start
// to GPU render end. The frame's start is kept by its ID, so it also shows that a present carries its frame's ID.
#define LAT_RING 64
#define LAT_EVERY 600
static struct { uint64_t id, start_ns; } g_lat_start[LAT_RING];
static struct { uint64_t n, ns, presents; } g_lat;
static PFN_vkGetLatencyTimingsNV g_reflex_timings;
uint64_t vk_reflex_frame_begin(void) {
uint64_t id = __atomic_add_fetch(&g_reflex_frame_next, 1, __ATOMIC_RELAXED);
__atomic_store_n(&g_reflex_frame, id, __ATOMIC_RELAXED);
if (rt_trace & RT_TRACE_PERF) g_lat_start[id % LAT_RING].start_ns = kern_now_ns(), g_lat_start[id % LAT_RING].id = id;
return id;
}
// g_pl held, after the present of frame pid
static void latency_note(VkCtx *c, uint64_t pid) {
if (!(rt_trace & RT_TRACE_PERF) || !pid) return;
if (g_lat_start[pid % LAT_RING].id == pid) g_lat.n++, g_lat.ns += kern_now_ns() - g_lat_start[pid % LAT_RING].start_ns;
if (++g_lat.presents % LAT_EVERY) return;
char drv[200] = "";
if (g_reflex_mode > 0 && g_sc) {
if (!g_reflex_timings) g_reflex_timings = (PFN_vkGetLatencyTimingsNV)vkGetDeviceProcAddr(c->device, "vkGetLatencyTimingsNV");
static VkLatencyTimingsFrameReportNV rep[64];
VkGetLatencyMarkerInfoNV gi = {.sType = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV};
if (g_reflex_timings) {
g_reflex_timings(c->device, g_sc, &gi); // the count first
if (gi.timingCount > 64) gi.timingCount = 64;
for (uint32_t i = 0; i < gi.timingCount; i++)
rep[i] = (VkLatencyTimingsFrameReportNV){.sType = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV};
gi.pTimings = rep;
if (gi.timingCount) g_reflex_timings(c->device, g_sc, &gi);
uint32_t full = 0;
double sum = 0;
for (uint32_t i = 0; i < gi.timingCount; i++) {
const VkLatencyTimingsFrameReportNV *r = &rep[i];
if (r->simStartTimeUs && r->simEndTimeUs && r->renderSubmitStartTimeUs && r->presentStartTimeUs &&
r->gpuRenderEndTimeUs > r->simStartTimeUs)
full++, sum += (double)(r->gpuRenderEndTimeUs - r->simStartTimeUs);
}
snprintf(drv, sizeof drv, "; driver reports: %u of %u frames with every marker, simulation start to GPU render "
"end %.2f ms", full, gi.timingCount, full ? sum / full / 1000.0 : 0.0);
}
}
rt_log("reflex: frame start to present %.2f ms over %llu frames (reflex %s)%s", g_lat.n ? g_lat.ns / 1e6 / g_lat.n : 0.0,
(unsigned long long)g_lat.n, g_reflex_mode == 2 ? "boost" : g_reflex_mode == 1 ? "on" : "off", drv);
g_lat.n = g_lat.ns = 0;
}
uint64_t vk_reflex_frame(void) { return __atomic_load_n(&g_reflex_frame, __ATOMIC_RELAXED); }
void vk_reflex_submit_frame(uint64_t id) { t_reflex_submit = id; }
uint64_t vk_reflex_submit_id(void) { return t_reflex_submit ? t_reflex_submit : vk_reflex_frame(); }
// The present thread, before the blit of frame id: the present of that blit carries id.
void vk_reflex_present_frame(uint64_t id) {
// g_blit_pid feeds flip_locked's VkPresentIdKHR (Reflex) and latency_note (TOTK_TRACE=perf); with neither, the
// present skips the lock
if (!vk_has_reflex() && !(rt_trace & RT_TRACE_PERF)) return;
plat_rmutex_lock(&g_pl);
g_blit_pid = id;
plat_rmutex_unlock(&g_pl);
}
void vk_reflex_marker(int marker, uint64_t pid) {
VkCtx *c = vk_ctx();
if (!c || !c->has_nv_reflex || !g_reflex_marker || g_reflex_mode <= 0 || !g_sc || !pid) return;
plat_rmutex_lock(&g_pl);
if (g_sc && g_reflex_marker) {
VkSetLatencyMarkerInfoNV mi = {
.sType = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV,
.presentID = pid,
.marker = (VkLatencyMarkerNV)marker
};
g_reflex_marker(c->device, g_sc, &mi);
}
plat_rmutex_unlock(&g_pl);
}
void vk_reflex_sleep(void) {
VkCtx *c = vk_ctx();
if (!c || !c->has_nv_reflex || !g_reflex_sleep || !g_reflex_sem || g_reflex_mode <= 0 || !g_sc) return;
uint64_t val = __atomic_add_fetch(&g_reflex_val, 1, __ATOMIC_RELAXED);
VkLatencySleepInfoNV si = {
.sType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV,
.signalSemaphore = g_reflex_sem,
.value = val
};
// vkLatencySleepNV uses the swapchain, which Vulkan wants externally synchronised with the acquire and the present
// (they run under g_pl on the present thread). The wait for the semaphore stays outside the lock.
VkResult r = VK_ERROR_INITIALIZATION_FAILED;
plat_rmutex_lock(&g_pl);
if (g_sc) r = g_reflex_sleep(c->device, g_sc, &si);
plat_rmutex_unlock(&g_pl);
if (r == VK_SUCCESS) {
VkSemaphoreWaitInfo wi = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
.semaphoreCount = 1,
.pSemaphores = &g_reflex_sem,
.pValues = &val
};
vkWaitSemaphores(c->device, &wi, 100000000ULL);
}
}
// ---- swapchain
static const char *g_present_got = ""; // the TOTK_VK_PRESENT value of the mode the swapchain got; "" before one
@@ -289,12 +467,29 @@ static void flip_locked(void) {
if (!g_flip_on) return;
g_flip_on = 0;
if (!g_sc) return;
VkPresentInfoKHR pi = {.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, .waitSemaphoreCount = 1,
VkCtx *c = vk_ctx();
uint64_t pid = 0;
VkPresentIdKHR pid_info = {0};
if (c && c->has_nv_reflex) {
// The frame's own ID; a present without one (a probe, a skipped frame's neighbour) takes the next free value,
// as present IDs must grow on a swapchain
pid = g_flip_pid > g_last_pid ? g_flip_pid : g_last_pid + 1;
g_last_pid = pid;
pid_info.sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
pid_info.swapchainCount = 1;
pid_info.pPresentIds = &pid;
vk_reflex_marker(4, pid); // VK_LATENCY_MARKER_PRESENT_START_NV
}
VkPresentInfoKHR pi = {.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
.pNext = (c && c->has_nv_reflex) ? &pid_info : NULL,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &g_render_done[g_flip_idx], .swapchainCount = 1, .pSwapchains = &g_sc,
.pImageIndices = &g_flip_idx};
vk_queue_lock();
VkResult r = vkQueuePresentKHR(vk_ctx()->gfx_queue, &pi);
VkResult r = vkQueuePresentKHR(c->gfx_queue, &pi);
vk_queue_unlock();
if (c && c->has_nv_reflex) vk_reflex_marker(5, pid); // VK_LATENCY_MARKER_PRESENT_END_NV
if (c) latency_note(c, pid ? pid : g_flip_pid);
vk_device_fault_report(r);
if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_SUBOPTIMAL_KHR) plat_xchg32(&g_dirty, 1);
}
@@ -338,8 +533,14 @@ static int build_swapchain(void) {
vk_queue_lock();
vkDeviceWaitIdle(c->device);
VkSwapchainKHR old = g_sc;
VkSwapchainLatencyCreateInfoNV sci = {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV,
.latencyModeEnable = VK_TRUE
};
VkSwapchainCreateInfoKHR ci = {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, .surface = g_surface, .minImageCount = count,
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.pNext = (c->has_nv_reflex) ? &sci : NULL,
.surface = g_surface, .minImageCount = count,
.imageFormat = sf.format, .imageColorSpace = sf.colorSpace, .imageExtent = ext, .imageArrayLayers = 1,
.imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // every surface supports it (the menu overlay draws into it)
@@ -376,6 +577,10 @@ static int build_swapchain(void) {
}
free_capture();
vk_queue_unlock();
// The Reflex sleep mode belongs to the swapchain: a new one (resize, fullscreen, out of date) starts with low
// latency off, so the mode is set on it again even though the setting did not change.
g_reflex_mode = -1;
reflex_apply_locked();
return 1;
}
@@ -746,6 +951,7 @@ static void present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w
if (r == VK_SUCCESS) {
g_flip_on = 1;
g_flip_idx = idx;
g_flip_pid = g_blit_pid; // the frame this blit shows (vk_reflex_present_frame)
if (!defer) flip_locked();
} else {
vk_device_fault_report(r);
@@ -800,6 +1006,11 @@ void gfx_window_release_vk(void) {
vk_color_release();
vk_hdr_release();
vk_contact_release();
if (g_reflex_sem) {
vkDestroySemaphore(c->device, g_reflex_sem, NULL);
g_reflex_sem = VK_NULL_HANDLE;
}
g_reflex_mode = -1;
free_capture();
free_thumbs();
for (int i = 0; i < FRAMES; i++) {
+1004 -284
View File
File diff suppressed because it is too large. Load diff
+2
View File
@@ -279,6 +279,8 @@ int cam_pack_build(const void *in, size_t n, const void *zsdic, size_t zsdic_n,
// multiplied, malloc'd; 0 = factor 1 or cannot (logged)
void cam_pack_served(void); // romfs.c serves the multiplied pack
// ---- game resolution (resolution.c): TOTK_OUTPUT_RES, TOTK_RENDER_SCALE
uint64_t res_grass_heap_extra_kib(void); // TOTK_GRASS_RANGE: added to the HeapDef grass heap; 0 = none
uint64_t res_grass_heap_extra_bytes(void); // the same, added to the application pool, 2 MiB steps
uint64_t res_heap_extra_bytes(void); // added to the application pool (mem_init), 2 MiB steps
uint64_t res_heap_extra_kib(void); // added to the HeapDef texture heap and its parent; 0 = none
uint64_t res_tex_heap_extra_bytes(void); // TOTK_TEX_HEAP_EXTRA_MB: added to the application pool and
+124 -25
View File
@@ -21,6 +21,7 @@
#include "ui/menu.h"
#include "vk.h"
#include "platform/platform.h"
#include "gameplay_tweaks.h"
enum { STICK_MAX = 32767, STICK_DIR = 16384, TRIGGER_ON = 16384, RESCAN_MS = 1000 };
@@ -33,6 +34,7 @@ static volatile int32_t g_block, g_menu; // text entry / host menu: 0 off, 1 o
enum { PAD_USED = 16384, MOUSE_USED = 6 };
static volatile int32_t g_kbm_last = 1;
int input_kbm_last(void) { return __atomic_load_n(&g_kbm_last, __ATOMIC_RELAXED); }
int input_gameplay_active(void) { return !g_menu && !g_block && ikb_foreground() && ikb_captured(); }
static SDL_Gamepad *pad;
static uint64_t next_scan;
static int pad_rumble; // the open gamepad has rumble motors
@@ -57,7 +59,8 @@ static const SDL_GamepadButton pad_sdl[PAD_COUNT] = {
[PAD_LPADDLE2] = SDL_GAMEPAD_BUTTON_LEFT_PADDLE2, [PAD_RPADDLE2] = SDL_GAMEPAD_BUTTON_RIGHT_PADDLE2,
};
// TOTK_INPUT_SCRIPT=<file>: lines "<frame> <button> [hold]" or "<frame> LSTICK|RSTICK <x> <y> [hold]", ORed into the real input.
// TOTK_INPUT_SCRIPT=<file>: lines "<frame> <button> [hold]", "<frame> LSTICK|RSTICK <x> <y> [hold]", "<frame> MOUSE
// <dx> <dy>" or "<frame> WHEEL <notches>" (+ away from the player), ORed into the real input.
// <frame> and its hold are 60 Hz ticks of game time since the first present (frame_step_ticks: presents at 60 fps), so
// the title menus get the presses at the same game time at any frame limit. A line "@<ms> ..." is timed instead: <ms>
// and its hold are milliseconds of the world clock (frame_step_world_us, game time since the loaded save's first
@@ -74,6 +77,7 @@ static ScriptEv *script_ev;
static int script_n, script_state; // 0 not loaded, 1 loaded
static int script_mixed; // the script has timed lines: its untimed ones end where the world clock starts
static int32_t script_mouse[2]; // one-shot raw counts, consumed by the camera hook; under lock
static int32_t script_wheel; // one-shot wheel notches, taken with the real ones (wheel_stick); under lock
static void script_load(void) {
script_state = 1;
@@ -96,7 +100,11 @@ static void script_load(void) {
ScriptEv e = {.at = (uint64_t)(at * unit + 0.5), .hold = timed ? 66667 : 4, .bit = -1, .timed = timed};
long a, b;
double c;
if (!strcmp(name, "MOUSE") || !strcmp(name, "LSTICK") || !strcmp(name, "RSTICK")) {
if (!strcmp(name, "WHEEL")) {
if (sscanf(line + off, "%ld", &a) != 1) { rt_log("input: script line %d: WHEEL needs notches", ln); continue; }
e.stick = 4, e.x = (int32_t)a, e.hold = 1; // one turn, never held
snprintf(e.text, sizeof e.text, "WHEEL %d", e.x);
} else if (!strcmp(name, "MOUSE") || !strcmp(name, "LSTICK") || !strcmp(name, "RSTICK")) {
int n = sscanf(line + off, "%ld %ld %lf", &a, &b, &c);
if (n < 2) { rt_log("input: script line %d: %s needs x y [hold]", ln, name); continue; }
e.stick = name[0] == 'M' ? 3 : name[0] == 'L' ? 1 : 2; e.x = (int32_t)a; e.y = (int32_t)b;
@@ -131,14 +139,17 @@ static void script_apply(uint64_t *b, int32_t sl[2], int32_t sr[2]) {
ScriptEv *e = &script_ev[i];
if (e->timed ? w < 0 : script_mixed && w >= 0) continue;
uint64_t now = e->timed ? (uint64_t)w : tick;
if (now < e->at || (now >= e->at + e->hold && (e->logged || !e->timed))) continue;
if (e->stick == 3 && e->logged) continue;
// A one-shot (MOUSE, WHEEL) goes in at the first poll at or after its time: a poll that skips a tick (the
// game below 60 fps) would otherwise lose it
if (e->stick >= 3 ? e->logged || now < e->at
: now < e->at || (now >= e->at + e->hold && (e->logged || !e->timed))) continue;
if (!e->logged) {
e->logged = 1;
if (e->timed) rt_log("input: script frame %llu at %.1f ms: %s", (unsigned long long)fr, w / 1000.0, e->text);
else rt_log("input: script frame %llu tick %llu: %s", (unsigned long long)fr, (unsigned long long)tick, e->text);
}
if (e->stick == 3) {
if (e->stick == 4) script_wheel += e->x;
else if (e->stick == 3) {
int64_t x = (int64_t)script_mouse[0] + e->x, y = (int64_t)script_mouse[1] + e->y;
script_mouse[0] = (int32_t)(x < INT32_MIN ? INT32_MIN : x > INT32_MAX ? INT32_MAX : x);
script_mouse[1] = (int32_t)(y < INT32_MIN ? INT32_MIN : y > INT32_MAX ? INT32_MAX : y);
@@ -261,6 +272,17 @@ void input_direct_mouse_sample(int enabled, int32_t *dx, int32_t *dy) {
plat_mutex_unlock(&lock);
}
// A turn of the real wheel as a WHEEL line of the recording (one-shot, as a MOUSE line). Under lock.
static void rec_wheel(int32_t notches) {
if (rec_state != 1) return;
char what[32];
snprintf(what, sizeof what, "WHEEL %d", notches);
int64_t w = frame_step_world_us();
uint64_t tick = frame_step_ticks();
rec_line(tick, w, tick + 1, w, what);
fflush(rec);
}
static float mouse_sens = -1; // TOTK_MOUSE_SENS, 0 = mouse camera off; live (cfg_version)
static unsigned mouse_sens_seen;
@@ -541,35 +563,86 @@ static int32_t shake_stick(int held) {
return (now - from) / SHAKE_SIDE_NS % 2 ? STICK_MAX : -STICK_MAX;
}
// The scroll wheel on the Purah Pad's map, which zooms with the right stick's y (up: in): each notch is a full-tilt
// pulse of MAP_ZOOM_PULSE_NS on that stick with MAP_ZOOM_GAP_NS of neutral after it, so a step of the zoom and a
// held zoom both see one notch as one push. A fast scroll's notches wait their turn (at most MAP_ZOOM_QUEUE), a turn the
// other way drops them. Returns the stick y for this poll, 0 between pulses and off the map. Under lock.
#define MAP_ZOOM_PULSE_NS 100000000ull
#define MAP_ZOOM_GAP_NS 50000000ull
#define MAP_ZOOM_QUEUE 4
static int32_t map_zoom_stick(int32_t notches, int on_map) {
// The scroll wheel (ikb_wheel_take, and an input script's WHEEL lines) as the stick a gamepad player would move:
// - on the Purah Pad's map it zooms: the right stick's y, away from the player zooming in;
// - while a D-pad strip (weapons, shields, bows, materials) is held open it steps the choice: the right stick's x, away
// from the player to the left, towards the player to the right;
// - in a menu with the game's focus box (the inventory, shops, Options, the save list; menu_cursor_menu) it steps the
// focus: the left stick's y, away from the player up;
// - in the Purah Pad's camera (menu_cursor_camera) it zooms: the D-pad's up (away from the player, in) or down, the
// buttons its guide shows for the zoom.
// Each notch is a full-tilt pulse with neutral after it (wheel_timing), so the game sees one notch as one step, and a
// fast scroll's notches wait their turn (at most WHEEL_QUEUE); a turn the other way drops them. A strip's pulse is the
// mouse's (input_direct_mouse_row: 32 ms each way); a menu takes the stick on its own update, a frame of the game's
// 30 Hz or less, so its pulse covers two. Elsewhere, and while the settings menu is open, the notches are dropped.
enum { WHEEL_NONE, WHEEL_MAP, WHEEL_STRIP, WHEEL_MENU, WHEEL_CAMERA };
static const struct { uint64_t pulse_ns, gap_ns; } wheel_timing[] = {
[WHEEL_MAP] = {100000000ull, 50000000ull}, [WHEEL_STRIP] = {32000000ull, 32000000ull},
[WHEEL_MENU] = {70000000ull, 50000000ull}, [WHEEL_CAMERA] = {100000000ull, 50000000ull}};
#define WHEEL_QUEUE 4
#define WHEEL_GAP_NS 300000000ull // a menu's focus gap (a tab switch): queued notches wait this long for its next screen
// The stick value for this poll at the place `where` (WHEEL_*): -STICK_MAX, 0 or STICK_MAX. Under lock.
static int32_t wheel_stick(int32_t notches, int where) {
static int32_t queued, dir;
static uint64_t until; // the end of the pulse (dir != 0) or of the neutral after it
static int place;
static uint64_t until, none_since; // until: the end of the pulse (dir != 0) or of the neutral after it
uint64_t now = plat_now_ns();
if (!on_map) { queued = dir = 0, until = 0; return 0; }
if (where == WHEEL_NONE) {
if (!none_since) none_since = now;
if (now - none_since > WHEEL_GAP_NS) queued = 0, place = WHEEL_NONE;
dir = 0;
return 0;
}
none_since = 0;
if (where != place) queued = dir = 0, until = 0, place = where;
if (notches) {
if (queued && (notches > 0) != (queued > 0)) queued = 0;
queued += notches;
queued = queued > MAP_ZOOM_QUEUE ? MAP_ZOOM_QUEUE : queued < -MAP_ZOOM_QUEUE ? -MAP_ZOOM_QUEUE : queued;
queued = queued > WHEEL_QUEUE ? WHEEL_QUEUE : queued < -WHEEL_QUEUE ? -WHEEL_QUEUE : queued;
}
if (dir) {
if (now < until) return dir * STICK_MAX;
dir = 0, until = now + MAP_ZOOM_GAP_NS;
dir = 0, until = now + wheel_timing[where].gap_ns;
return 0;
}
if (now < until || !queued) return 0;
dir = queued > 0 ? 1 : -1;
queued -= dir;
until = now + MAP_ZOOM_PULSE_NS;
until = now + wheel_timing[where].pulse_ns;
return dir * STICK_MAX;
}
// After the keys, the gamepad and the script: where the wheel goes this poll (b holds the script's D-pad too, so a
// scripted strip takes scripted notches). Under lock.
static void wheel_route(uint64_t *bp, int32_t sl[2], int32_t sr[2]) {
uint64_t b = *bp;
int32_t real = state > 0 ? ikb_wheel_take() : 0, notches = real + script_wheel; // the script's under TOTK_INPUT=none too
script_wheel = 0;
if (menu_is_open()) notches = 0;
if (real && notches) {
__atomic_store_n(&g_kbm_last, 1, __ATOMIC_RELAXED); // the pointer comes to a menu the wheel turns in
rec_wheel(real);
}
// A strip is its D-pad direction held with its screen open; with the menu cursor off (the screens not read,
// menu_cursor_shortcut -1) the buttons alone decide, as for the mouse's selectors
int sc = b & (1ull << B_UP | 1ull << B_LEFT | 1ull << B_RIGHT) && !(b & 1ull << B_L) ? menu_cursor_shortcut() : 0;
int strip = sc == -1 || sc == 1 || (sc == 0 && menu_cursor_strip());
int where = menu_cursor_map() ? WHEEL_MAP
: strip ? WHEEL_STRIP
: menu_cursor_camera() ? WHEEL_CAMERA
: menu_cursor_menu() ? WHEEL_MENU
: WHEEL_NONE;
if (where == WHEEL_MAP && gameplay_tweaks_map_zoom()) where = WHEEL_NONE;
else if (where == WHEEL_STRIP && gameplay_tweaks_strip_wheel(b)) where = WHEEL_NONE;
int32_t v = wheel_stick(notches, where);
if (!v) return;
if (where == WHEEL_CAMERA) *bp |= 1ull << (v > 0 ? B_UP : B_DOWN);
else if (where == WHEEL_MAP) pick(&sr[0], &sr[1], 0, v);
else if (where == WHEEL_STRIP) pick(&sr[0], &sr[1], -v, 0);
else pick(&sl[0], &sl[1], 0, v);
}
// Under lock, state 1: the open gamepad's inputs by position (pd[PAD_*] != 0 held); 0 without a connected gamepad.
static int pad_physical(uint8_t pd[PAD_COUNT]) {
if ((!pad || !SDL_GamepadConnected(pad)) && plat_now_ns() / 1000000u >= next_scan) { next_scan = plat_now_ns() / 1000000u + RESCAN_MS; scan_pads(); }
@@ -641,6 +714,30 @@ static void poll_merged(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx
if (!counts || mouse_ignore[k]) down[k] = 0;
}
was_captured = cap;
// On the Purah Pad's map (menu_cursor.c finds it, TOTK_MAP_CLICK) the left mouse button presses A at the
// map's cursor, which the mouse moves there, instead of its binding (Y by default). A press is one or the
// other from the moment it goes down until it is released, so a button held as the map opens or closes
// keeps what it pressed.
static int map_held, map_a;
if (!down[KEY_MOUSE_L]) map_held = map_a = 0;
else if (!map_held) map_held = 1, map_a = menu_cursor_map() && cfg_bool("TOTK_MAP_CLICK");
if (map_a) down[KEY_MOUSE_L] = 0, b |= 1ull << B_A;
// While a dialogue box is on screen (menu_cursor.c, TOTK_DIALOGUE_CLICK) the left mouse button presses B,
// which advances the text and also shows the rest of a line at once, and the right one presses A, instead
// of their bindings: Y by default, which opens the dialogue log there, and ZL. A press is one or the other
// from the moment it goes down until it is released, so a click that closes the last box does not turn
// into an attack while it is still held, and a button held as the box opens does not skip its first line.
// Dialogue choices have the pointer, and their clicks are menu_cursor.c's: a left click there is A.
static const uint8_t click_key[2] = {KEY_MOUSE_L, KEY_MOUSE_R}, click_btn[2] = {B_B, B_A};
static int click_held[2], click_talk[2];
for (int i = 0; i < 2; i++) {
int key = click_key[i];
if (!down[key]) click_held[i] = click_talk[i] = 0;
else if (!click_held[i]) click_held[i] = 1, click_talk[i] = menu_cursor_dialogue();
if (click_talk[i]) down[key] = 0, b |= 1ull << click_btn[i];
}
if (cap && !g_menu && !g_block) gameplay_tweaks_prepare_keys(down, b);
else gameplay_tweaks_reset();
b |= input_map_buttons(down);
int32_t k[2];
walk_get();
@@ -658,13 +755,10 @@ static void poll_merged(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx
// Before the screens were read (the menu cursor off) the buttons alone decide, as before.
if (selector && menu_cursor_shortcut() == 0) selector = 0;
mouse_camera(k, selector);
// On the map the left stick moves the cursor and the right one zooms: the mouse moves the cursor there,
// the scroll wheel zooms (map_zoom_stick). Elsewhere the wheel is unbound; its notches are dropped.
int map = menu_cursor_map();
if (map) pick(&sl[0], &sl[1], k[0], k[1]);
// On the map the left stick moves the cursor and the right one zooms: the mouse moves the cursor there
// (the scroll wheel zooms, wheel_route)
if (menu_cursor_map()) pick(&sl[0], &sl[1], k[0], k[1]);
else pick(&sr[0], &sr[1], k[0], k[1]);
int32_t zoom = map_zoom_stick(ikb_wheel_take(), map);
if (zoom) pick(&sr[0], &sr[1], 0, zoom);
int32_t shake = shake_stick(input_map_held(down, B_SHAKE));
if (shake) sr[0] = shake, sr[1] = 0;
// A mouse shake (mouse_direct.c) moves the stick with the mouse, side by side, and lets go when it rests
@@ -679,6 +773,8 @@ static void poll_merged(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx
else if (kbm_used) __atomic_store_n(&g_kbm_last, 1, __ATOMIC_RELAXED);
}
script_apply(&b, sl, sr);
wheel_route(&b, sl, sr);
gameplay_tweaks_apply(__atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED), input_gameplay_active(), &b, &sl[0], &sl[1], &sr[0], &sr[1]);
rec_apply(b, sl, sr);
// Minus and Plus held together (gamepad or keys) open or close the menu and never reach the game
static int combo_held;
@@ -710,10 +806,12 @@ static volatile uint64_t g_block_closed, g_menu_closed;
int input_cursor_allowed(void) {
const char *in = cfg_get("TOTK_INPUT");
return g_block != 1 && g_menu != 1 && mouse_sens_get() > 0 && !(in && !strcmp(in, "none")) && !menu_cursor_pointer();
return g_block != 1 && g_menu != 1 && (gameplay_tweaks_capture_needed() || mouse_sens_get() > 0) &&
!(in && !strcmp(in, "none")) && !menu_cursor_pointer();
}
void input_block(int on) {
if (on) gameplay_tweaks_reset();
if (!on) __atomic_store_n(&g_block_closed, plat_now_ns(), __ATOMIC_RELEASE);
plat_xchg32(&g_block, on ? 1 : 2);
ikb_cursor_update();
@@ -722,6 +820,7 @@ void input_block(int on) {
// The in-game menu (ui/menu.cpp) blocks the game's input the same way: g_menu 0 closed, 1 open, 2 closed, waiting for
// the release. The cursor is released while it is open, for the menu's mouse.
void input_menu(int open) {
if (open) gameplay_tweaks_reset();
if (!open) __atomic_store_n(&g_menu_closed, plat_now_ns(), __ATOMIC_RELEASE);
plat_xchg32(&g_menu, open ? 1 : 2);
if (!open) ikb_menu_closed(); // the capture before Esc comes back
+23
View File
@@ -28,6 +28,20 @@ uint64_t input_buttons_last(void);
// mouse_direct.c: the right stick's side a mouse shake gives while Ultrahand holds an object (-1 / +1), 0 while the
// mouse does not shake; input.c puts it on the stick
int input_direct_mouse_shake(void);
enum {
INPUT_CAM_UNCLASSIFIED = 0,
INPUT_CAM_FREE_ROAM,
INPUT_CAM_AIM,
INPUT_CAM_SCOPE,
INPUT_CAM_LOCK_ON,
INPUT_CAM_MENU_WHEEL,
INPUT_CAM_ABILITY,
INPUT_CAM_ULTRAHAND_OBJECT,
INPUT_CAM_VEHICLE,
INPUT_CAM_DISABLED,
};
int input_camera_context(void);
int input_gameplay_active(void);
// menu_cursor.c: the L ability wheel or a D-pad strip has the focus: 1 / 0, -1 with the menu cursor off (not read)
int menu_cursor_shortcut(void);
// menu_cursor.c: the pointer in the game's menus (1.4.3). poll: once per pad read, adds a click's A or B; pointer: a
@@ -35,6 +49,15 @@ int menu_cursor_shortcut(void);
void menu_cursor_poll(uint64_t *buttons);
int menu_cursor_pointer(void);
int menu_cursor_map(void); // the Purah Pad's map is open: the mouse's stick is the left one (its cursor)
// a dialogue box is on screen and TOTK_DIALOGUE_CLICK is on: left click is B, right click A (input.c poll_merged)
int menu_cursor_dialogue(void);
// A menu screen (not the ability wheel, a D-pad strip or the map) has the game's focus box, whichever device was used
// last: input.c turns the scroll wheel into steps of its focus. 0 with the menu cursor off.
int menu_cursor_menu(void);
// A D-pad strip's screen (ShortCut_00) is open; it has no focus box while held. 0 with the menu cursor off.
int menu_cursor_strip(void);
// The Purah Pad's camera is open: its frame and pointer without the map the Scope has. 0 with the menu cursor off.
int menu_cursor_camera(void);
// The same for host UI (the text entry): never blocked. input_block(1) while a text entry is open: input_poll then
// reports nothing; input_block(0) when it closes: nothing until all buttons and stick directions are released.
void input_poll_ui(uint64_t *buttons, int32_t *lx, int32_t *ly, int32_t *rx, int32_t *ry);
+41 -2
View File
@@ -12,18 +12,21 @@
#include <SDL3/SDL.h>
#include "cfg.h"
#include "host.h"
#include "input.h"
#include "input_map.h"
#include "input_sdl.h"
#include "input_wsys.h"
#include "gameplay_tweaks.h"
#include "platform/platform.h"
static SDL_Window *win;
static volatile uint8_t key_held[KEY_COUNT];
static volatile int32_t esc_held, f8_held, focused;
static volatile int32_t mouse_dx, mouse_dy; // relative motion since the last ikb_mouse_take, whole counts
static volatile int32_t mouse_wheel; // wheel turned while captured, in 1/120 notches (ikb_wheel_take)
static volatile int32_t mouse_wheel; // wheel turned while captured or over the window, in 1/120 notches
// (ikb_wheel_take)
static float rem_x, rem_y; // window thread: the fractions SDL reported beyond them
static volatile int32_t mouse_travel; // raw counts moved in total, captured or not (ikb_mouse_travel)
static float travel_rem; // window thread: the fraction of a count beyond mouse_travel
@@ -143,6 +146,7 @@ static void cursor_apply(void) {
plat_xchg32(&mouse_dy, 0);
rem_x = rem_y = 0;
plat_xchg32(&captured, want);
if (!want) gameplay_tweaks_reset();
}
// The pointer's place in the window (the window thread): x and y are SDL window units, the same space the mouse
@@ -199,8 +203,37 @@ void ikb_menu_closed(void) {
if (o & CUR_ESC) plat_cas32(&cur_rel, 0, o);
}
// pointer_image = 1: the pointer over the window while the cursor is not captured is cursor_art.c's, sized by the
// window's display scale; 0 (the default) keeps SDL's arrow. Window thread, at the window's creation and whenever the
// settings change (input_sdl_idle), so the menu switches it live. SDL's arrow stays when SDL refuses the image.
static void art_cursor(SDL_Window *w) {
static SDL_Cursor *art;
static int shown = -1, failed;
static unsigned seen = ~0u;
unsigned v = cfg_version();
if (v == seen && shown >= 0) return;
seen = v;
int want = cfg_bool("TOTK_POINTER_IMAGE");
if (want == shown) return;
if (want && !art && !failed) {
float scale = SDL_GetWindowDisplayScale(w);
int size = (int)lrintf(32 * (scale > 0 ? scale : 1)), hot;
size = size < 32 ? 32 : size > 128 ? 128 : size;
SDL_Surface *s = SDL_CreateSurface(size, size, SDL_PIXELFORMAT_ARGB8888);
if (s && s->pitch == size * 4) {
cursor_art(s->pixels, size, &hot);
art = SDL_CreateColorCursor(s, hot, hot);
}
if (s) SDL_DestroySurface(s);
if (!art) failed = 1, rt_log("input: the pointer's image failed (%s); the arrow stays", SDL_GetError());
}
SDL_SetCursor(want && art ? art : SDL_GetDefaultCursor());
shown = want;
}
void input_sdl_window(SDL_Window *w) {
win = w;
art_cursor(w);
wake_event = SDL_RegisterEvents(1);
plat_xchg32(&focused, (SDL_GetWindowFlags(w) & SDL_WINDOW_INPUT_FOCUS) != 0);
__atomic_store_n(&ptr_have, 0, __ATOMIC_RELEASE); // the pointer's place is unknown until it enters or moves
@@ -209,6 +242,7 @@ void input_sdl_window(SDL_Window *w) {
void input_sdl_idle(void) {
if (cur_pending) cursor_apply();
if (win) art_cursor(win);
pointer_apply();
}
@@ -266,10 +300,15 @@ void input_sdl_event(const SDL_Event *e) {
__atomic_store_n(&ptr_have, 0, __ATOMIC_RELEASE);
break;
case SDL_EVENT_MOUSE_WHEEL: // notches, + away from the player (a flipped wheel reports the other sign)
if (captured) {
// Captured, or released over the focused window: a game menu with the pointer takes it (input.c)
if (captured || (focused && __atomic_load_n(&ptr_have, __ATOMIC_ACQUIRE))) {
float y = e->wheel.direction == SDL_MOUSEWHEEL_FLIPPED ? -e->wheel.y : e->wheel.y;
plat_add32(&mouse_wheel, (int32_t)(y * 120));
}
if (input_gameplay_active()) {
double delta = e->wheel.direction == SDL_MOUSEWHEEL_FLIPPED ? e->wheel.y : -e->wheel.y;
gameplay_tweaks_wheel(delta, ikb_down(KEY_C), ikb_down(KEY_MOUSE_R));
}
break;
case SDL_EVENT_WINDOW_FOCUS_GAINED:
plat_xchg32(&focused, 1);
+54 -4
View File
@@ -13,6 +13,7 @@
#include "input_win.h"
#include "input_map.h"
#include "input_wsys.h"
#include "gameplay_tweaks.h"
#include "nvn_api.h"
#include "ui/menu.h"
#include "vk.h"
@@ -84,7 +85,8 @@ uint32_t input_key_char(int key) {
// ---- mouse camera: raw motion accumulated by the window thread, one stick sample per presented frame
static volatile LONG mouse_dx, mouse_dy; // raw counts since the last frame sample
static volatile LONG mouse_travel; // raw counts moved in total, captured or not (ikb_mouse_travel)
static volatile LONG mouse_wheel; // wheel turned while captured, in WHEEL_DELTA units (ikb_wheel_take)
static volatile LONG mouse_wheel; // wheel turned while captured or over the window, in WHEEL_DELTA units
// (ikb_wheel_take)
static volatile LONG cur_captured; // cursor hidden and confined to the client area
static volatile LONG cur_active; // WM_ACTIVATEAPP: the window's application is active
// Bits: CUR_REL, Esc or activation by a click on the title bar or border: until a client click; CUR_ESC, set with CUR_REL
@@ -118,9 +120,43 @@ static void cursor_update(HWND h) {
if (cur_captured) ClipCursor(NULL);
InterlockedExchange(&cur_captured, 0);
}
if (!cur_captured) gameplay_tweaks_reset();
ReleaseSRWLockExclusive(&cur_lock);
}
// The pointer shown over the client area while the cursor is not captured (cursor_art.c), 32 pixels at 96 DPI and
// larger with the window's DPI; made again when the DPI changes. Window thread. NULL when Windows refuses it: the
// window class's arrow stays.
static HCURSOR art_cursor(HWND h) {
static HCURSOR cur;
static UINT made_dpi;
UINT dpi = GetDpiForWindow(h);
if (!dpi) dpi = USER_DEFAULT_SCREEN_DPI;
if (cur && dpi == made_dpi) return cur;
int size = MulDiv(32, (int)dpi, USER_DEFAULT_SCREEN_DPI), hot;
size = size < 32 ? 32 : size > 128 ? 128 : size;
BITMAPV5HEADER bh = {.bV5Size = sizeof bh, .bV5Width = size, .bV5Height = -size, .bV5Planes = 1, .bV5BitCount = 32,
.bV5Compression = BI_BITFIELDS, .bV5RedMask = 0xff0000, .bV5GreenMask = 0xff00,
.bV5BlueMask = 0xff, .bV5AlphaMask = 0xff000000u};
void *bits = NULL;
HDC dc = GetDC(NULL);
HBITMAP color = CreateDIBSection(dc, (BITMAPINFO *)&bh, DIB_RGB_COLORS, &bits, NULL, 0);
ReleaseDC(NULL, dc);
HBITMAP mask = CreateBitmap(size, size, 1, 1, NULL);
HCURSOR made = NULL;
if (color && mask && bits) {
cursor_art(bits, size, &hot);
ICONINFO ii = {.fIcon = FALSE, .xHotspot = (DWORD)hot, .yHotspot = (DWORD)hot, .hbmMask = mask,
.hbmColor = color};
made = (HCURSOR)CreateIconIndirect(&ii);
}
if (color) DeleteObject(color);
if (mask) DeleteObject(mask);
if (!made) return cur; // the old size, or NULL
cur = made, made_dpi = dpi; // the old one may still be on screen: kept (a DPI change is rare)
return cur;
}
int input_cursor_released(void) { return (cur_rel & CUR_REL) != 0; }
void input_cursor_suspend(int on) {
@@ -148,13 +184,27 @@ int input_window_msg(HWND h, UINT m, WPARAM w, LPARAM l, LRESULT *res) {
InterlockedAdd(&mouse_dy, y);
}
}
// The wheel comes in the same message (usButtonData, signed, + away from the player)
if (cur_captured && ri.header.dwType == RIM_TYPEMOUSE && (ri.data.mouse.usButtonFlags & RI_MOUSE_WHEEL))
// The wheel comes in the same message (usButtonData, signed, + away from the player). It counts while the
// cursor is captured, or released over the client area: a game menu with the pointer (menu_cursor.c) takes it
// as steps of its focus. input.c drops the notches where nothing takes them.
float px, py;
if (ri.header.dwType == RIM_TYPEMOUSE && (ri.data.mouse.usButtonFlags & RI_MOUSE_WHEEL) &&
(cur_captured || ikb_pointer(&px, &py)))
InterlockedAdd(&mouse_wheel, (SHORT)ri.data.mouse.usButtonData);
break; // DefWindowProc must see WM_INPUT for cleanup
}
case WM_MOUSEWHEEL:
if (input_gameplay_active())
gameplay_tweaks_wheel(-(double)(short)HIWORD(w) / WHEEL_DELTA,
ikb_down(KEY_C), ikb_down(KEY_MOUSE_R));
break;
case WM_SETCURSOR:
if (cur_captured && LOWORD(l) == HTCLIENT) { SetCursor(NULL); *res = TRUE; return 1; }
if (LOWORD(l) == HTCLIENT) {
// pointer_image = 1: the pointer of cursor_art.c in place of the window class's arrow (0, the default:
// the arrow, left to DefWindowProc)
HCURSOR c = cur_captured || !cfg_bool("TOTK_POINTER_IMAGE") ? NULL : art_cursor(h);
if (cur_captured || c) { SetCursor(c); *res = TRUE; return 1; }
}
break;
case WM_SYSCOMMAND: // Alt pressed alone would enter the window menu loop, which stalls the game: Alt is a game key
if ((w & 0xFFF0) == SC_KEYMENU && l == 0) { *res = 0; return 1; }
+8 -2
View File
@@ -13,10 +13,16 @@ void ikb_pointer_set(float nx, float ny); // moves the pointer there (the wind
int ikb_captured(void); // the cursor is captured for the mouse camera
void ikb_mouse_take(int32_t *dx, int32_t *dy); // raw mouse motion since the last call, in counts
uint32_t ikb_mouse_travel(void); // raw counts the mouse moved in total (|dx| + |dy|), captured or not
int32_t ikb_wheel_take(void); // whole wheel notches turned while captured since the last call (+ away
// from the player); a high-resolution wheel's part of a notch is kept
int32_t ikb_wheel_take(void); // whole wheel notches turned since the last call while the cursor was
// captured or over the focused window (+ away from the player); a
// high-resolution wheel's part of a notch is kept
void ikb_cursor_update(void); // what input_cursor_allowed says may have changed
void ikb_menu_closed(void); // the menu closed: a capture that Esc gave up comes back
// ---- shared by the back ends
// cursor_art.c: the pointer's image at size x size pixels (0xAARRGGBB, straight alpha, rows from the top) and its
// hotspot (*hot, the same in x and y). Pure.
void cursor_art(uint32_t *argb, int size, int *hot);
// ---- what input.c provides the back end
int input_cursor_allowed(void); // no text entry or menu open, the mouse camera on, input not disabled
+3 -2
View File
@@ -263,11 +263,12 @@ void mem_init(void) {
L = (RtGuestLayout){
.aslr = {low, RT_ADDRESS_LIMIT - low},
.stack = {low + STACK_OFF, STACK_SIZE},
.heap = {low + HEAP_OFF, HEAP_CAP + res_tex_heap_extra_bytes()},
.heap = {low + HEAP_OFF, HEAP_CAP + res_tex_heap_extra_bytes() + res_grass_heap_extra_bytes()},
.alias = {alias, ALIAS_SIZE},
.kernel = {RT_KERNEL_BASE, RT_KERNEL_SIZE},
.hostfn = {RT_HOSTFN_BASE, RT_HOSTFN_SIZE},
.pool = pool ? strtoull(pool, NULL, 0) : DEFAULT_POOL + res_heap_extra_bytes() + res_tex_heap_extra_bytes(),
.pool = pool ? strtoull(pool, NULL, 0)
: DEFAULT_POOL + res_heap_extra_bytes() + res_tex_heap_extra_bytes() + res_grass_heap_extra_bytes(),
};
if (!L.pool) rt_fatal("memory: TOTK_APP_POOL is 0");
}
+114 -11
View File
@@ -20,6 +20,14 @@
//
// Only while keyboard and mouse are the device used last (input_kbm_last): a gamepad player sees the menus unchanged.
// TOTK_MENU_CURSOR (live, default 1): 0 leaves the menus to the keys and the pad.
//
// With TOTK_MAP_CLICK=1 (live, default 0: one key per controller button) input.c makes the left mouse button A on the
// map (menu_cursor_map), so a click acts at the map's cursor. The map is found only while TOTK_MENU_CURSOR is on.
//
// The same read of the open screens tells input.c when a dialogue box is on screen (menu_cursor_dialogue), where the
// left mouse button presses B (it advances the text and skips its scroll) and the right one A, instead of their
// bindings (Y by default, which opens the dialogue log, and ZL). TOTK_DIALOGUE_CLICK (live, default 0: one key per
// controller button) switches that on its own: it does not need the pointer.
#include <math.h>
#include <stdint.h>
#include <stdio.h>
@@ -50,6 +58,10 @@ enum { DI_PROJ = 0x10, DI_VIEW = 0x50, LYT_ROOT = 0x18, LYT_SIZE = 0x28, LYT_NAM
// nn::ui2d::Pane
enum { PANE_PARENT = 0x18, PANE_SIZE = 0x50, PANE_FLAG = 0x58, PANE_ALPHA = 0x59, PANE_BASE = 0x5b, PANE_MTX = 0x70 };
// How far the pointer moves, in layout units (1280 x 720 across the picture: 1.5 window pixels at 1080p, 3 at 4K),
// before it takes back a focus that the wheel, the keys or the pad moved away from it (menu_cursor_poll)
#define DEAD_ZONE 6.0f
static uint64_t main_lo, main_hi;
static int ok_at(uint64_t p, uint64_t n) {
@@ -166,16 +178,24 @@ static void layout_name(uint64_t scr, char *out, size_t n) {
// 1.4.3 constructor keeps). The map has no focus box, so it is found here: the Purah Pad's frame (AppMenuOverlay_00)
// with AppMap_00 and the menu's background AppMenuBG_00 open. The Scope opens the frame over AppMap_00 without that
// background (Weeping of the Empire's engine/runtime/totk_menu_cursor.cpp census tells them apart the same way).
// The dialogue window (DIALOGUE_SCREEN) has no focus box either: the scan remembers its screen for dialogue_shown.
// A D-pad strip has no focus box either while it is held open: *strip is ShortCut_00 being open. *camera is the
// Purah Pad's camera (the ability wheel's camera): the frame and its pointer CameraPointer_00 open without AppMap_00,
// which the Scope has with them.
// TOTK_MENU_CURSOR_LOG=1 logs the open screens whenever the set changes.
enum { SM_COUNT = 0x8, SM_SCREENS = 0x10 };
static int map_open(void) {
#define DIALOGUE_SCREEN "MessageDialog_00" // the box a character's lines and the game's messages are shown in
#define DIALOGUE_GAP_MS 500 // how long after the box closed a click is still the dialogue's
static uint64_t dialogue_scr; // game thread only
static int map_open(int *strip, int *camera) {
uint64_t sm = screen_mgr();
if (!sm) return 0;
int32_t n = (int32_t)rd32(sm + SM_COUNT);
uint64_t arr = rd64(sm + SM_SCREENS);
*strip = *camera = 0;
if (n <= 0 || n > 1024 || !ok_at(arr, 8ull * (uint64_t)n)) return 0;
const char *e = cfg_get("TOTK_MENU_CURSOR_LOG");
int verbose = e && !strcmp(e, "1"), pad = 0, map = 0, bg = 0;
int verbose = e && !strcmp(e, "1"), pad = 0, map = 0, bg = 0, pointer = 0;
char list[1024];
size_t len = 0;
uint64_t h = 1469598103934665603ull;
@@ -187,6 +207,9 @@ static int map_open(void) {
pad |= !strcmp(nm, "AppMenuOverlay_00");
map |= !strcmp(nm, "AppMap_00");
bg |= !strcmp(nm, "AppMenuBG_00");
if (!strcmp(nm, DIALOGUE_SCREEN)) dialogue_scr = scr;
pointer |= !strcmp(nm, "CameraPointer_00");
*strip |= !strcmp(nm, "ShortCut_00");
if (!verbose) continue;
for (const char *c = nm; *c; c++) h = (h ^ (uint8_t)*c) * 1099511628211ull;
if (len < sizeof list - 64) len += (size_t)snprintf(list + len, sizeof list - len, "%s%s", len ? " " : "", nm);
@@ -194,8 +217,22 @@ static int map_open(void) {
static uint64_t last;
static int lines;
if (verbose && h != last && lines < 200) last = h, lines++, rt_log("menu_cursor: open screens: %s", list);
*camera = pad && pointer && !map && !bg;
return pad && map && bg;
}
// The dialogue window is open. Read at every pad read from the screen the last scan found open, so a click follows the
// box without the scan's 100 ms: the game keeps its screens, so the one found once is the one that opens the next time.
// A screen that is no longer that layout (a reload built the screens again) is forgotten until a scan finds it.
static int dialogue_shown(void) {
uint64_t scr = dialogue_scr;
if (!scr) return 0;
if (!game_object(scr, SCR_REQUEST + 1)) { dialogue_scr = 0; return 0; }
if (rd8(scr + SCR_STATE) != SCR_OPENED) return 0;
char nm[48];
layout_name(scr, nm, sizeof nm);
if (strcmp(nm, DIALOGUE_SCREEN)) { dialogue_scr = 0; return 0; }
return 1;
}
static void layout_size(uint64_t scr, float *lw, float *lh) {
*lw = 1920, *lh = 1080;
uint64_t lyt = rd64(scr + SCR_LAYOUT);
@@ -280,15 +317,29 @@ static int gameplay_screen(const char *nm) {
static volatile int32_t g_pointer; // a menu has the pointer: input_cursor_allowed releases the capture
static volatile int32_t g_map; // the Purah Pad's map is open (not the Scope): the mouse moves its cursor
static volatile int32_t g_dialogue; // a dialogue box is on screen and TOTK_DIALOGUE_CLICK is on: left B, right A
static volatile int32_t g_menu; // a menu screen has the focus box, from either device (the scroll wheel's steps)
static volatile int32_t g_strip; // a D-pad strip's screen is open (the scroll wheel's steps along it)
static volatile int32_t g_camera; // the Purah Pad's camera is open (the scroll wheel zooms it)
int menu_cursor_pointer(void) { return __atomic_load_n(&g_pointer, __ATOMIC_RELAXED); }
int menu_cursor_map(void) { return __atomic_load_n(&g_map, __ATOMIC_RELAXED); }
int menu_cursor_dialogue(void) { return __atomic_load_n(&g_dialogue, __ATOMIC_RELAXED); }
int menu_cursor_menu(void) { return __atomic_load_n(&g_menu, __ATOMIC_RELAXED); }
int menu_cursor_strip(void) { return __atomic_load_n(&g_strip, __ATOMIC_RELAXED); }
int menu_cursor_camera(void) { return __atomic_load_n(&g_camera, __ATOMIC_RELAXED); }
static int enabled(void) {
if (!RT_V143) return 0;
const char *v = cfg_get("TOTK_MENU_CURSOR"), *in = cfg_get("TOTK_INPUT");
return !(v && !strcmp(v, "0")) && !(in && !strcmp(in, "none"));
}
// The left click in dialogue: its own setting, on with the menu cursor off too
static int dialogue_enabled(void) {
if (!RT_V143) return 0;
const char *in = cfg_get("TOTK_INPUT");
return cfg_bool("TOTK_DIALOGUE_CLICK") && !(in && !strcmp(in, "none"));
}
static void set_pointer(int on) {
if (plat_xchg32(&g_pointer, on) == on) return;
@@ -317,27 +368,68 @@ static void log_screen(const Focus *f, const char *nm, int n, float lw, float lh
// Once per pad read on the game thread: the pointer's hover and clicks, as pad buttons (A, B) for this read
void menu_cursor_poll(uint64_t *buttons) {
static int inited, pending_a, held_l, held_r;
static int inited, pending_a, held_l, held_r, anchored;
static uint64_t pending_node, pending_until, hold_until, hold_bit, menu_seen;
static float last_px = -1, last_py = -1;
static uint64_t ptr_node, last_focus; // the item the pointer last pointed at, the focus at the last read
static float last_px = -1, last_py = -1, anchor_px, anchor_py;
if (!inited) {
inited = 1;
main_lo = MOD_MAIN_BASE, main_hi = MOD_MAIN_BASE + MAIN_SIZE;
if (RT_V143) rt_log("menu_cursor: on for 1.4.3 (TOTK_MENU_CURSOR=0 turns it off)");
}
if (!enabled()) { set_pointer(0); __atomic_store_n(&g_map, 0, __ATOMIC_RELAXED); return; }
Focus f = focus_now();
char nm[48] = "";
if (f.screen) layout_name(f.screen, nm, sizeof nm);
int cursor = enabled(), talk = dialogue_enabled();
if (!cursor && !talk) {
set_pointer(0);
__atomic_store_n(&g_map, 0, __ATOMIC_RELAXED);
__atomic_store_n(&g_dialogue, 0, __ATOMIC_RELAXED);
__atomic_store_n(&g_menu, 0, __ATOMIC_RELAXED);
__atomic_store_n(&g_strip, 0, __ATOMIC_RELAXED);
__atomic_store_n(&g_camera, 0, __ATOMIC_RELAXED);
return;
}
// The open screens are scanned every 100 ms, not at every pad read: each screen costs memory queries
uint64_t now = plat_now_ms();
static uint64_t map_at;
static int map, map_logged;
if (!map_at || now - map_at >= 100) map_at = now, map = map_open();
static int map, map_logged, dialogue_logged, strip, camera;
if (!map_at || now - map_at >= 100) map_at = now, map = map_open(&strip, &camera);
// Between two lines of a conversation the game closes the box and opens it again, so a click made in that gap still
// counts as dialogue for DIALOGUE_GAP_MS after the box was last open. The first clicks after a conversation fall
// in it too and are B or A, as they are for a player who taps the button through the last line.
// TOTK_MENU_CURSOR_LOG=1 logs how long each gap was.
static uint64_t dialogue_seen;
int box = talk && dialogue_shown();
if (!talk) dialogue_seen = 0;
if (box) {
static int gap_lines;
const char *e = cfg_get("TOTK_MENU_CURSOR_LOG");
uint64_t gap = dialogue_seen ? now - dialogue_seen : 0;
if (gap > 30 && gap < 5000 && gap_lines < 100 && e && !strcmp(e, "1"))
gap_lines++, rt_log("menu_cursor: the dialogue box was closed for %llu ms", (unsigned long long)gap);
dialogue_seen = now;
}
int dialogue = box || (dialogue_seen && now - dialogue_seen < DIALOGUE_GAP_MS);
if (dialogue && !dialogue_logged)
dialogue_logged = 1, rt_log("menu_cursor: a dialogue box is open (" DIALOGUE_SCREEN "): left click is B, "
"right click A (TOTK_DIALOGUE_CLICK=1)");
__atomic_store_n(&g_dialogue, dialogue, __ATOMIC_RELAXED);
if (!cursor) {
set_pointer(0);
__atomic_store_n(&g_map, 0, __ATOMIC_RELAXED);
__atomic_store_n(&g_menu, 0, __ATOMIC_RELAXED);
__atomic_store_n(&g_strip, 0, __ATOMIC_RELAXED);
__atomic_store_n(&g_camera, 0, __ATOMIC_RELAXED);
return;
}
__atomic_store_n(&g_strip, strip, __ATOMIC_RELAXED);
__atomic_store_n(&g_camera, camera, __ATOMIC_RELAXED);
Focus f = focus_now();
char nm[48] = "";
if (f.screen) layout_name(f.screen, nm, sizeof nm);
if (map && !map_logged) map_logged = 1, rt_log("menu_cursor: the map is open: the mouse moves its cursor");
__atomic_store_n(&g_map, map, __ATOMIC_RELAXED);
// With the gamepad as the last device the menus stay as they are on the console: no pointer, the capture kept.
// Moving the mouse (or a key) makes keyboard and mouse the last device and the pointer comes.
__atomic_store_n(&g_menu, f.screen && !gameplay_screen(nm) && !map, __ATOMIC_RELAXED);
int menu = f.screen && !gameplay_screen(nm) && ikb_foreground() && input_kbm_last();
if (menu) menu_seen = now;
// A menu's focus gap (a tab switch, a popup opening: no focus box for a frame or two) keeps the pointer where it
@@ -352,7 +444,7 @@ void menu_cursor_poll(uint64_t *buttons) {
return;
}
if (gap) return; // a click's focus request waits for the next screen
if (!menu) { pending_a = 0; last_px = last_py = -1; return; }
if (!menu) { pending_a = 0, anchored = 0, ptr_node = last_focus = 0; last_px = last_py = -1; return; }
if (pending_a) { // the focus asked for by a click: A once it is there
if (rd64(f.control + CTL_ACTIVE) == pending_node) {
pending_a = 0, hold_until = now + 60, hold_bit = 1ull << B_A;
@@ -366,11 +458,21 @@ void menu_cursor_poll(uint64_t *buttons) {
if (click_r) { hold_until = now + 60, hold_bit = 1ull << B_B; *buttons |= hold_bit; return; }
float px, py;
if (!picture_pos(&px, &py)) return;
// The focus moved to another item than the pointer's (the scroll wheel, the keys, the pad): the pointer takes it
// back only after it has left a dead zone of DEAD_ZONE layout units around where it was then, so a hand resting on
// the mouse does not undo a scroll. A click still acts at once.
if (f.node != last_focus) {
if (f.node != ptr_node) anchored = 1, anchor_px = px, anchor_py = py;
last_focus = f.node;
}
int moved = fabsf(px - last_px) > 0.001f || fabsf(py - last_py) > 0.001f;
if (!moved && !click_l) return;
last_px = px, last_py = py;
float lw, lh;
layout_size(f.screen, &lw, &lh);
if (anchored && !click_l && fabsf(px - anchor_px) * lw < DEAD_ZONE && fabsf(py - anchor_py) * lh < DEAD_ZONE)
return;
anchored = 0;
Xf xf = screen_xf(f.screen);
Pt p = {(px - 0.5f) * lw, (0.5f - py) * lh, px * 2 - 1, 1 - py * 2, NULL};
if (xf.ok && !xf_plain(&xf, lw, lh)) p.t = &xf;
@@ -379,6 +481,7 @@ void menu_cursor_poll(uint64_t *buttons) {
log_screen(&f, nm, n, lw, lh, p.t, n && stale_hit_panes(n, btn, lw, lh, p.t));
uint64_t at = n ? node_at(n, node, btn, &p, lw, lh) : 0;
if (!at) return;
ptr_node = at;
if (at != f.node) move_focus(&f, at);
if (click_l) {
if (at == f.node) { hold_until = now + 60, hold_bit = 1ull << B_A; *buttons |= hold_bit; }
+3 -2
View File
@@ -30,8 +30,9 @@ typedef struct {
int kind, enabled;
ModProblem problem;
uint32_t replaced, added, overridden; // romfs.c: files served (replacing / added), files a higher mod serves
uint32_t other_version; // files for another game version (RomFS *.Product.<n>.*, ExeFS patches
// for another build), not used
uint32_t other_version; // files named for another game version: RomFS *.Product.<n>.* the RomFS
// lacks (served under their own names; another version's size table is
// not) and ExeFS patches for another build (not used)
char overridden_by[256]; // the first higher mod that took one of its files
char note[256]; // MOD_EXEFS_UNSUPPORTED: why
uint32_t pending, pending_key; // ExeFS patch files the build lacks; FNV-1a of their names and contents
+63
View File
@@ -121,6 +121,8 @@ void input_direct_mouse_row(int32_t dx, float sensitivity, uint64_t now, InputMo
#define HOST_MOUSE_HAND (RT_PATCH_PAGE + 0xf90)
#define HOST_MOUSE_ORBIT_STATE (RT_PATCH_PAGE + 0xf70)
static _Thread_local uint64_t mouse_input_object;
static volatile int32_t cam_blocked, cam_kind;
static uint64_t cam_kind_at;
// Where a game version keeps what the hooks read and write (recomp/patches-v143.txt, patches-v121.txt). The camera
// input update keeps its flags in w21, its input object in x20 and y in s10 in both; the free orbit's object is x0 at
@@ -362,6 +364,7 @@ static void camera_input(Cpu *c) {
const unsigned rx = mouse_layout()->input_x;
mouse_input_object = 0;
uint32_t flags = (uint32_t)c->x[21];
__atomic_store_n(&cam_blocked, (flags & 1) != 0, __ATOMIC_RELAXED);
int accept = !(flags & 1) && !input_direct_mouse_selector_active();
__atomic_store_n(&accepts_mouse, accept, __ATOMIC_RELAXED);
__atomic_store_n(&last_update, plat_now_ns(), __ATOMIC_RELEASE);
@@ -456,6 +459,8 @@ static void camera_input(Cpu *c) {
// directly and move its persistent pitch/yaw by the same amounts so the next update starts at the new orientation.
// The controller still handles its gamepad input, following, collision and focus normally.
static void orbit_begin(Cpu *c) {
__atomic_store_n(&cam_kind, INPUT_CAM_FREE_ROAM, __ATOMIC_RELAXED);
__atomic_store_n(&cam_kind_at, plat_now_ns(), __ATOMIC_RELEASE);
orbit.object = 0;
uint64_t object = c->x[0];
if (direct_mode()) {
@@ -1034,6 +1039,45 @@ static void camera_load(Cpu *c) {
rt_log("mouse: load hook called from main+%#llx, no such site", (unsigned long long)offset);
abort();
}
int mapped = INPUT_CAM_UNCLASSIFIED;
switch (s->mode) {
case MODE_AIM:
case MODE_LOCKON_AIM:
mapped = INPUT_CAM_AIM;
break;
case MODE_SCOPE:
case MODE_FINDER:
mapped = INPUT_CAM_SCOPE;
break;
case MODE_ABILITY:
case MODE_ABILITY_OFFSET:
mapped = INPUT_CAM_ABILITY;
break;
case MODE_LOCKON:
mapped = INPUT_CAM_LOCK_ON;
break;
case MODE_HORSE:
case MODE_HORSE_LOCKON:
mapped = INPUT_CAM_VEHICLE;
break;
case MODE_TALK:
case MODE_TALK_MANUAL:
mapped = INPUT_CAM_DISABLED;
break;
case MODE_CLIMB:
case MODE_WAKEBOARD:
case MODE_SHIELD:
case MODE_WATERFALL:
case MODE_TAIL:
mapped = INPUT_CAM_FREE_ROAM;
break;
default:
break;
}
if (mapped != INPUT_CAM_UNCLASSIFIED) {
__atomic_store_n(&cam_kind, mapped, __ATOMIC_RELAXED);
__atomic_store_n(&cam_kind_at, plat_now_ns(), __ATOMIC_RELEASE);
}
uint64_t at = load_address(c, s->insn);
if (s->role == ROLE_BASE_STORE) { // performs the store, of the value plus the degrees when there are any
uint32_t bits = (uint32_t)c->v[s->insn & 31];
@@ -1099,4 +1143,23 @@ __attribute__((constructor)) static void mouse_direct_register(void) {
rt_register_host(HOST_MOUSE_HAND, hand_input);
rt_register_host(HOST_MOUSE_LOAD, camera_load);
}
int input_camera_context(void) {
static int patch_id = -2;
if (patch_id == -2) patch_id = rt_patch_set("mouse_direct");
if (patch_id < 0 || !rt_patch_enabled(patch_id)) return INPUT_CAM_UNCLASSIFIED;
uint64_t now = plat_now_ns();
if (hand_active(now)) return INPUT_CAM_ULTRAHAND_OBJECT;
uint64_t kat = __atomic_load_n(&cam_kind_at, __ATOMIC_ACQUIRE);
int kind = (kat && now - kat < 150000000ull) ? __atomic_load_n(&cam_kind, __ATOMIC_RELAXED) : INPUT_CAM_UNCLASSIFIED;
if (kind == INPUT_CAM_SCOPE || kind == INPUT_CAM_AIM) return kind;
uint64_t last = __atomic_load_n(&last_update, __ATOMIC_ACQUIRE);
int cam_alive = last && now - last < 150000000ull;
if (cam_alive && __atomic_load_n(&cam_blocked, __ATOMIC_RELAXED)) return INPUT_CAM_MENU_WHEEL;
if (kind != INPUT_CAM_UNCLASSIFIED) return kind;
if (cam_alive) return INPUT_CAM_FREE_ROAM;
return INPUT_CAM_UNCLASSIFIED;
}
#else
int input_camera_context(void) { return INPUT_CAM_UNCLASSIFIED; }
#endif
+3
View File
@@ -687,6 +687,8 @@ NVN_API(nvnWindowAcquireTexture) {
sleep_until(at);
perf_end(PERF_PACE, p0);
}
vk_reflex_sleep();
vk_reflex_marker(0, vk_reflex_frame_begin()); // VK_LATENCY_MARKER_SIMULATION_START_NV: a new frame and its ID
// The sync means "the display no longer reads this image". Presents are copies queued in submit order, so it is
// already satisfied: fenced = 3 with fence 0.
if (s) {
@@ -710,6 +712,7 @@ NVN_API(nvnQueuePresentTexture) {
if (o->magic != NVN_WIN_MAGIC || idx < 0 || idx >= o->ntex || idx >= 4 || !o->tex[idx])
rt_fatal("nvn: QueuePresentTexture of image %d on window %p", idx, (void *)o);
o->presents++;
vk_reflex_marker(1, vk_reflex_frame()); // VK_LATENCY_MARKER_SIMULATION_END_NV
const tex_t *t = (const tex_t *)o->tex[idx];
uint64_t period = present_period(o), now = kern_now_ns();
uint64_t slot = now + pace(&o->pace, now, period);
+111
View File
@@ -0,0 +1,111 @@
// Recall and Ultrahand target check (patch set "ability", recomp/patches-v143.txt and patches-v121.txt).
//
// main+0x1bd0138 on 1.4.3 (main+0x1622b60 on 1.2.1, the same code and actor offsets) runs while an ability picks its
// target. Once the owner's request says ready, it loads the result holder from the owner (x8 = [x19+0x6b0]), the
// target actor from the holder (x21 = [x8]), links the actor (main+0x155ec: reads the actor's +0x10, +0x24 and
// +0x1a8), reads [[x21+0x228]+0xb0] (main+0x9a89d4) and takes a reference on that (main+0x2b8464: an atomic
// read-modify-write of the word at +0x90). The holder can be reused memory by then, and the game crashes reading
// 0xffffffffffffffff (Windows' report of a non-canonical address) minutes to hours into play. UltraTears
// (kuraeow/ultratears, "ability target guard") found the class; this code is ours.
//
// A target is dropped only where the game's own code would fault on it: the holder or the actor unreadable, a link
// record the game follows unreadable or read-only, the component pointer unreadable, or the reference word
// unreadable or in a module's code or read-only data. Every
// other target goes on exactly as the game reads it, so no target the game can handle is ever lost. UltraTears' test
// of a live actor (its link record [actor+0x1a8] points back to it at +0x40 and carries its id at +0x48) is not in the
// game's code: the game links an actor whose link record is null without complaint. It runs here as a log line only,
// to show in players' logs whether it would ever reject a live target.
//
// The first site replaces `ldr x21, [x8]` with a call here; the second, at the game's `cbz x21` right after it, becomes
// `mov x21, x9; cbz x21`. The answer travels in x9 because the lifted caller keeps x21 (callee-saved) in a C local
// across the call and reloads only caller-saved registers; x9 is dead there on every path. x9 gets the holder's first
// word, or 0 for a dropped target, which the cbz skips for this frame as it skips an empty one. A null or tagged
// (bit 0) word goes back unchanged: the game skips those itself. No other register changes.
// Only an ability's target pick reaches this (hundreds of calls an hour), so the memory queries cost nothing.
#include <stdint.h>
#include "host.h"
#if __has_include("patches.h")
#include "patches.h"
#endif
#ifdef RT_PATCH_PAGE
#define HOST_ABILITY_TARGET (RT_PATCH_PAGE + 0xf60)
#define ACTOR_SPAN 0x230 // the actor fields the function and its callees read: +0x10 .. +0x22f
static int readable(uint64_t a, uint64_t n) { return a && !(a & 3) && mem_guest_readable(a, n); }
static uint64_t u64_at(uint64_t a) { return *(volatile uint64_t *)(uintptr_t)a; }
static uint32_t u32_at(uint64_t a) { return *(volatile uint32_t *)(uintptr_t)a; }
// [a, a+4) inside a module's code or read-only data: a write there faults.
static int read_only_module(uint64_t a) {
for (int i = 0; i < ldr_count(); i++) {
const RtLoaded *m = ldr_module(i);
if (a - m->base < m->size) return a - m->base < m->data_off;
}
return 0;
}
// NULL when the game's code can follow the actor without a fault, else what would fault.
static const char *faults(uint64_t actor) {
if (!readable(actor, ACTOR_SPAN)) return "actor not readable";
// main+0x155ec (1.2.1: main+0x809ecc) follows a non-null link record unless the actor's state word +0x24 is 7..11:
// it stores the record in the owner, updates +0x50 atomically (main+0x15838) and later compares +0x40 and +0x48.
uint64_t link = u64_at(actor + 0x1a8);
if (link && u32_at(actor + 0x24) - 7 >= 5 &&
(!readable(link + 0x40, 0x18) || read_only_module(link + 0x50)))
return "link record not writable";
uint64_t comp = u64_at(actor + 0x228);
if (!comp) return NULL; // main+0x9a89d4 returns 0 for it and the game stops there
if (!readable(comp + 0xb0, 8)) return "component not readable";
uint64_t ref = u64_at(comp + 0xb0);
if (!ref) return NULL; // the game's cbz x0 skips the reference
if (!readable(ref + 0x90, 4) || read_only_module(ref + 0x90)) return "reference word not writable";
return NULL;
}
// UltraTears' live-actor test, for the log: NULL when it passes.
static const char *not_live(uint64_t actor) {
uint64_t link = u64_at(actor + 0x1a8);
if (!readable(link + 0x40, 0x10)) return "link record not readable";
if (u64_at(link + 0x40) != actor) return "link record points elsewhere";
if (u32_at(link + 0x48) != u32_at(actor + 0x10)) return "link record has another id";
return NULL;
}
static void host_ability_target(Cpu *c) {
static uint64_t checked, dropped, mismatched;
uint64_t holder = c->x[8], actor = 0;
const char *why = NULL;
if (!readable(holder, 8)) why = "holder not readable";
else if ((actor = u64_at(holder)) && !(actor & 1)) why = faults(actor);
if (why) {
c->x[9] = 0;
uint64_t n = __atomic_add_fetch(&dropped, 1, __ATOMIC_RELAXED);
if (n <= 20 || !(n & (n - 1)))
rt_log("ability: target dropped, the game would fault on it (%s): holder %#llx actor %#llx; %llu dropped",
why, (unsigned long long)holder, (unsigned long long)actor, (unsigned long long)n);
return;
}
c->x[9] = actor;
if (!actor || (actor & 1)) return;
uint64_t k = __atomic_add_fetch(&checked, 1, __ATOMIC_RELAXED);
const char *odd = not_live(actor);
if (!odd) {
if (k == 1) rt_log("ability: first target checked (TOTK_ABILITY_GUARD=0: no check)");
return;
}
uint64_t n = __atomic_add_fetch(&mismatched, 1, __ATOMIC_RELAXED);
if (n <= 20 || !(n & (n - 1)))
rt_log("ability: target kept although the live-actor test fails (%s): actor %#llx; %llu of %llu targets", odd,
(unsigned long long)actor, (unsigned long long)n, (unsigned long long)k);
}
__attribute__((constructor)) static void ability_register(void) {
rt_register_host(HOST_ABILITY_TARGET, host_ability_target);
}
#endif
+2
View File
@@ -12,6 +12,7 @@
#include <string.h>
#include "cfg.h"
#include "gfx.h"
#include "host.h"
#include "input.h"
#include "ov.h"
@@ -93,6 +94,7 @@ static void npad_states(Cpu *c, uint32_t want) {
if (live) {
s.attributes = ATTR_CONNECTED;
input_poll(&s.buttons, &s.lx, &s.ly, &s.rx, &s.ry);
vk_reflex_marker(6, vk_reflex_frame()); // VK_LATENCY_MARKER_INPUT_SAMPLE_NV
}
*out = s;
ret_x(c, 1);
+4
View File
@@ -9,6 +9,7 @@
#include <opus/opus.h>
#include "host.h"
#include "audio_cat.h"
#include "platform/platform.h"
#define CODEC_R_INVALID 0x1fcd1u // MacNativeGames' "invalid argument" result for nn::codec
@@ -153,6 +154,7 @@ static void ov_decode(Cpu *c) {
int got = opus_decode(d->dec, in + 8, (opus_int32)n, out, (int)capacity, 0);
opus_uint32 final = 0;
if (got >= 0) opus_decoder_ctl(d->dec, OPUS_GET_FINAL_RANGE(&final));
int channels = d->channels;
release(d);
if (got < 0) {
rt_log("nn::codec: opus_decode: %s", opus_strerror(got));
@@ -163,6 +165,8 @@ static void ov_decode(Cpu *c) {
rt_log("nn::codec: Opus final range %#x != stream %#x (logged once)", (unsigned)final, (unsigned)range);
*consumed = 8 + n;
*samples = got;
if (got > 0 && audio_cat_active()) // the PCM's sound category for the music / effects / voice volumes
audio_cat_on_opus_decode(guest, (uint64_t)(uintptr_t)in, (uint64_t)(uintptr_t)out, (uint64_t)got * (uint64_t)channels * sizeof(int16_t));
ret_x(c, 0);
}
+5
View File
@@ -20,6 +20,7 @@
#include "cfg.h"
#include "host.h"
#include "audio_cat.h"
#if __has_include("patches.h")
#include "patches.h"
@@ -235,6 +236,10 @@ static void decode(Cpu *c, uint64_t dict, uint64_t dict_size, uint64_t ddict, ui
}
c->x[0] = r;
count(size, r, kern_now_ns() - t0);
// A sound bank (BARS) for the music / effects / voice volumes (audio_cat.c); its compressed bytes were tagged
// by the RomFS read, which gives the bank's category.
if (r >= 16 && !memcmp((const void *)(uintptr_t)dst, "BARS", 4) && audio_cat_active())
audio_cat_scan_bars(dst, (uint64_t)r, audio_cat_lookup(src));
}
static void host_multiframe(Cpu *c) { decode(c, c->x[5], c->x[6], c->x[7], GUEST_MULTIFRAME, 8); }
+138 -2
View File
@@ -34,6 +34,7 @@
#include <SDL3/SDL_clipboard.h>
#include "cfg.h"
#include "platform.h"
// The write-watch ABI of Linux 6.7 (uapi linux/fs.h and linux/userfaultfd.h), for headers older than it: the release
@@ -1250,7 +1251,135 @@ const char *plat_user_locale(void) {
return tag;
}
// Noto CJK as the common distributions and SteamOS install it; one collection covers every CJK language.
// A CJK font for the menu: the file that draws this language on this system.
//
// The languages the catalog has (ja, ko, zh-Hans, zh-Hant) are not covered by the font built into the menu, so their
// glyphs are merged in from a system file. Distributions disagree on where Noto CJK lives, and a sandboxed build
// (Flatpak, Snap, an AppImage on a host whose fonts are mounted at /run/host/fonts) may have no Noto CJK where the
// fixed paths expect it while the host still has CJK fonts that would do. So ask fontconfig first: it is the database
// Tk/Xft and every other Linux toolkit reads, it knows /app/share/fonts, the XDG data dirs, /run/host/fonts and the
// per-user dirs, and adding a font there is enough -- the menu does not need to learn about it. The fixed
// distribution paths stay as the fallback for a system without fontconfig, and TOTK_MENU_FONT overrides both.
//
// fontconfig is loaded with dlopen rather than linked, so a host without libfontconfig (a bare container) still builds
// and runs and just takes the fallback. The runtime already links -ldl for the NVIDIA libraries.
static int cjk_lang(const char *lang) {
return !strcmp(lang, "ja") || !strcmp(lang, "ko") || !strcmp(lang, "zh-Hans") || !strcmp(lang, "zh-Hant");
}
// The fontconfig language tag of a catalog language. GL says zh-Hans/zh-Hant, but fontconfig and OpenType name the
// faces zh-cn/zh-tw (Noto Sans CJK SC is lang=zh-cn), and a pattern naming only zh-hans does not reach it.
static const char *cjk_lang_tag(const char *lang) {
if (!strcmp(lang, "ja")) return "ja";
if (!strcmp(lang, "ko")) return "ko";
if (!strcmp(lang, "zh-Hans")) return "zh-cn";
return "zh-tw";
}
// The handful of fontconfig calls used here (2.0 ABI, unchanged since). Loaded once, kept for the process: the menu
// rebuilds its atlas when the window height changes and must not dlopen on every rebuild.
typedef struct _FcPattern FcPattern;
typedef struct _FcCharSet FcCharSet;
typedef struct _FcConfig FcConfig;
typedef struct {
int state; // 0 untried, 1 usable, -1 no fontconfig on this system
FcPattern *(*NameParse)(const unsigned char *);
void (*PatternDestroy)(FcPattern *);
int (*PatternAddCharSet)(FcPattern *, const char *, const FcCharSet *);
int (*PatternGetString)(const FcPattern *, const char *, int, unsigned char **);
FcCharSet *(*CharSetCreate)(void);
int (*CharSetAddChar)(FcCharSet *, unsigned int);
void (*CharSetDestroy)(FcCharSet *);
FcPattern *(*FontMatch)(FcConfig *, FcPattern *, int *); // 3 args: (config, pattern, FcResult *)
int (*PatternGetCharSet)(const FcPattern *, const char *, int, FcCharSet **);
int (*CharSetHasChar)(const FcCharSet *, unsigned int);
FcConfig *(*ConfigGetCurrent)(void);
int (*Init)(void);
} Fc;
static Fc fc;
static int fc_load(void) {
if (fc.state) return fc.state > 0;
void *lib = plat_lib_open("libfontconfig.so.1");
if (!lib) lib = plat_lib_open("libfontconfig.so");
if (!lib) { fc.state = -1; return 0; }
fc.NameParse = (FcPattern *(*)(const unsigned char *))plat_lib_sym(lib, "FcNameParse");
fc.PatternDestroy = (void (*)(FcPattern *))plat_lib_sym(lib, "FcPatternDestroy");
fc.PatternAddCharSet = (int (*)(FcPattern *, const char *, const FcCharSet *))plat_lib_sym(lib, "FcPatternAddCharSet");
fc.PatternGetString = (int (*)(const FcPattern *, const char *, int, unsigned char **))plat_lib_sym(lib, "FcPatternGetString");
fc.CharSetCreate = (FcCharSet *(*)(void))plat_lib_sym(lib, "FcCharSetCreate");
fc.CharSetAddChar = (int (*)(FcCharSet *, unsigned int))plat_lib_sym(lib, "FcCharSetAddChar");
fc.CharSetDestroy = (void (*)(FcCharSet *))plat_lib_sym(lib, "FcCharSetDestroy");
fc.FontMatch = (FcPattern *(*)(FcConfig *, FcPattern *, int *))plat_lib_sym(lib, "FcFontMatch");
fc.PatternGetCharSet = (int (*)(const FcPattern *, const char *, int, FcCharSet **))plat_lib_sym(lib, "FcPatternGetCharSet");
fc.CharSetHasChar = (int (*)(const FcCharSet *, unsigned int))plat_lib_sym(lib, "FcCharSetHasChar");
fc.ConfigGetCurrent = (FcConfig *(*)(void))plat_lib_sym(lib, "FcConfigGetCurrent");
fc.Init = (int (*)(void))plat_lib_sym(lib, "FcInit");
if (!fc.NameParse || !fc.PatternDestroy || !fc.PatternAddCharSet || !fc.PatternGetString || !fc.CharSetCreate ||
!fc.CharSetAddChar || !fc.CharSetDestroy || !fc.FontMatch || !fc.ConfigGetCurrent ||
!fc.PatternGetCharSet || !fc.CharSetHasChar) {
fc.state = -1;
return 0;
}
// FcInit loads the configuration and the font set; FcConfigGetCurrent is NULL before it, and FcFontMatch asserts
// on a NULL config. Idempotent, so the second call of a rebuild costs a flag check.
if (fc.Init) fc.Init();
if (!fc.ConfigGetCurrent()) {
fc.state = -1;
return 0;
}
fc.state = 1;
return 1;
}
// The file fontconfig picks for this language, or 0. Asks for the generic CJK-capable family with the language set and
// one representative character of that language in the charset, so a Latin-only or Japanese face cannot win by default.
static int fc_font_for(const char *lang, char *out, size_t cap) {
static const struct { const char *lang; unsigned int cp; } probe[] = {
{"ja", 0x65E5}, // 日
{"ko", 0xD55C}, // 한
{"zh-Hans", 0x8BBE}, // 设
{"zh-Hant", 0x8A2D}, // 設
};
unsigned int cp = 0;
for (size_t i = 0; i < sizeof probe / sizeof *probe; i++)
if (!strcmp(probe[i].lang, lang)) cp = probe[i].cp;
if (!cp || !fc_load()) return 0;
char query[64];
snprintf(query, sizeof query, "sans-serif:lang=%s", cjk_lang_tag(lang));
FcPattern *pat = fc.NameParse((const unsigned char *)query);
if (!pat) return 0;
FcCharSet *cs = fc.CharSetCreate();
int ok = 0;
if (cs) {
fc.CharSetAddChar(cs, cp);
if (fc.PatternAddCharSet(pat, "charset", cs)) {
int result = 0; // FcResult; FcFontMatch asserts when this pointer is NULL
FcPattern *m = fc.FontMatch(fc.ConfigGetCurrent(), pat, &result);
unsigned char *file = NULL;
if (m) {
// fontconfig returns the closest pattern even when nothing covers the character, so check the charset
// before trusting it: without this a Latin-only system hands back DejaVu Sans and the menu merges no
// glyphs while believing it did.
FcCharSet *got = NULL;
if (result == 0 /* FcResultMatch */ &&
fc.PatternGetCharSet(m, "charset", 0, &got) == 0 && got && fc.CharSetHasChar(got, cp) &&
fc.PatternGetString(m, "file", 0, &file) == 0 && file)
ok = snprintf(out, cap, "%s", (const char *)file) < (int)cap;
fc.PatternDestroy(m);
}
}
fc.CharSetDestroy(cs);
}
fc.PatternDestroy(pat);
return ok;
}
// See platform.h. TOTK_MENU_FONT names a file to use for every CJK language; then fontconfig; then the fixed paths,
// which are the normal layout on SteamOS and the distributions that predate fontconfig's own lookup.
int plat_font_path(const char *lang, char *out, size_t cap) {
static const char *files[] = {
"/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",
@@ -1259,7 +1388,14 @@ int plat_font_path(const char *lang, char *out, size_t cap) {
"/usr/share/fonts/noto/NotoSansCJK-Regular.ttc",
"/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
};
if (strcmp(lang, "ja") && strcmp(lang, "ko") && strcmp(lang, "zh-Hans") && strcmp(lang, "zh-Hant")) return 0;
if (!cjk_lang(lang)) return 0;
char override[PATH_MAX];
if (plat_getenv("TOTK_MENU_FONT", override, sizeof override) && plat_file_exists(override))
return snprintf(out, cap, "%s", override) < (int)cap;
// menu_font_fontconfig=0 skips the fontconfig lookup and keeps the five fixed paths, for a player whose fontconfig
// resolves to a face the font parser cannot read. Read through cfg_bool like every other switch, so totk.ini and
// the TOTK_ variable both work and the menu can grey it out.
if (cfg_bool("TOTK_MENU_FONT_FONTCONFIG") && fc_font_for(lang, out, cap) && plat_file_exists(out)) return 1;
for (size_t i = 0; i < sizeof files / sizeof *files; i++)
if (plat_file_exists(files[i])) return snprintf(out, cap, "%s", files[i]) < (int)cap;
return 0;
+3 -1
View File
@@ -387,7 +387,9 @@ const char *plat_ui_language(void);
const char *plat_user_locale(void);
uint32_t plat_thread_id(void); // id of the calling thread, for unique file names
// A system font file with the glyphs of a catalog language ("ja", "ko", "zh-Hans", "zh-Hant"): the menu shows each
// language's name in its own script. Copies the UTF-8 path into out; 0 when the system has none.
// language's name in its own script. Copies the UTF-8 path into out; 0 when the system has none. On Linux the file is
// the one fontconfig picks for that language (so a sandbox that installs a font where its fontconfig finds it needs no
// code change), with TOTK_MENU_FONT overriding it and the usual distribution paths as the fallback.
int plat_font_path(const char *lang, char *out, size_t cap);
// The operating system and its build ("Windows 10.0.28000") into out; 0 when unknown.
int plat_os_version(char *out, size_t cap);
+51 -2
View File
@@ -243,6 +243,23 @@ static double scene_scale(void) {
uint64_t res_heap_extra_bytes(void) { return ((res_heap_extra_kib() << 10) + 0x1fffff) & ~0x1fffffull; }
// TOTK_GRASS_RANGE (percent, 50 to 400; 100 = the game's): how far around the camera grass blades grow. The near grass
// map (the grass patch set, recomp/patches-v121.txt and patches-v143.txt) covers 62.5 m and draws into 256x256 and
// 128x128 textures; other values scale the extent, its step and both textures together, so the grass keeps its detail
// per metre. The larger textures come from the grass heap "草" of the HeapDef, which has no room for them (at 200 %
// without growth the game stops at start on a failed allocation), so it grows by 9318 KiB, its size in 1.4.3, times
// the textures' growth in area (k^2 - 1).
#define GRASS_HEAP_KIB 9318
static int grass_pct(void) {
int pct = cfg_int("TOTK_GRASS_RANGE");
return pct < 50 ? 50 : pct > 400 ? 400 : pct;
}
uint64_t res_grass_heap_extra_kib(void) {
int pct = grass_pct();
return pct > 100 ? (uint64_t)GRASS_HEAP_KIB * (uint64_t)(pct * pct - 10000) / 10000 : 0;
}
uint64_t res_grass_heap_extra_bytes(void) { return ((res_grass_heap_extra_kib() << 10) + 0x1fffff) & ~0x1fffffull; }
// TOTK_TEX_HEAP_EXTRA_MB (0 to 4096): more room in "TextureHeap" and its parent "ゲームグラフィックス", the heap the
// world's textures stream into. HD texture packs made for emulators with 8 GB of DRAM grow it by about 3.3 GiB in their
// own HeapDef; without the room the game runs out and starts its panic Blood Moon over and over. The pool and the heap
@@ -397,9 +414,9 @@ int res_heapdef_plain(const void *in, size_t n) {
}
int res_heapdef_build(const void *in, size_t n, void **out, size_t *out_n) {
uint64_t extra = res_heap_extra_kib(), tex = tex_heap_extra_kib();
uint64_t extra = res_heap_extra_kib(), tex = tex_heap_extra_kib(), grass = res_grass_heap_extra_kib();
*out = NULL;
if (!extra && !tex) return 0;
if (!extra && !tex && !grass) return 0;
Byml b;
uint32_t heaps = 0;
size_t dta_at = 0, gfx_at = 0;
@@ -439,6 +456,17 @@ int res_heapdef_build(const void *in, size_t n, void **out, size_t *out_n) {
}
}
}
if (grass) {
size_t at = heap_size_field(&b, heaps, "\xe8\x8d\x89"); // 草, the grass heap
if (at) {
int32_t g, g2;
memcpy(&g, b.p + at, 4);
g2 = g + (int32_t)grass;
memcpy(b.p + at, &g2, 4);
rt_log("resolution: HeapDef grass heap %d -> %d KiB (TOTK_GRASS_RANGE)", g, g2);
} else
rt_log("resolution: the HeapDef table has no grass heap; grass_range may run out of grass memory");
}
size_t cap = ZSTD_compressBound(b.n);
void *z = malloc(cap);
size_t zn = z ? ZSTD_compress(z, cap, b.p, b.n, 9) : 0;
@@ -499,8 +527,29 @@ static void res_shadow_range(void) {
rt_log("resolution: shadow cascades end at %g, %g, %g and %g m", d[0], d[1], d[2], d[3]);
}
// The grass map's values on page +128..+144 (the grass patch set): extent, step, the two texture sizes, and the
// half extent main+0x206340c picks instead of the extent. Texture sizes stay multiples of 32.
static void res_grass_range(void) {
int pct = grass_pct(), set = rt_patch_set("grass");
if (pct == 100) return;
if (set < 0) {
rt_log("resolution: this game version has no grass patch set; grass_range stays 100");
return;
}
float k = pct / 100.0f, f[2] = {62.5f * k, 3.90625f * k}, half = 31.25f * k;
uint32_t t[2] = {(uint32_t)(256 * pct / 100 + 16) / 32 * 32, (uint32_t)(128 * pct / 100 + 16) / 32 * 32};
uint8_t *page = rt_patch_page();
memcpy(page + 128, f, sizeof f);
memcpy(page + 136, t, sizeof t);
memcpy(page + 144, &half, sizeof half);
rt_patch_switch(set, 1);
rt_log("resolution: grass map %g m, textures %ux%u and %ux%u (TOTK_GRASS_RANGE=%d)", f[0], t[0], t[0], t[1], t[1],
pct);
}
void res_init(void) {
res_shadow_range();
res_grass_range();
if (!bigger()) {
rt_log("resolution: the game's own (output 1920x1080, scene 1600x900)");
shadow_init(rt_patch_page());
+187 -24
View File
@@ -38,6 +38,7 @@
#include "mods.h"
#include "romfs_config.h"
#include "romfs_path.h"
#include "audio_cat.h"
#include "platform/platform.h"
#include "restbl.h"
#include "sha256.h"
@@ -69,6 +70,7 @@ static PlatMutex lock = PLAT_MUTEX_INIT;
static uint64_t handles[NH]; // file index + 1; 0 is free
static uint32_t handle_ovl[NH]; // overlay slot + 1 of an open handle, 0 = original
static PlatFile *handle_file[NH]; // the handle's open overlay file, when handle_ovl is set
static uint8_t handle_audio_cat[NH]; // the open file's sound category (audio_cat.c), AUDIO_CAT_UNKNOWN when not audio
static Overlay *overlays; // sorted by RomFS index after overlay_init
static size_t noverlay, overlay_cap;
static char **added; // RomFS paths of the added files, sorted; added[k] is index file_count + k
@@ -340,7 +342,8 @@ static void overlay_push(Overlay o) {
}
// 1 when path names a file of one game version only (Product.<n> in a name: the resource size table, the actor
// database and other version-bound files); the RomFS lacking it means it is another version's.
// database and other version-bound files); the RomFS lacking it means it is another version's, or a name this version
// still asks for (mod_walk_cb).
static int other_version(const char *path) {
for (const char *p = strstr(path, ".Product."); p; p = strstr(p + 1, ".Product.")) {
const char *d = p + strlen(".Product.");
@@ -420,9 +423,18 @@ static int mod_walk_cb(const char *leaf, int kind, uint64_t size, void *ctx) {
}
uint64_t i = index_any_case(path);
if (i == UINT64_MAX && other_version(path)) {
if (is_restbl(path)) shipped_add(file, w->k + 1, 1); // its entries for this mod's files still apply
m->other_version++;
return 1;
// Another version's resource size table is no file this game opens; its entries for this mod's files still
// apply.
if (is_restbl(path)) {
shipped_add(file, w->k + 1, 1);
return 1;
}
// Any other file is served under its own name below, as an added file, the way LayeredFS shows a console every
// file of a mod: the game does ask for names its RomFS lacks. Measured on 1.4.3 with mods on (trace = fs): it
// opened Sound/Resource/Pack_MasterSword.Product.110.bars.zs, where its RomFS holds Product.140 and the
// unversioned file only. A sound mod that ships its pack under all those names stayed silent while this file
// was left out.
}
PlatFile *f = open_read(file);
if (!f) {
@@ -878,7 +890,7 @@ static void *plain_mod_heapdef(size_t *n, const char **who) {
return NULL;
}
static void heapdef_overlay(void) {
if (!res_heap_extra_kib() && !res_tex_heap_extra_bytes()) return;
if (!res_heap_extra_kib() && !res_tex_heap_extra_bytes() && !res_grass_heap_extra_kib()) return;
static const char keeps[] = "the game keeps its own resolution";
Overlay *base;
size_t n;
@@ -957,11 +969,29 @@ static void overlay_drop(size_t a, size_t b) {
noverlay -= b - a;
}
// The folder <prefix>-<w>x<h> the game resolution w x h takes in base: that exact size when it has a manifest (an
// install by a setup that wrote every size, or make_romfs_patches.py --aspect <w>x<h> in a source build), else the
// size of its shape (cfg.c cfg_shape_size), the one folder per shape installer/steps.py Shapes writes. name gets the
// folder found, or the shape's one when neither has a manifest (for the log). 1 when found.
static int shaped_name(const char *base, const char *prefix, unsigned w, unsigned h, char *name, size_t cap) {
char path[2400];
unsigned s[2] = {w, h};
for (int pass = 0; pass < 2; pass++) {
if (pass && !cfg_shape_size(w, h, s)) break;
if (pass && s[0] == w && s[1] == h) break;
snprintf(name, cap, "%s-%ux%u", prefix, s[0], s[1]);
if (snprintf(path, sizeof path, "%s/%s/manifest.tsv", base, name) < (int)sizeof path && plat_file_exists(path))
return 1;
}
return 0;
}
static void overlay_init(void) {
// TOTK_ROMFS_PATCHES unset: romfs-patches next to romfs-index.bin if it has a manifest (tools/make_romfs_patches.py).
// A game resolution that is not 16:9 takes romfs-patches-<w>x<h> instead when it is there: the same overlay with
// the UI laid out for that shape (make_romfs_patches.py --aspect), when the game version has the camera aspect patch
// the layout goes with (res_wants_wide_overlay).
// A game resolution that is not 16:9 takes romfs-patches-<w>x<h> instead when it is there (shaped_name: the exact
// size, else the folder of its shape): the same overlay with the UI laid out for that shape
// (make_romfs_patches.py --aspect), when the game version has the camera aspect patch the layout goes with
// (res_wants_wide_overlay).
// With prompts = xbox, the Xbox prompts' folder for the pad layout in its place (input_prompts_folder): the same
// patches with Xbox button icons (make_romfs_patches.py --prompts); prompts = pc takes romfs-patches-pc whatever
// the pad layout. The game reads the archives once at boot, so the prompts stay until restart even though the
@@ -977,23 +1007,29 @@ static void overlay_init(void) {
int wide = 0;
unsigned out[2];
res_wanted(out);
unsigned shape[2] = {out[0], out[1]}; // the --aspect of the folder made for this shape
cfg_shape_size(out[0], out[1], shape);
if (!patches && res_wants_wide_overlay(out)) {
if (snprintf(def, sizeof def, "%s/romfs-patches-%ux%u/manifest.tsv", index_dir, out[0], out[1]) < (int)sizeof def &&
plat_file_exists(def)) {
def[strlen(def) - strlen("/manifest.tsv")] = 0;
char name[128];
if (shaped_name(index_dir, "romfs-patches", out[0], out[1], name, sizeof name) &&
snprintf(def, sizeof def, "%s/%s", index_dir, name) < (int)sizeof def) {
patches = def, wide = 1;
rt_log("RomFS overlay: the UI layout for %ux%u from %s", out[0], out[1], name);
} else {
rt_log("RomFS overlay: no romfs-patches-%ux%u for this game resolution, the UI keeps its 16:9 layout "
"(tools/make_romfs_patches.py --aspect %ux%u)", out[0], out[1], out[0], out[1]);
rt_log("RomFS overlay: no %s for this game resolution, the UI keeps its 16:9 layout (run the setup again, "
"or tools/make_romfs_patches.py --aspect %ux%u)", name, shape[0], shape[1]);
}
}
static const char *const layouts[2] = {"nintendo", "xbox"}; // one of each Xbox folder, then the PC one
for (int i = 0; i < 3; i++) {
const char *name = i < 2 ? input_prompts_folder(PROMPTS_XBOX, layouts[i]) : input_prompts_folder(PROMPTS_PC, 0);
char *dir = prompts_folders[i].dir;
if (wide) snprintf(dir, sizeof prompts_folders[i].dir, "%s-%ux%u", name, out[0], out[1]);
else snprintf(dir, sizeof prompts_folders[i].dir, "%s", name);
prompts_folders[i].name = name;
if (wide) {
prompts_folders[i].ready = shaped_name(index_dir, name, out[0], out[1], dir, sizeof prompts_folders[i].dir);
continue;
}
snprintf(dir, sizeof prompts_folders[i].dir, "%s", name);
prompts_folders[i].ready =
snprintf(path, sizeof path, "%s/%s/manifest.tsv", index_dir, dir) < (int)sizeof path && plat_file_exists(path);
}
@@ -1025,7 +1061,7 @@ static void overlay_init(void) {
char why[256];
if (prompts_off == ROMFS_PROMPTS_SHAPE)
snprintf(why, sizeof why, "the game resolution has no %s (tools/make_romfs_patches.py --prompts %s "
"--aspect %ux%u)", wanted_dir, prompts_wanted + strlen("romfs-patches-"), out[0], out[1]);
"--aspect %ux%u)", wanted_dir, prompts_wanted + strlen("romfs-patches-"), shape[0], shape[1]);
else
snprintf(why, sizeof why, "%s", prompts_off == ROMFS_PROMPTS_PATCHES
? "TOTK_ROMFS_PATCHES is set"
@@ -1081,26 +1117,138 @@ static void index_path(char *out, size_t cap) {
strcpy(out + k, "romfs-index.bin");
}
// 1 when <prefix>-<w>x<h> has a manifest next to romfs-index.bin. Works before fs_init: index_dir is not set that early
// (cfg_init, res_init and resolution.c decide run first), so the index path is worked out again here.
static int shaped_folder_ready(const char *prefix, unsigned w, unsigned h) {
char dir[2100], path[2200];
index_path(dir, sizeof dir);
// The folder of romfs-index.bin. Works before fs_init: index_dir is not set that early (cfg_init, res_init and
// resolution.c decide run first), so the index path is worked out again here.
static void index_folder(char *dir, size_t cap) {
index_path(dir, cap);
char *sep = plat_last_sep(dir);
if (sep) *sep = 0;
else strcpy(dir, ".");
return snprintf(path, sizeof path, "%s/%s-%ux%u/manifest.tsv", dir, prefix, w, h) < (int)sizeof path &&
plat_file_exists(path);
}
// 1 when the game resolution w x h has the UI layout of its shape: romfs-patches-<w>x<h>, the folder overlay_init
// looks for.
// 1 when the folder overlay_init takes for <prefix> at w x h (shaped_name) has a manifest next to romfs-index.bin.
static int shaped_folder_ready(const char *prefix, unsigned w, unsigned h) {
char dir[2100], name[128];
index_folder(dir, sizeof dir);
return shaped_name(dir, prefix, w, h, name, sizeof name);
}
// 1 when the game resolution w x h has the UI layout of its shape: romfs-patches-<w>x<h> of that size or of its shape,
// the folder overlay_init looks for.
int romfs_shaped_ready(unsigned w, unsigned h) { return shaped_folder_ready("romfs-patches", w, h); }
// 1 when it has a prompts' folder (input_prompts_folder) with that layout too: <folder>-<w>x<h>, which overlay_init
// loads in its place with those prompts.
int romfs_shaped_prompts_ready(const char *folder, unsigned w, unsigned h) { return shaped_folder_ready(folder, w, h); }
// ---- the layout for a new screen, from the settings menu (ui/menu.cpp row_output_res)
// The setup writes the shaped folders for the displays connected when it ran (installer/steps.py Shapes). After a
// monitor change the menu can start the same generator for the shape of the game resolution: the setup's Python and
// tools/make_romfs_patches.py, which build-cache/rebuild.txt names (installer/steps.py write_rebuild_command: line 1 the
// Python, pythonw on Windows, so no console opens; line 4 the setup's folder), on the install folder's romfs/. Child
// processes the game does not wait for: the generator writes manifest.tsv last, so a folder it has not finished is not
// taken, and the next start loads the finished one.
static int prepare_tools(char *python, size_t pcap, char *script, size_t scap, char *dir, size_t dcap) {
char path[2400];
index_folder(dir, dcap);
uint64_t n = 0;
snprintf(path, sizeof path, "%s/build-cache/rebuild.txt", dir);
char *text = (char *)plat_file_read(path, &n);
if (!text) return 0;
char *lines[5] = {0};
int k = 0;
for (char *p = text; k < 5 && p < text + n;) {
char *e = memchr(p, '\n', (size_t)(text + n - p));
if (!e) e = text + n;
if (e > p && e[-1] == '\r') e[-1] = 0;
*e = 0;
lines[k++] = p;
p = e + 1;
}
int ok = k >= 4 && !strcmp(lines[1], "-c") && snprintf(python, pcap, "%s", lines[0]) < (int)pcap &&
snprintf(script, scap, "%s/tools/make_romfs_patches.py", lines[3]) < (int)scap;
free(text);
snprintf(path, sizeof path, "%s/romfs/romfs.bin", dir);
return ok && plat_file_exists(python) && plat_file_exists(script) && plat_file_exists(path);
}
int romfs_shape_missing(unsigned w, unsigned h, const char *prompts_folder) {
unsigned out[2] = {w, h};
if (!res_wants_wide_overlay(out)) return 0;
return !shaped_folder_ready("romfs-patches", w, h) ||
(prompts_folder && romfs_prompts_ready(prompts_folder) && !shaped_folder_ready(prompts_folder, w, h));
}
int romfs_shape_can_prepare(void) {
static int known = -1;
if (known < 0) {
char python[1024], script[1100], dir[2100];
known = prepare_tools(python, sizeof python, script, sizeof script, dir, sizeof dir);
}
return known;
}
// The folders a generator was started for in this process. The menu thread alone calls romfs_shape_prepare, so no
// lock. The game picks its overlay at start, so a folder is not started twice before the next start, even when its
// generator has ended: a second click, or the same size chosen again, starts no second generator writing into it.
static char shape_started[8][160];
static int shape_started_n;
static int shape_was_started(const char *folder) {
for (int i = 0; i < shape_started_n; i++)
if (!strcmp(shape_started[i], folder)) return 1;
return 0;
}
// Starts the generator for folder (a name in dir) unless one was started for it before. 1 when one runs for it, 0 when
// it could not start. plat_spawn starts it detached and closes its handles without waiting, so a click costs the menu
// thread one CreateProcess.
static int shape_spawn(const char *const *argv, const char *dir, const char *folder) {
if (shape_was_started(folder)) return 1;
if (!plat_spawn(argv, dir)) return 0;
if (shape_started_n < (int)(sizeof shape_started / sizeof *shape_started))
snprintf(shape_started[shape_started_n++], sizeof *shape_started, "%s", folder);
return 1;
}
int romfs_shape_prepare(unsigned w, unsigned h, const char *prompts_folder) {
char python[1024], script[1100], dir[2100], romfs[2200], out[2300], reuse[2300], binds[2300], size[32], version[8],
name[128], folder[160];
unsigned s[2];
if (!cfg_shape_size(w, h, s) || !prepare_tools(python, sizeof python, script, sizeof script, dir, sizeof dir))
return 0;
snprintf(size, sizeof size, "%ux%u", s[0], s[1]);
snprintf(version, sizeof version, "v%d", rt_game_version);
snprintf(romfs, sizeof romfs, "%s/romfs", dir);
int started = 0, failed = 0;
if (!shaped_name(dir, "romfs-patches", w, h, name, sizeof name)) {
snprintf(folder, sizeof folder, "romfs-patches-%s", size);
snprintf(out, sizeof out, "%s/%s", dir, folder);
const char *argv[] = {python, script, "--version", version, "--romfs", romfs, "--out", out, "--aspect", size,
NULL};
if (shape_spawn(argv, dir, folder)) started++;
else failed++;
}
snprintf(reuse, sizeof reuse, "%s/%s/manifest.tsv", dir, prompts_folder ? prompts_folder : "");
if (prompts_folder && plat_file_exists(reuse) && !shaped_name(dir, prompts_folder, w, h, name, sizeof name)) {
const char *style = prompts_folder + strlen("romfs-patches-");
snprintf(reuse, sizeof reuse, "%s/%s", dir, prompts_folder);
snprintf(folder, sizeof folder, "%s-%s", prompts_folder, size);
snprintf(out, sizeof out, "%s/%s", dir, folder);
// The keyboard and mouse prompts are drawn from totk.ini's bind_ lines, as the setup's PcPrompts and Shapes
// steps draw them (installer/steps.py pc_binds); a file without such lines gives the keyboard defaults.
snprintf(binds, sizeof binds, "%s/totk.ini", dir);
int pc = !strcmp(style, "pc") && plat_file_exists(binds);
const char *argv[] = {python, script, "--version", version, "--romfs", romfs, "--out", out, "--prompts", style,
"--aspect", size, "--reuse", reuse, pc ? "--binds" : NULL, binds, NULL};
if (shape_spawn(argv, dir, folder)) started++;
else failed++;
}
rt_log("RomFS overlay: making the layout for %s in the background (%d generators running, %d failed; %s)", size,
started, failed, script);
return started && !failed;
}
static void load_index(void) {
char path[2100];
index_path(path, sizeof path);
@@ -1249,12 +1397,21 @@ uint32_t romfs_open(uint64_t *out, const char *path, int mode) {
if (!f || memcmp(&id, &o->id, sizeof id))
rt_fatal("RomFS overlay %s is missing or changed since the start check (restart the game)", o->path);
}
// The handle keeps its sound category (audio_cat.c) even while the volume settings are at 100, so a stream opened
// before a setting moves is classified by its later reads. A stream may start reading past its header (the
// header came with the BARS bank), so the coefficients are taken from the image here.
int cat = audio_cat_from_path(p);
if (cat != AUDIO_CAT_UNKNOWN && !ov && image_map && audio_cat_active()) {
Entry e = entry(i);
if (e.size >= 0x40) audio_cat_scan_bwav(image_map + e.offset, e.size < 4096 ? e.size : 4096, cat);
}
plat_mutex_lock(&lock);
for (unsigned j = 1; j < NH; j++)
if (!handles[j]) {
handles[j] = i + 1;
handle_ovl[j] = ov;
handle_file[j] = f;
handle_audio_cat[j] = (uint8_t)cat;
*out = ROMFS_HANDLE_BASE + j;
plat_mutex_unlock(&lock);
return 0;
@@ -1304,6 +1461,11 @@ uint32_t romfs_read(uint64_t *out, uint64_t h, int64_t offset, void *buffer, uin
done += (uint64_t)r;
}
*out = done;
uint64_t j = h - ROMFS_HANDLE_BASE;
if (handle_audio_cat[j] != AUDIO_CAT_UNKNOWN && done && audio_cat_active()) {
if (offset == 0) audio_cat_scan_bwav(buffer, done, handle_audio_cat[j]);
audio_cat_tag_range((uint64_t)(uintptr_t)buffer, done, handle_audio_cat[j]);
}
return 0;
}
@@ -1326,6 +1488,7 @@ void romfs_close(uint64_t h) {
handles[j] = 0;
handle_ovl[j] = 0;
handle_file[j] = NULL;
handle_audio_cat[j] = 0;
plat_mutex_unlock(&lock);
if (of) plat_file_close(of);
}
+298 -42
View File
@@ -1,17 +1,27 @@
#version 450
// Portions adapted from RenoDX. Copyright (C) 2025-2026 Carlos Lopez Jr. and RenoDX contributors.
// SPDX-License-Identifier: MIT
// The game's tonemap pass for HDR output (runtime/vk_hdr.c vk_hdr_shader_swap puts it in place of the translated
// shader when TOTK_HDR=1). Same inputs as the game's: fp_t_tcb_8 (bloom, clamped to 10000 as the game does) plus
// fp_t_tcb_A (the scene), weights in c1[0] and the saturation grade in c3[0]. The game maps luminance and each channel
// with 1 - e^-x, blends the two by the luminance curve squared, clamps to 0..1 and grades saturation. Here the curve is
// the game's up to PIVOT and a straight line with its slope above, so mid-greys look as in SDR and highlights keep
// going; the grade works on the colour divided by its largest channel above 1; a roll-off on the largest channel stops
// at the display's peak. The output is relative to the HUD's white (1.0), which the present maps to TOTK_HDR_UI_NITS.
// Hue correction (hdr.z, TOTK_HDR_HUE): the game's SDR clamp turns bright saturated colours towards white (a torch flame
// clips red, then green, and reads yellow-white, the colour its emitted light was tuned to); the extended curve keeps
// their ratios, so they stay saturated. From the picture's white upwards the colour moves towards the game's own SDR
// result at the HDR luminance, by up to hdr.z (RenoDX's TotK mod has the same control).
// Approach after RenoDX's TotK mod by souperman9 and Musa (github.com/clshortfuse/renodx, src/games/totk, MIT): its
// "extended vanilla" curve.
// fp_t_tcb_A (the scene), weights in c1[0] and the saturation grade in c3[0].
//
// The HDR reconstruction follows RenoDX's TotK defaults more closely than the original recomp implementation:
// - the game's 1 - e^-x tone curve is extended along its tangent above 0.18;
// - the vanilla SDR tonemap is kept as a donor for hue and purity;
// - MacLeod-Boynton hue/purity transfer is performed through XYZ/LMS in BT.2020. hdr.z (TOTK_HDR_HUE, 0..1) scales
// both: at its default 0.7 the hue moves 70% and the purity 65% of the way to the SDR donor, RenoDX's defaults
// ("Hue Shift" and "SDR Blowout"); at 0 bright colours keep the extended curve's saturation. This replaces the
// earlier blend towards the SDR result scaled to the HDR luminance, which the same setting drove;
// - the game's saturation grade is applied after a temporary neutral max-channel compression, then expanded back;
// - the result is constrained to non-negative BT.709 and display-mapped with per-channel Neutwo in linear BT.2020;
// - RenoDX's default 2.2 gamma correction is folded into the native linear path: the Neutwo peak is corrected before
// display mapping and the corresponding sRGB-to-gamma-2.2 appearance correction is applied after tone mapping.
// The output remains linear BT.709 relative to the HUD's white (1.0), so the game's later HUD passes and the existing
// HDR10 present encoder continue to work unchanged.
//
// Color reconstruction, gamma correction and Neutwo math adapted from RenoDX (MIT), clshortfuse/renodx commit
// 43c067b755a6a741f6500b2b936570f1462dcfbe, notably src/games/totk/tonemap.slang,
// src/games/totk/macleod_boynton.hlsli, src/shaders/colorcorrect.hlsl and src/shaders/tonemap/neutwo.hlsl.
// Bindings are those of the game's translated shader: vk_hdr.c rewrites them from the original's names.
layout(location = 0) in vec4 uv;
layout(location = 0) out vec4 color;
@@ -26,15 +36,264 @@ layout(set = 0, binding = 3, std140) uniform C1 { vec4 v[4096]; } fp_c1;
layout(set = 0, binding = 4, std140) uniform C3 { vec4 v[4096]; } fp_c3;
const float PIVOT = 0.18;
const float PURITY_PER_HUE = 0.65 / 0.70; // RenoDX's default SDR blowout against its default hue shift
const float GAMMA = 2.2;
const float MB_EPSILON = 1e-20;
const float MB_INTERVAL_MAX = 1e30;
const float MB_NEAR_WHITE_EPSILON = 1e-14;
const float MB_T_MIN = 1e-6;
float curve(float x) { // the game's 1 - e^-x below PIVOT, its tangent there above
float y0 = 1.0 - exp(-PIVOT);
return x <= PIVOT ? 1.0 - exp(-x) : y0 + exp(-PIVOT) * (x - PIVOT);
}
vec3 curve3(vec3 x) { return vec3(curve(x.r), curve(x.g), curve(x.b)); }
// Column-major GLSL matrices. Values match the RenoDX TotK MacLeod-Boynton implementation.
const mat3 XYZ_TO_LMS_2006 = mat3(
vec3(0.185082982238733, -0.134433056469973, 0.000789456671966863),
vec3(0.584081279463687, 0.405752392775348, -0.000912281325916184),
vec3(-0.0240722415044404, 0.0358252602217631, 0.0198490812339463));
const mat3 LMS_TO_XYZ_2006 = mat3(
vec3(2.628474773947687, 0.8765342837340055, -0.06425592569153735),
vec3(-3.761263499279893, 1.2003038085515867, 0.20476359921126536),
vec3(9.9763571339745, -1.1033785928646218, 49.93266413348867));
const mat3 BT709_TO_XYZ = mat3(
vec3(0.4123907993, 0.2126390059, 0.0193308187),
vec3(0.3575843394, 0.7151686788, 0.1191947798),
vec3(0.1804807884, 0.0721923154, 0.9505321522));
const mat3 XYZ_TO_BT709 = mat3(
vec3(3.2409699419, -0.9692436363, 0.0556300797),
vec3(-1.5373831776, 1.8759675015, -0.2039769589),
vec3(-0.4986107603, 0.0415550574, 1.0569715142));
const mat3 BT2020_TO_XYZ = mat3(
vec3(0.6369580483, 0.2627002120, 0.0),
vec3(0.1446169036, 0.6779980715, 0.0280726930),
vec3(0.1688809752, 0.0593017165, 1.0609850577));
const mat3 XYZ_TO_BT2020 = mat3(
vec3(1.7166511880, -0.6666843518, 0.0176398574),
vec3(-0.3556707838, 1.6164812366, -0.0427706133),
vec3(-0.2533662814, 0.0157685458, 0.9421031212));
// The chains the per-pixel code uses, folded at compile time: one matrix per conversion instead of two.
const mat3 BT709_TO_BT2020 = XYZ_TO_BT2020 * BT709_TO_XYZ;
const mat3 BT2020_TO_BT709 = XYZ_TO_BT709 * BT2020_TO_XYZ;
const mat3 BT2020_TO_LMS = XYZ_TO_LMS_2006 * BT2020_TO_XYZ;
const mat3 LMS_TO_BT2020 = XYZ_TO_BT2020 * LMS_TO_XYZ_2006;
// D65 white (x 0.31272, y 0.32903) in LMS, and its MacLeod-Boynton coordinates (l, s) = (L, S) / (L + M).
const vec3 WHITE_LMS = XYZ_TO_LMS_2006 * vec3(0.31272 / 0.32903, 1.0, (1.0 - 0.31272 - 0.32903) / 0.32903);
const vec2 MB_WHITE = vec2(WHITE_LMS.x, WHITE_LMS.z) / (WHITE_LMS.x + WHITE_LMS.y);
float maxc(vec3 c) { return max(c.r, max(c.g, c.b)); }
float minc(vec3 c) { return min(c.r, min(c.g, c.b)); }
float div_safe(float a, float b, float fallback) { return b == 0.0 ? fallback : a / b; }
vec3 to_bt2020(vec3 c) { return BT709_TO_BT2020 * c; }
vec3 to_bt709(vec3 c) { return BT2020_TO_BT709 * c; }
// RenoDX GammaSafe(c, true, 2.2): sRGBDecode(GammaEncode(c, 2.2)). Used on the peak ratio before Neutwo.
float srgb_decode(float c) {
return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);
}
float gamma22_to_srgb_linear(float c) {
float a = abs(c);
float v = srgb_decode(pow(a, 1.0 / GAMMA));
return c < 0.0 ? -v : v;
}
// RenoDX GammaSafe(c, false, 2.2): GammaDecode(sRGBEncode(c), 2.2). In RenoDX this is paired with a gamma-2.2
// intermediate encode/decode. The native recomp stays linear, so applying this once here gives the same linear result.
float srgb_encode(float c) {
return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;
}
float srgb_linear_to_gamma22_linear(float c) {
float a = abs(c);
float v = pow(srgb_encode(a), GAMMA);
return c < 0.0 ? -v : v;
}
vec3 srgb_linear_to_gamma22_linear(vec3 c) {
return vec3(srgb_linear_to_gamma22_linear(c.r),
srgb_linear_to_gamma22_linear(c.g),
srgb_linear_to_gamma22_linear(c.b));
}
float vanilla_curve(float x) { return 1.0 - exp(-x); }
float extended_curve(float x) {
float y0 = vanilla_curve(PIVOT);
return x <= PIVOT ? vanilla_curve(x) : y0 + exp(-PIVOT) * (x - PIVOT);
}
vec3 extended_curve3(vec3 x) {
return vec3(extended_curve(x.r), extended_curve(x.g), extended_curve(x.b));
}
// RenoDX's generic TotK extended-vanilla path uses BT.601 luma for the SDR donor and HDR extension.
float bt601_luma(vec3 c) { return dot(c, vec3(0.2989030703, 0.5866198547, 0.1144770751)); }
vec3 vanilla_tonemap(vec3 x) {
float lum_in = bt601_luma(x);
float lum_out = vanilla_curve(lum_in);
vec3 by_lum = x * div_safe(lum_out, lum_in, 0.0);
vec3 by_channel = vec3(vanilla_curve(x.r), vanilla_curve(x.g), vanilla_curve(x.b));
float blend = clamp(lum_out, 0.0, 1.0);
return mix(by_lum, by_channel, blend * blend);
}
vec3 extended_vanilla_tonemap(vec3 x) {
float lum_in = bt601_luma(x);
float lum_out = extended_curve(lum_in);
vec3 by_lum = x * div_safe(lum_out, lum_in, 0.0);
vec3 by_channel = extended_curve3(x);
float blend = clamp(vanilla_curve(lum_in), 0.0, 1.0);
return mix(by_lum, by_channel, blend * blend);
}
vec2 mb_from_lms(vec3 lms) {
float t = lms.x + lms.y;
return t > 0.0 ? vec2(lms.x / t, lms.z / t) : vec2(0.0);
}
vec3 lms_from_mb_t(vec2 mb, float t) {
return vec3(mb.x * t, (1.0 - mb.x) * t, mb.y * t);
}
void interval_lower_zero(float a, float b, out float lo, out float hi) {
if (abs(a) < MB_EPSILON) {
if (b >= 0.0) {
lo = -MB_INTERVAL_MAX;
hi = MB_INTERVAL_MAX;
} else {
lo = 1.0;
hi = 0.0;
}
return;
}
float t0 = -b / a;
if (a > 0.0) {
lo = t0;
hi = MB_INTERVAL_MAX;
} else {
lo = -MB_INTERVAL_MAX;
hi = t0;
}
}
struct MBResult {
vec3 rgb;
float purity;
};
// Normalized MacLeod-Boynton purity solve in linear BT.2020. Purity 0 is white on the hue ray and purity 1 is the
// first RGB gamut boundary; T = L + M is held constant so the operation changes chromaticity rather than intensity.
MBResult mb_apply_bt2020(vec3 rgb, float purity_value) {
MBResult outv;
outv.rgb = rgb;
outv.purity = 0.0;
vec3 lms = BT2020_TO_LMS * rgb;
float t = lms.x + lms.y;
if (t <= MB_T_MIN) return outv;
vec2 white = MB_WHITE;
vec2 direction = mb_from_lms(lms) - white;
if (dot(direction, direction) < MB_NEAR_WHITE_EPSILON) return outv;
vec3 rgb_white = LMS_TO_BT2020 * lms_from_mb_t(white, t);
vec3 a = rgb - rgb_white;
float t_lo = 0.0, t_hi = MB_INTERVAL_MAX, lo, hi;
interval_lower_zero(a.r, rgb_white.r, lo, hi); t_lo = max(t_lo, lo); t_hi = min(t_hi, hi);
interval_lower_zero(a.g, rgb_white.g, lo, hi); t_lo = max(t_lo, lo); t_hi = min(t_hi, hi);
interval_lower_zero(a.b, rgb_white.b, lo, hi); t_lo = max(t_lo, lo); t_hi = min(t_hi, hi);
if (t_hi < t_lo) {
outv.rgb = max(rgb, vec3(0.0));
return outv;
}
float t_max = max(0.0, t_hi);
outv.purity = t_max > MB_EPSILON ? clamp(1.0 / t_max, 0.0, 1.0) : 0.0;
float t_final = clamp(purity_value, 0.0, 1.0) * t_max;
vec3 lms_final = lms_from_mb_t(white + t_final * direction, t);
outv.rgb = max(LMS_TO_BT2020 * lms_final, vec3(0.0));
return outv;
}
vec3 correct_purity(vec3 target709, vec3 reference709, float strength) {
vec3 target2020 = to_bt2020(target709);
vec3 reference2020 = to_bt2020(reference709);
float target_purity = mb_apply_bt2020(target2020, 1.0).purity;
float reference_purity = mb_apply_bt2020(reference2020, 1.0).purity;
float applied = mix(target_purity, reference_purity, clamp(strength, 0.0, 1.0));
return to_bt709(mb_apply_bt2020(target2020, applied).rgb);
}
// Transfer SDR donor hue and purity to the extended HDR result using the same MB construction as RenoDX TotK.
vec3 correct_hue_and_purity(vec3 target709, vec3 reference709, float hue_strength, float purity_strength) {
if (hue_strength <= 0.0 && purity_strength <= 0.0) return target709;
if (hue_strength <= 0.0) return correct_purity(target709, reference709, purity_strength);
vec3 target2020 = to_bt2020(target709);
vec3 reference2020 = to_bt2020(reference709);
vec3 target_lms = BT2020_TO_LMS * target2020;
float target_t = target_lms.x + target_lms.y;
if (target_t <= MB_T_MIN) return target709;
float target_purity = mb_apply_bt2020(target2020, 1.0).purity;
float reference_purity = mb_apply_bt2020(reference2020, 1.0).purity;
float applied_purity = mix(target_purity, reference_purity, clamp(purity_strength, 0.0, 1.0));
vec3 reference_lms = BT2020_TO_LMS * reference2020;
vec2 white = MB_WHITE;
vec2 target_direction = mb_from_lms(target_lms) - white;
vec2 reference_direction = mb_from_lms(reference_lms) - white;
float target_len_sq = dot(target_direction, target_direction);
float reference_len_sq = dot(reference_direction, reference_direction);
if (target_len_sq < MB_NEAR_WHITE_EPSILON && reference_len_sq < MB_NEAR_WHITE_EPSILON)
return correct_purity(target709, reference709, purity_strength);
vec2 target_unit = target_len_sq > MB_NEAR_WHITE_EPSILON
? target_direction * inversesqrt(target_len_sq) : vec2(0.0);
vec2 reference_unit = reference_len_sq > MB_NEAR_WHITE_EPSILON
? reference_direction * inversesqrt(reference_len_sq) : target_unit;
if (target_len_sq <= MB_NEAR_WHITE_EPSILON) target_unit = reference_unit;
float hue_blend = clamp(hue_strength, 0.0, 1.0);
vec2 blended_unit = mix(target_unit, reference_unit, hue_blend);
float blended_len_sq = dot(blended_unit, blended_unit);
if (blended_len_sq <= MB_NEAR_WHITE_EPSILON) {
blended_unit = hue_blend >= 0.5 ? reference_unit : target_unit;
blended_len_sq = dot(blended_unit, blended_unit);
}
blended_unit *= inversesqrt(max(blended_len_sq, MB_EPSILON));
float seed_len = sqrt(max(target_len_sq, 0.0));
if (seed_len <= 1e-6) seed_len = sqrt(max(reference_len_sq, 0.0));
seed_len = max(seed_len, 1e-6);
vec3 seed_lms = lms_from_mb_t(white + blended_unit * seed_len, target_t);
vec3 seed2020 = LMS_TO_BT2020 * seed_lms;
return to_bt709(mb_apply_bt2020(seed2020, applied_purity).rgb);
}
float hue_transfer_gate(vec3 donor) {
float hi = maxc(donor), lo = minc(donor);
float chroma = div_safe(hi - lo, hi, 0.0);
return smoothstep(0.02, 0.12, chroma);
}
float neutwo(float x) { return x * inversesqrt(x * x + 1.0); }
float neutwo(float x, float peak) { return peak * x * inversesqrt(x * x + peak * peak); }
float max_channel_neutwo_scale(vec3 c) {
float top = maxc(abs(c));
return top > 0.0 ? neutwo(top) / top : 1.0;
}
vec3 saturation_grade(vec3 c, vec4 w, vec4 g) {
float d = c.r * 0.6666667 + (c.g + c.b) * w.z - 1.0;
float grade = g.y * (1.0 - d * d) + g.x;
float m = maxc(c);
return vec3(m) + (c - vec3(m)) * grade;
}
vec3 per_channel_neutwo_bt2020(vec3 c709, float peak) {
vec3 c = max(to_bt2020(c709), vec3(0.0));
c = vec3(neutwo(c.r, peak), neutwo(c.g, peak), neutwo(c.b, peak));
return to_bt709(c);
}
void main() {
vec3 x = min(texture(fp_t_tcb_8, uv.xy).rgb, vec3(10000.0)) + texture(fp_t_tcb_A, uv.xy).rgb;
@@ -42,33 +301,30 @@ void main() {
float game = support_buffer.hdr.x > 0.0 ? support_buffer.hdr.x : 1.0;
float peak = support_buffer.hdr.y > 1.0 ? support_buffer.hdr.y : 1.0;
float lum = max(x.r * 0.2989 + x.g * w.x + x.b * w.y, 0.0);
float sdr = 1.0 - exp(-lum);
vec3 by_lum = lum > 0.0 ? x * (curve(lum) / lum) : x;
vec3 c = max(mix(by_lum, curve3(x), sdr * sdr), vec3(0.0));
// RenoDX's default Gamma Correction = 2.2 adjusts the peak in the opposite direction of its post-tonemap
// appearance correction. At 1000/203 this raises the Neutwo peak from about 4.926 to about 5.33.
peak = gamma22_to_srgb_linear(peak);
// the game's saturation grade, on the colour scaled into 0..1 by its largest channel
float s = max(maxc(c), 1.0);
vec3 n = c / s;
float m = maxc(n);
float d = n.r * 0.6666667 + (n.g + n.b) * w.z - 1.0;
float grade = g.y * (1.0 - d * d) + g.x;
c = s * ((n - m) * grade + m);
// the game's own SDR result: the same blend clamped to 0..1, graded
vec3 sdr_c = clamp(mix(lum > 0.0 ? x * (sdr / lum) : x, vec3(1.0) - exp(-x), sdr * sdr), 0.0, 1.0);
float sm = maxc(sdr_c), sd = sdr_c.r * 0.6666667 + (sdr_c.g + sdr_c.b) * w.z - 1.0;
sdr_c = (sdr_c - sm) * (g.y * (1.0 - sd * sd) + g.x) + sm;
// Extended HDR carrier plus the original bounded SDR rendering used as RenoDX's color donor.
vec3 c = extended_vanilla_tonemap(x);
vec3 donor = clamp(vanilla_tonemap(x), vec3(0.0), vec3(1.0));
float hue = clamp(support_buffer.hdr.z, 0.0, 1.0);
const vec3 Y = vec3(0.2126, 0.7152, 0.0722); // Rec. 709 luminance
float yc = dot(c, Y), ys = dot(sdr_c, Y);
if (hue > 0.0 && ys > 1e-5) c = mix(c, max(sdr_c, vec3(0.0)) * (yc / ys), hue * smoothstep(0.5, 1.5, maxc(c)));
c = correct_hue_and_purity(c, donor, hue * hue_transfer_gate(donor), hue * PURITY_PER_HUE);
// RenoDX temporarily compresses the largest channel with neutral Neutwo while the original TotK saturation grade
// runs, then divides the compression back out. This avoids feeding the SDR-authored grade arbitrarily large HDR RGB.
float grade_scale = max_channel_neutwo_scale(c);
c = saturation_grade(c * grade_scale, w, g) / grade_scale;
// RenoDX's default BT.709 clamp is a non-negative clamp. Final display mapping is per-channel Neutwo in BT.2020,
// which allows bright colors to converge toward white instead of preserving max-channel RGB ratios.
c = max(c, vec3(0.0));
c = per_channel_neutwo_bt2020(c, peak);
// Fold RenoDX's default 2.2 intermediate gamma correction into this native linear path. RenoDX first maps the
// linear result from an sRGB display response to a pure 2.2 response, then encodes/decodes the intermediate as 2.2;
// those latter two operations cancel, leaving this corrected linear value for HDR output.
c = srgb_linear_to_gamma22_linear(c);
// roll-off of the largest channel from half the peak to the peak
float top = maxc(c), knee = 0.5 * peak;
if (top > knee) {
float r = peak - knee;
c *= (knee + r * (1.0 - exp(-(top - knee) / r))) / top;
}
color = vec4(max(c, vec3(0.0)) * game, 0.0);
}
+78 -5
View File
@@ -515,7 +515,35 @@ static void row_output_res(void) {
snprintf(shown[i], sizeof shown[i], "%d × %d", w, h); // U+00D7, the multiplication sign
names[i] = shown[i];
}
opt_choice_list("TOTK_OUTPUT_RES", UI_MENU_OUTPUT_RES, vals, names, N, UI_MENU_OUTPUT_RES_DESC);
// A size of another shape needs that shape's folders (romfs.c overlay_init): the layout, and with Xbox or PC
// prompts the prompts' one too. The setup writes them for the displays it saw (installer/steps.py Shapes); at a
// shape without them the game draws 16:9 with bars or keeps the Switch prompts, so the row says so and offers to
// start the generator for the next start (romfs_shape_prepare; a child process, the menu does not wait). The file
// checks run again only when a setting or the started generation changes.
static unsigned seen = ~0u;
static int missing, started; // started: 0 not asked, 1 running, -1 failed to start
static char asked[16];
const char *now = cfg_value("TOTK_OUTPUT_RES");
if (seen != cfg_version()) {
seen = cfg_version();
unsigned w = 0, h = 0;
const char *layout = cfg_value("TOTK_PAD_LAYOUT");
const char *want = input_prompts_folder(input_prompts_pick(cfg_get("TOTK_PROMPTS"), layout), layout);
missing = sscanf(now, "%ux%u", &w, &h) == 2 && romfs_shape_missing(w, h, want);
}
int here = started && !strcmp(asked, now); // the generation started for the value shown
const char *note = !missing ? nullptr
: here ? menu_text(started > 0 ? UI_MENU_OUTPUT_RES_PREPARING : UI_MENU_SHAPE_PREPARE_FAILED)
: menu_text(UI_MENU_OUTPUT_RES_NO_LAYOUT);
opt_choice_list("TOTK_OUTPUT_RES", UI_MENU_OUTPUT_RES, vals, names, N, UI_MENU_OUTPUT_RES_DESC, -1, note);
if (!missing || here || !romfs_shape_can_prepare()) return;
if (!opt_button("##shape_prepare", UI_MENU_SHAPE_PREPARE, UI_MENU_SHAPE_PREPARE_DESC)) return;
unsigned w = 0, h = 0;
const char *layout = cfg_value("TOTK_PAD_LAYOUT");
sscanf(now, "%ux%u", &w, &h);
snprintf(asked, sizeof asked, "%s", now);
started = romfs_shape_prepare(w, h, input_prompts_folder(input_prompts_pick(cfg_get("TOTK_PROMPTS"), layout), layout))
? 1 : -1;
}
static void row_render_scale(void) {
@@ -552,6 +580,13 @@ static void row_shadow_range(void) {
opt_choice_list("TOTK_SHADOW_RANGE", UI_MENU_SHADOW_RANGE, vals, names, 4, UI_MENU_SHADOW_RANGE_DESC);
}
static void row_grass_range(void) {
static const char *const vals[] = {"50", "100", "150", "200", "300", "400"};
static const char *const names[] = {"31 m (0.5x)", "62 m (1x)", "94 m (1.5x)",
"125 m (2x)", "188 m (3x)", "250 m (4x)"};
opt_choice_list("TOTK_GRASS_RANGE", UI_MENU_GRASS_RANGE, vals, names, 6, UI_MENU_GRASS_RANGE_DESC);
}
static void row_gpu(void) {
const char *vals[MAX_GPUS + 1], *names[MAX_GPUS + 1];
char idx[MAX_GPUS][4];
@@ -683,6 +718,7 @@ static void tab_screen(float scale) {
opt_choice_list("TOTK_ANISO", UI_MENU_ANISO, aniso, aniso_names, 5, UI_MENU_ANISO_DESC);
row_shadow_scale();
row_shadow_range();
row_grass_range();
opt_slider("TOTK_PCSS", UI_MENU_PCSS, 0, 200, UI_MENU_PCSS_DESC, 10, "%.0f %%");
opt_slider("TOTK_CONTACT_SHADOWS", UI_MENU_CONTACT_SHADOWS, 0, 100, UI_MENU_CONTACT_SHADOWS_DESC, 10, "%.0f %%");
opt_toggle("TOTK_DLAA", UI_MENU_DLAA, UI_MENU_DLAA_DESC);
@@ -694,6 +730,8 @@ static void tab_screen(float scale) {
static const UiTextId chars[] = {UI_MENU_DLSS_CHARS_OFF, UI_MENU_DLSS_CHARS_LIGHT, UI_MENU_DLSS_CHARS_MEDIUM,
UI_MENU_DLSS_CHARS_FULL};
opt_choice("TOTK_DLSS_CHAR_MASK", UI_MENU_DLSS_CHARS, chars, 4, UI_MENU_DLSS_CHARS_DESC);
static const UiTextId reflex[] = {UI_MENU_REFLEX_OFF, UI_MENU_REFLEX_ON, UI_MENU_REFLEX_BOOST};
opt_choice("TOTK_REFLEX", UI_MENU_REFLEX, reflex, 3, UI_MENU_REFLEX_DESC);
opt_toggle("TOTK_FXAA", UI_MENU_FXAA, UI_MENU_FXAA_DESC);
rows_color();
opt_group(UI_MENU_HDR_GROUP);
@@ -733,6 +771,9 @@ static void tab_game(float scale) {
static void tab_sound(float scale) {
opt_begin("##sound", scale);
opt_slider("TOTK_VOLUME", UI_MENU_VOLUME, 0, 100, UI_MENU_VOLUME_DESC, 5, "%.0f %%");
opt_slider("TOTK_VOLUME_MUSIC", UI_MENU_VOLUME_MUSIC, 0, 100, UI_MENU_VOLUME_MUSIC_DESC, 5, "%.0f %%");
opt_slider("TOTK_VOLUME_SFX", UI_MENU_VOLUME_SFX, 0, 100, UI_MENU_VOLUME_SFX_DESC, 5, "%.0f %%");
opt_slider("TOTK_VOLUME_VOICE", UI_MENU_VOLUME_VOICE, 0, 100, UI_MENU_VOLUME_VOICE_DESC, 5, "%.0f %%");
static const UiTextId channels[] = {UI_MENU_CHANNELS_AUTO, UI_MENU_CHANNELS_STEREO, UI_MENU_CHANNELS_51};
opt_choice("TOTK_AUDIO_CHANNELS", UI_MENU_AUDIO_CHANNELS, channels, 3, UI_MENU_AUDIO_CHANNELS_DESC);
opt_end();
@@ -797,8 +838,9 @@ static const char *prompts_note(bool *restart) {
const char *layout = cfg_value("TOTK_PAD_LAYOUT"), *used = romfs_prompts();
const char *want = input_prompts_folder(input_prompts_pick(cfg_get("TOTK_PROMPTS"), layout), layout);
if (want == used || (want && used && !strcmp(want, used))) return nullptr;
// A game resolution of another shape needs a folder of its own for the prompts (<folder>-<w>x<h>). The setup writes
// one for each size the Screen tab offers; at any other size the shape is the reason, not the setup.
// A game resolution of another shape needs a folder of its own for the prompts (<folder>-<w>x<h>, one per shape).
// The setup writes it for the shapes of the displays it saw and the prompts totk.ini had then; at another shape
// the shape is the reason (row_output_res offers to make it), not a damaged install.
int off = romfs_prompts_off(want);
if (want && !romfs_prompts_ready(want) && off != ROMFS_PROMPTS_SHAPE) return menu_text(UI_MENU_PROMPTS_MISSING);
switch (off) {
@@ -850,6 +892,32 @@ static void restart_confirm(void) {
ImGui::EndPopup();
}
static void rows_gameplay_tweaks(void) {
opt_group(UI_MENU_GROUP_GAMEPLAY_TWEAKS);
opt_toggle("TOTK_GAMEPLAY_TWEAKS_ENABLED", UI_MENU_GAMEPLAY_TWEAKS_ENABLED, UI_MENU_GAMEPLAY_TWEAKS_ENABLED_DESC);
if (!cfg_bool("TOTK_GAMEPLAY_TWEAKS_ENABLED")) return;
opt_toggle("TOTK_GAMEPLAY_ULTRAHAND_ROTATE", UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE, UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE_DESC);
opt_toggle("TOTK_GAMEPLAY_ULTRAHAND_C_AXIS", UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS, UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS_DESC);
opt_slider("TOTK_GAMEPLAY_ROTATION_SENSITIVITY", UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY, 0.25f, 4.0f,
UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY_DESC, 0.05f, "%.2fx");
opt_toggle("TOTK_GAMEPLAY_ULTRAHAND_DISTANCE", UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE, UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE_DESC);
opt_slider("TOTK_GAMEPLAY_DISTANCE_SENSITIVITY", UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY, 0.25f, 4.0f,
UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY_DESC, 0.05f, "%.2fx");
opt_toggle("TOTK_GAMEPLAY_WEAPON_WHEEL", UI_MENU_GAMEPLAY_WEAPON_WHEEL, UI_MENU_GAMEPLAY_WEAPON_WHEEL_DESC);
opt_slider("TOTK_GAMEPLAY_WEAPON_SENSITIVITY", UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY, 0.25f, 4.0f,
UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY_DESC, 0.05f, "%.2fx");
opt_toggle("TOTK_GAMEPLAY_ITEM_WHEEL", UI_MENU_GAMEPLAY_ITEM_WHEEL, UI_MENU_GAMEPLAY_ITEM_WHEEL_DESC);
opt_slider("TOTK_GAMEPLAY_ITEM_SENSITIVITY", UI_MENU_GAMEPLAY_ITEM_SENSITIVITY, 0.25f, 4.0f,
UI_MENU_GAMEPLAY_ITEM_SENSITIVITY_DESC, 0.05f, "%.2fx");
opt_toggle("TOTK_GAMEPLAY_ITEM_AD", UI_MENU_GAMEPLAY_ITEM_AD, UI_MENU_GAMEPLAY_ITEM_AD_DESC);
opt_toggle("TOTK_GAMEPLAY_MAP_ZOOM", UI_MENU_GAMEPLAY_MAP_ZOOM, UI_MENU_GAMEPLAY_MAP_ZOOM_DESC);
opt_slider("TOTK_GAMEPLAY_MAP_ZOOM_SENSITIVITY", UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY, 0.25f, 4.0f,
UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY_DESC, 0.05f, "%.2fx");
}
static void tab_controls(float scale) {
opt_begin("##controls", scale);
static const UiTextId layout[] = {UI_MENU_PAD_LAYOUT_AUTO, UI_MENU_PAD_LAYOUT_NINTENDO, UI_MENU_PAD_LAYOUT_XBOX};
@@ -867,8 +935,12 @@ static void tab_controls(float scale) {
opt_choice("TOTK_MOUSE_MODE", UI_MENU_MOUSE_MODE, mouse_modes, 2, UI_MENU_MOUSE_MODE_DESC);
opt_slider("TOTK_MOUSE_SENS", UI_MENU_MOUSE_SENS, 0, 10, UI_MENU_MOUSE_SENS_DESC, 0.1f, "%.1f");
opt_toggle("TOTK_MENU_CURSOR", UI_MENU_MENU_CURSOR, UI_MENU_MENU_CURSOR_DESC);
opt_toggle("TOTK_MAP_CLICK", UI_MENU_MAP_CLICK, UI_MENU_MAP_CLICK_DESC);
opt_toggle("TOTK_DIALOGUE_CLICK", UI_MENU_DIALOGUE_CLICK, UI_MENU_DIALOGUE_CLICK_DESC);
opt_toggle("TOTK_POINTER_IMAGE", UI_MENU_POINTER_IMAGE, UI_MENU_POINTER_IMAGE_DESC);
row_walk_key();
opt_slider("TOTK_WALK_SCALE", UI_MENU_WALK_SCALE, 0.2f, 0.9f, UI_MENU_WALK_SCALE_DESC, 0.01f, "%.2f");
rows_gameplay_tweaks();
// Analog sticks: one dead zone row per stick, falling back to TOTK_STICK_DEADZONE (both sticks) while unset. With
// a gamepad connected each row shows its stick's deflection now, before the dead zone: a drifting stick's resting
// value, to set it above.
@@ -950,9 +1022,10 @@ static bool validation_layer_present(void) {
// Every setting the menu shows back to its default (the environment's keys stay), written to totk.ini.
static void reset_all(void) {
const char *keys[128];
const char *keys[256]; // above the number of rows in cfg.c metas (128 on 2026-11-11)
int n = 0;
for (const CfgMeta *m; n < 128 && (m = cfg_meta_at(n)); n++) keys[n] = m->key;
for (const CfgMeta *m; n < 256 && (m = cfg_meta_at(n)); n++) keys[n] = m->key;
if (cfg_meta_at(n)) rt_log("menu: reset covers the first %d settings only; raise keys[] in reset_all", n);
int done = cfg_reset(keys, n);
opt_save_soon();
rt_log("menu: reset %d settings to their defaults", done);
+216 -11
View File
@@ -86,7 +86,7 @@ static const char *const text_en[UI_TEXT_COUNT] = {
"bars, or stretch them over the whole picture. Applies from the next movie.",
[UI_MENU_MOVIE_ASPECT_KEEP] = "Black bars", [UI_MENU_MOVIE_ASPECT_STRETCH] = "Stretch",
[UI_MENU_FOV] = "Field of view",
[UI_MENU_FOV_DESC] = "How much of the world the camera shows, in percent of the game's own. Game version 1.4.3 only.",
[UI_MENU_FOV_DESC] = "How much of the world the camera shows, in percent of the game's own. Game versions 1.1.0 and 1.4.3.",
[UI_MENU_SHADOW_RES] = "Shadow map size",
[UI_MENU_SHADOW_RES_DESC] = "Size of the sun's shadow map. The game's own size changes with the view, down to about 400 "
"near the ground, so leaf shadows look blocky and jump; a fixed size keeps them still and "
@@ -141,6 +141,10 @@ static const char *const text_en[UI_TEXT_COUNT] = {
[UI_MENU_SHADOW_RANGE_DESC] = "Moves the steps where shadows turn softer (the game's 20, 40, 80 and 160 m) further "
"away. Spreads the shadow map over more ground: raise Shadow resolution with it. "
"Takes effect at the next start.",
[UI_MENU_GRASS_RANGE] = "Grass range",
[UI_MENU_GRASS_RANGE_DESC] = "How far around the camera grass grows (the game's: 62.5 m). Higher keeps the "
"grass in meadows further out instead of growing it in just in front of you; lower "
"draws less of it. Takes effect at the next start.",
[UI_MENU_DLAA] = "NVIDIA DLSS / DLAA",
[UI_MENU_DLAA_DESC] = "NVIDIA DLSS for the 3D scene (NVIDIA RTX GPUs; " DLSS_FILE " next to " EXE_FILE "): smoother "
"edges and less shimmer. The HUD is not touched. The mode below sets the resolution it works "
@@ -166,6 +170,11 @@ static const char *const text_en[UI_TEXT_COUNT] = {
[UI_MENU_DLSS_PERFORMANCE] = "Performance", [UI_MENU_DLSS_ULTRA] = "Ultra Performance",
[UI_MENU_FXAA] = "Game anti-aliasing (FXAA)",
[UI_MENU_FXAA_DESC] = "The game's own FXAA edge smoothing. It blurs fine detail a little; with DLAA on it is not needed.",
[UI_MENU_REFLEX] = "NVIDIA Reflex Low Latency",
[UI_MENU_REFLEX_DESC] = "Reduces system latency on NVIDIA GPUs using VK_NV_low_latency2. On + Boost keeps GPU clocks high in CPU-bound scenes.",
[UI_MENU_REFLEX_OFF] = "Off",
[UI_MENU_REFLEX_ON] = "On",
[UI_MENU_REFLEX_BOOST] = "On + Boost",
[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 "
@@ -218,8 +227,9 @@ static const char *const text_en[UI_TEXT_COUNT] = {
[UI_MENU_MODS_CHEATS] = "Cheats: %d. Switch them on the Cheats tab.",
[UI_MENU_MODS_CHEATS_FILE] = "Cheats for this game version are read at start from cheats\\%s in this mod.",
[UI_MENU_MODS_BAD_NAME] = "The folder name contains |, which the mod list uses between names. Rename the folder.",
[UI_MENU_MODS_OTHER_VERSION] = "%u of its files are made for another game version and are left out. Look for a "
"version of this mod made for your game version.",
[UI_MENU_MODS_OTHER_VERSION] = "%u of its files carry another game version in their names. The game reads them only "
"where something asks for those names. If the mod does nothing, look for a version "
"of it made for your game version.",
[UI_MENU_MODS_UNUSED] = "not used",
[UI_MENU_MODS_FPS60] = "60 FPS patch",
[UI_MENU_MODS_FPS60_DESC] = "The port's own patch for 60 frames per second. Set it with Frame rate limit on the "
@@ -232,6 +242,9 @@ static const char *const text_en[UI_TEXT_COUNT] = {
"at 60 FPS.",
[UI_MENU_VOLUME] = "Volume", [UI_MENU_VOLUME_DESC] = "Master volume of the game.",
[UI_MENU_VOLUME_MUSIC] = "Music volume", [UI_MENU_VOLUME_MUSIC_DESC] = "Volume of background music.",
[UI_MENU_VOLUME_SFX] = "SFX volume", [UI_MENU_VOLUME_SFX_DESC] = "Volume of sound effects.",
[UI_MENU_VOLUME_VOICE] = "Voice volume", [UI_MENU_VOLUME_VOICE_DESC] = "Volume of character voices.",
[UI_MENU_AUDIO_CHANNELS] = "Speakers",
[UI_MENU_AUDIO_CHANNELS_DESC] = "Stereo or 5.1 surround output. Automatic picks 5.1 when the Windows speaker setup "
"has six or more channels. Applies after a restart.",
@@ -265,6 +278,11 @@ static const char *const text_en[UI_TEXT_COUNT] = {
[UI_MENU_PROMPTS_FAILED] = "prompt files damaged: run the setup again",
[UI_MENU_PROMPTS_RESTART] = "prompts change after restart",
[UI_MENU_PROMPTS_OFF_SHAPE] = "off at this game resolution (no layout made for it)",
[UI_MENU_OUTPUT_RES_NO_LAYOUT] = "no layout made for this shape: run the setup again",
[UI_MENU_OUTPUT_RES_PREPARING] = "layout being made in the background; used at the next start",
[UI_MENU_SHAPE_PREPARE] = "Prepare the layout for this screen",
[UI_MENU_SHAPE_PREPARE_DESC] = "Makes the interface layout and the chosen button prompts for this game resolution's shape in the background, with the setup's tools, as the setup does for the displays it saw. The game keeps running; it uses them from its next start.",
[UI_MENU_SHAPE_PREPARE_FAILED] = "the setup's tools did not start: run the setup again",
[UI_MENU_PROMPTS_OFF_MODS] = "off: a RomFS mod replaces their files",
[UI_MENU_PROMPTS_OFF_PATCHES] = "off while TOTK_ROMFS_PATCHES is set",
[UI_MENU_RESTART] = "Restart now",
@@ -283,6 +301,12 @@ static const char *const text_en[UI_TEXT_COUNT] = {
[UI_MENU_MOUSE_DIRECT] = "Direct",
[UI_MENU_MENU_CURSOR] = "Mouse in the game's menus",
[UI_MENU_MENU_CURSOR_DESC] = "In the game's own menus (title, inventory, shops, dialogue choices) the pointer shows: the item under it is selected, left click confirms, right click goes back. Only after the mouse or a key was used last, so a gamepad sees the menus unchanged (game 1.4.3).",
[UI_MENU_MAP_CLICK] = "Left click on the map",
[UI_MENU_MAP_CLICK_DESC] = "On the Purah Pad's map, the left mouse button presses A at the map's cursor instead of the button it is bound to (Y by default). Needs Mouse in the game's menus (game 1.4.3).",
[UI_MENU_DIALOGUE_CLICK] = "Clicks in dialogue",
[UI_MENU_DIALOGUE_CLICK_DESC] = "While a dialogue box is open, left click presses B (it continues the text and skips its scroll) and right click presses A, instead of the buttons they are bound to (Y by default, which opens the dialogue log, and ZL). Dialogue choices keep the pointer: left click picks (game 1.4.3).",
[UI_MENU_POINTER_IMAGE] = "Game pointer",
[UI_MENU_POINTER_IMAGE_DESC] = "While the cursor is not captured (the game's menus, this menu, after Esc), the window shows a gold arrowhead of its own instead of the system arrow, sized for the screen's scale.",
[UI_MENU_MOUSE_SENS] = "Mouse camera sensitivity",
[UI_MENU_MOUSE_SENS_DESC] = "How fast the mouse turns the camera.",
[UI_MENU_WALK_KEY] = "Walk key",
@@ -292,6 +316,33 @@ static const char *const text_en[UI_TEXT_COUNT] = {
[UI_MENU_WALK_SCALE] = "Walk scale",
[UI_MENU_WALK_SCALE_DESC] = "The tilt the keyboard's sticks get while the walk key is held. Half is a walk, the "
"full tilt a run.",
[UI_MENU_GROUP_GAMEPLAY_TWEAKS] = "Gameplay tweaks",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED] = "Gameplay tweaks",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED_DESC] = "Mouse wheel controls for Ultrahand rotation and distance, item and weapon switching, and smooth map zoom.",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE] = "Ultrahand wheel rotation",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE_DESC] = "Turn objects held by Ultrahand directly with the mouse wheel.",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS] = "Ultrahand C rotation axis",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS_DESC] = "Hold C while scrolling to turn held objects around the alternate axis.",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY] = "Ultrahand rotation sensitivity",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY_DESC] = "How fast the mouse wheel turns held objects.",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE] = "Ultrahand wheel distance",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE_DESC] = "Right-click + mouse wheel pushes or pulls held objects.",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY] = "Ultrahand distance sensitivity",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY_DESC] = "How fast the mouse wheel changes object distance.",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL] = "Weapon wheel selection",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL_DESC] = "Scroll mouse wheel in free roam to switch weapons. Confirm with E.",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY] = "Weapon wheel sensitivity",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY_DESC] = "Scroll steps needed to advance to the next weapon.",
[UI_MENU_GAMEPLAY_ITEM_WHEEL] = "Quick menu wheel selection",
[UI_MENU_GAMEPLAY_ITEM_WHEEL_DESC] = "Scroll mouse wheel to browse items while a quick-selection menu is open.",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY] = "Quick menu wheel sensitivity",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY_DESC] = "Scroll steps needed to advance through items in quick-selection menus.",
[UI_MENU_GAMEPLAY_ITEM_AD] = "Quick menu A / D navigation",
[UI_MENU_GAMEPLAY_ITEM_AD_DESC] = "Press A / D to navigate left and right in quick-selection menus.",
[UI_MENU_GAMEPLAY_MAP_ZOOM] = "Smooth map zoom",
[UI_MENU_GAMEPLAY_MAP_ZOOM_DESC] = "Smooth inertial zoom on the Purah Pad map using the mouse wheel.",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY] = "Map zoom sensitivity",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY_DESC] = "How fast the mouse wheel zooms the map.",
[UI_MENU_STICK_SENS] = "Stick camera speed",
[UI_MENU_STICK_SENS_DESC] = "Multiplies the game's own right-stick camera speed, top speed included, at each of the "
"game's five camera sensitivities. The mouse keeps its own setting.",
@@ -568,7 +619,7 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
"растянуть их на всю картинку. Действует со следующего ролика.",
[UI_MENU_MOVIE_ASPECT_KEEP] = "Чёрные полосы", [UI_MENU_MOVIE_ASPECT_STRETCH] = "Растянуть",
[UI_MENU_FOV] = "Поле зрения",
[UI_MENU_FOV_DESC] = "Сколько мира показывает камера, в процентах от игрового. Только для версии игры 1.4.3.",
[UI_MENU_FOV_DESC] = "Сколько мира показывает камера, в процентах от игрового. Для версий игры 1.1.0 и 1.4.3.",
[UI_MENU_SHADOW_RES] = "Размер карты теней",
[UI_MENU_SHADOW_RES_DESC] = "Размер карты теней от солнца. Собственный размер игры меняется вместе с видом, у земли до "
"примерно 400, поэтому тени листвы выглядят квадратными и дёргаются; постоянный размер делает "
@@ -624,6 +675,10 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_SHADOW_RANGE_DESC] = "Отодвигает границы, за которыми тени становятся мягче (в игре 20, 40, 80 и 160 м). "
"Карта теней растягивается на большую площадь, поэтому вместе с этим поднимайте "
"разрешение теней. Действует после перезапуска.",
[UI_MENU_GRASS_RANGE] = "Дальность травы",
[UI_MENU_GRASS_RANGE_DESC] = "Как далеко вокруг камеры растёт трава (в игре 62,5 м). Выше: трава на лугах видна "
"дальше и не вырастает прямо перед вами; ниже: травы меньше. Действует после "
"перезапуска.",
[UI_MENU_DLAA] = "NVIDIA DLSS / DLAA",
[UI_MENU_DLAA_DESC] = "NVIDIA DLSS для 3D-сцены (видеокарты NVIDIA RTX; " DLSS_FILE " рядом с " EXE_FILE "): ровнее "
"края и меньше мерцания. Интерфейс не затрагивается. Режим ниже задаёт разрешение, с которым он "
@@ -649,6 +704,11 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_DLSS_PERFORMANCE] = "Производительность", [UI_MENU_DLSS_ULTRA] = "Макс. производительность",
[UI_MENU_FXAA] = "Сглаживание игры (FXAA)",
[UI_MENU_FXAA_DESC] = "Собственное сглаживание FXAA. Слегка размывает мелкие детали; с DLAA оно не нужно.",
[UI_MENU_REFLEX] = "NVIDIA Reflex Low Latency",
[UI_MENU_REFLEX_DESC] = "Снижает задержку системы на видеокартах NVIDIA с помощью VK_NV_low_latency2. «Вкл + Ускорение» удерживает высокие частоты GPU при упоре в процессор.",
[UI_MENU_REFLEX_OFF] = "Выкл",
[UI_MENU_REFLEX_ON] = "Вкл",
[UI_MENU_REFLEX_BOOST] = "Вкл + Ускорение",
[UI_MENU_FPS_LIMIT] = "Ограничение частоты кадров",
[UI_MENU_FPS_LIMIT_DESC] = "Наибольшее число кадров в секунду. Выше 60 — экспериментальный режим, нужна «Скорость "
@@ -699,8 +759,9 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_MODS_CHEATS] = "Читов: %d. Они включаются на вкладке «Читы».",
[UI_MENU_MODS_CHEATS_FILE] = "Читы для этой версии игры читаются при запуске из cheats\\%s в этом моде.",
[UI_MENU_MODS_BAD_NAME] = "В имени папки есть символ |, которым список модов разделяет имена. Переименуйте папку.",
[UI_MENU_MODS_OTHER_VERSION] = "Файлов для другой версии игры: %u, они пропущены. Поищите версию этого мода для "
"вашей версии игры.",
[UI_MENU_MODS_OTHER_VERSION] = "Файлов с другой версией игры в имени: %u. Игра читает их, только когда что-то "
"запрашивает эти имена. Если мод не работает, поищите его версию для вашей версии "
"игры.",
[UI_MENU_MODS_UNUSED] = "не используется",
[UI_MENU_MODS_FPS60] = "Патч 60 FPS",
[UI_MENU_MODS_FPS60_DESC] = "Собственный патч порта для 60 кадров в секунду. Настраивается «Ограничением частоты "
@@ -712,6 +773,9 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_MODS_QUICKMENU_DESC] = "Исправление порта: чёрный фон меню оружия, щитов и материалов при 60 FPS.",
[UI_MENU_VOLUME] = "Громкость", [UI_MENU_VOLUME_DESC] = "Общая громкость игры.",
[UI_MENU_VOLUME_MUSIC] = "Громкость музыки", [UI_MENU_VOLUME_MUSIC_DESC] = "Громкость фоновой музыки.",
[UI_MENU_VOLUME_SFX] = "Громкость эффектов", [UI_MENU_VOLUME_SFX_DESC] = "Громкость звуковых эффектов.",
[UI_MENU_VOLUME_VOICE] = "Громкость голосов", [UI_MENU_VOLUME_VOICE_DESC] = "Громкость голосов персонажей.",
[UI_MENU_AUDIO_CHANNELS] = "Динамики",
[UI_MENU_AUDIO_CHANNELS_DESC] = "Стерео или объёмный звук 5.1. Автоматически выбирается 5.1, если в Windows "
"настроено шесть каналов или больше. Применяется после перезапуска.",
@@ -745,6 +809,11 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_PROMPTS_FAILED] = "файлы подсказок повреждены: запустите установку снова",
[UI_MENU_PROMPTS_RESTART] = "подсказки сменятся после перезапуска",
[UI_MENU_PROMPTS_OFF_SHAPE] = "выкл. при этом разрешении игры (для него нет раскладки)",
[UI_MENU_OUTPUT_RES_NO_LAYOUT] = "для этой формы нет раскладки: запустите установщик снова",
[UI_MENU_OUTPUT_RES_PREPARING] = "раскладка создаётся в фоне; будет при следующем запуске",
[UI_MENU_SHAPE_PREPARE] = "Подготовить раскладку для этого экрана",
[UI_MENU_SHAPE_PREPARE_DESC] = "Создаёт в фоне раскладку интерфейса и выбранные подсказки кнопок для формы этого разрешения игры инструментами установщика, как установщик делает для мониторов, которые видел. Игра продолжает работать; раскладка будет со следующего запуска.",
[UI_MENU_SHAPE_PREPARE_FAILED] = "инструменты установщика не запустились: запустите установщик снова",
[UI_MENU_PROMPTS_OFF_MODS] = "выкл.: мод RomFS заменяет их файлы",
[UI_MENU_PROMPTS_OFF_PATCHES] = "выкл., пока задан TOTK_ROMFS_PATCHES",
[UI_MENU_RESTART] = "Перезапустить сейчас",
@@ -763,6 +832,12 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_MOUSE_DIRECT] = "Прямое",
[UI_MENU_MENU_CURSOR] = "Мышь в меню игры",
[UI_MENU_MENU_CURSOR_DESC] = "В меню самой игры (заставка, инвентарь, магазины, варианты ответа) появляется указатель: пункт под ним выбирается, левый щелчок подтверждает, правый возвращает назад. Только если последними использовались мышь или клавиатура, поэтому с геймпадом меню не меняются (версия игры 1.4.3).",
[UI_MENU_MAP_CLICK] = "Левый щелчок на карте",
[UI_MENU_MAP_CLICK_DESC] = "На карте игры левая кнопка мыши нажимает A у курсора карты, а не назначенную ей кнопку (по умолчанию Y). Нужна «Мышь в меню игры» (версия игры 1.4.3).",
[UI_MENU_DIALOGUE_CLICK] = "Щелчки в диалоге",
[UI_MENU_DIALOGUE_CLICK_DESC] = "Пока открыто окно диалога, левый щелчок нажимает B (продолжает текст и пропускает его прокрутку), а правый — A, вместо назначенных им кнопок (по умолчанию Y, она открывает журнал диалога, и ZL). В вариантах ответа по-прежнему работает указатель: левый щелчок выбирает (версия игры 1.4.3).",
[UI_MENU_POINTER_IMAGE] = "Игровой курсор",
[UI_MENU_POINTER_IMAGE_DESC] = "Пока курсор не захвачен (меню игры, это меню, после Esc), окно показывает собственный золотой наконечник вместо системной стрелки, по масштабу экрана.",
[UI_MENU_MOUSE_SENS] = "Чувствительность мыши",
[UI_MENU_MOUSE_SENS_DESC] = "Как быстро мышь поворачивает камеру.",
[UI_MENU_WALK_KEY] = "Клавиша шага",
@@ -772,6 +847,33 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_WALK_SCALE] = "Сила шага",
[UI_MENU_WALK_SCALE_DESC] = "Отклонение стиков клавиатуры при удержании клавиши шага. Половина — шаг, полное "
"отклонение — бег.",
[UI_MENU_GROUP_GAMEPLAY_TWEAKS] = "Геймплей",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED] = "Настройки геймплея",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED_DESC] = "Управление колесом мыши: вращение и дистанция предметов в Ультраруке, выбор оружия и предметов, плавный зум карты.",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE] = "Вращение колесом (Ультрарука)",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE_DESC] = "Вращение удерживаемых Ультрарукой предметов колесом мыши без удержания R.",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS] = "Ось C для вращения (Ультрарука)",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS_DESC] = "Удерживайте C при прокрутке колеса для вращения объекта вокруг третьей оси.",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY] = "Скорость вращения (Ультрарука)",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY_DESC] = "Как быстро колесо мыши поворачивает удерживаемый предмет.",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE] = "Дистанция колесом (Ультрарука)",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE_DESC] = "Правая кнопка мыши + колесо приближает или отдаляет предмет.",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY] = "Скорость дистанции (Ультрарука)",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY_DESC] = "Как быстро колесо мыши меняет дистанцию до предмета.",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL] = "Выбор оружия колесом",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL_DESC] = "Прокрутите колесо в свободной игре для выбора оружия. Подтверждение клавишей E.",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY] = "Чувствительность выбора оружия",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY_DESC] = "Шаги колеса для переключения на следующее оружие.",
[UI_MENU_GAMEPLAY_ITEM_WHEEL] = "Выбор в быстром меню колесом",
[UI_MENU_GAMEPLAY_ITEM_WHEEL_DESC] = "Прокрутка колеса листает предметы в открытом меню быстрого выбора.",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY] = "Чувствительность быстрого меню",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY_DESC] = "Шаги колеса для перехода к следующему предмету в быстром меню.",
[UI_MENU_GAMEPLAY_ITEM_AD] = "Навигация A / D в быстром меню",
[UI_MENU_GAMEPLAY_ITEM_AD_DESC] = "Клавиши A / D для выбора влево и вправо в меню быстрого выбора.",
[UI_MENU_GAMEPLAY_MAP_ZOOM] = "Плавный зум карты",
[UI_MENU_GAMEPLAY_MAP_ZOOM_DESC] = "Плавное инерционное приближение карты Планшета путеводителя колесом мыши.",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY] = "Скорость зума карты",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY_DESC] = "Как быстро колесо мыши масштабирует карту.",
[UI_MENU_STICK_SENS] = "Скорость камеры (стик)",
[UI_MENU_STICK_SENS_DESC] = "Умножает скорость поворота камеры правым стиком, включая наибольшую, при каждой из пяти "
"чувствительностей камеры в игре. На мышь не влияет.",
@@ -1029,8 +1131,9 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
[UI_MENU_MODS_CHEATS] = "Cheats: %d. Ligue-os na aba Cheats.",
[UI_MENU_MODS_CHEATS_FILE] = "Os cheats desta versão do jogo são lidos ao iniciar de cheats\\%s neste mod.",
[UI_MENU_MODS_BAD_NAME] = "O nome da pasta contém |, que a lista de mods usa entre os nomes. Renomeie a pasta.",
[UI_MENU_MODS_OTHER_VERSION] = "%u dos seus arquivos são de outra versão do jogo e ficam de fora. Procure uma versão "
"deste mod feita para a sua versão do jogo.",
[UI_MENU_MODS_OTHER_VERSION] = "%u dos seus arquivos trazem outra versão do jogo no nome. O jogo só os lê quando algo "
"pede esses nomes. Se o mod não fizer nada, procure uma versão dele feita para a sua "
"versão do jogo.",
[UI_MENU_MODS_UNUSED] = "não usado",
[UI_MENU_MODS_FPS60] = "Patch de 60 FPS",
[UI_MENU_MODS_FPS60_DESC] = "O patch do próprio port para 60 quadros por segundo. Ajuste em Limite de quadros na aba "
@@ -1120,6 +1223,9 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
[UI_MENU_MODE_DOCKED] = "Modo TV", [UI_MENU_MODE_HANDHELD] = "Modo portátil",
[UI_MENU_VOLUME] = "Volume", [UI_MENU_VOLUME_DESC] = "Volume geral do jogo.",
[UI_MENU_VOLUME_MUSIC] = "Volume da música", [UI_MENU_VOLUME_MUSIC_DESC] = "Volume da música de fundo.",
[UI_MENU_VOLUME_SFX] = "Volume dos efeitos", [UI_MENU_VOLUME_SFX_DESC] = "Volume dos efeitos sonoros.",
[UI_MENU_VOLUME_VOICE] = "Volume das vozes", [UI_MENU_VOLUME_VOICE_DESC] = "Volume das vozes dos personagens.",
[UI_MENU_AUDIO_CHANNELS] = "Alto-falantes",
[UI_MENU_AUDIO_CHANNELS_DESC] = "Saída estéreo ou surround 5.1. Automático escolhe 5.1 quando a configuração de "
"alto-falantes do Windows tem seis canais ou mais. Vale após reiniciar.",
@@ -1352,7 +1458,7 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
[UI_MENU_OV_FMT_FSR] = "AMD FSR 1, nitidez %d%%", [UI_MENU_OV_SCALE_NONE] = "nenhuma (1:1)",
[UI_MENU_OV_SCALE_BILINEAR] = "bilinear",
[UI_MENU_FOV] = "Campo de visão",
[UI_MENU_FOV_DESC] = "Quanto do mundo a câmera mostra, em porcentagem do original do jogo. Só na versão 1.4.3 do "
[UI_MENU_FOV_DESC] = "Quanto do mundo a câmera mostra, em porcentagem do original do jogo. Nas versões 1.1.0 e 1.4.3 do "
"jogo.",
[UI_MENU_SHADOW_RES] = "Tamanho do mapa de sombras",
[UI_MENU_SHADOW_RES_DESC] = "Tamanho do mapa de sombras do sol. O tamanho do jogo muda com a vista, até cerca de "
@@ -1416,10 +1522,21 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
[UI_MENU_MOUSE_DIRECT] = "Direta",
[UI_MENU_MENU_CURSOR] = "Mouse nos menus do jogo",
[UI_MENU_MENU_CURSOR_DESC] = "Nos menus do próprio jogo (título, inventário, lojas, escolhas de diálogo) o ponteiro aparece: o item sob ele fica selecionado, o clique esquerdo confirma e o direito volta. Só depois de usar o mouse ou uma tecla por último, então com um controle os menus ficam como antes (jogo 1.4.3).",
[UI_MENU_MAP_CLICK] = "Clique esquerdo no mapa",
[UI_MENU_MAP_CLICK_DESC] = "No mapa do jogo, o botão esquerdo do mouse aperta A no cursor do mapa, em vez do botão ao qual está atribuído (Y por padrão). Requer Mouse nos menus do jogo (jogo 1.4.3).",
[UI_MENU_DIALOGUE_CLICK] = "Cliques no diálogo",
[UI_MENU_DIALOGUE_CLICK_DESC] = "Enquanto uma caixa de diálogo está aberta, o clique esquerdo aperta B (continua o texto e pula a rolagem) e o direito aperta A, em vez dos botões aos quais estão atribuídos (Y por padrão, que abre o registro do diálogo, e ZL). As escolhas de diálogo continuam com o ponteiro: o clique esquerdo escolhe (jogo 1.4.3).",
[UI_MENU_POINTER_IMAGE] = "Ponteiro do jogo",
[UI_MENU_POINTER_IMAGE_DESC] = "Enquanto o cursor não está capturado (os menus do jogo, este menu, depois de Esc), a janela mostra uma ponta de flecha dourada própria em vez da seta do sistema, no tamanho da escala da tela.",
[UI_MENU_PROMPTS_MISSING] = "faltam os arquivos dos ícones: execute a instalação de novo",
[UI_MENU_PROMPTS_FAILED] = "arquivos dos ícones danificados: execute a instalação de novo",
[UI_MENU_PROMPTS_RESTART] = "os ícones mudam após reiniciar",
[UI_MENU_PROMPTS_OFF_SHAPE] = "desligados nesta resolução de jogo (sem layout feito para ela)",
[UI_MENU_OUTPUT_RES_NO_LAYOUT] = "sem layout feito para este formato: rode o instalador de novo",
[UI_MENU_OUTPUT_RES_PREPARING] = "layout sendo feito em segundo plano; usado na próxima vez que o jogo abrir",
[UI_MENU_SHAPE_PREPARE] = "Preparar o layout para esta tela",
[UI_MENU_SHAPE_PREPARE_DESC] = "Faz em segundo plano o layout da interface e os botões escolhidos para o formato desta resolução de jogo, com as ferramentas do instalador, como o instalador faz para os monitores que viu. O jogo continua rodando; ele os usa a partir da próxima vez que abrir.",
[UI_MENU_SHAPE_PREPARE_FAILED] = "as ferramentas do instalador não abriram: rode o instalador de novo",
[UI_MENU_PROMPTS_OFF_MODS] = "desligados: um mod de RomFS substitui os arquivos deles",
[UI_MENU_PROMPTS_OFF_PATCHES] = "desligados enquanto TOTK_ROMFS_PATCHES está definido",
[UI_MENU_RESTART] = "Reiniciar agora",
@@ -1439,6 +1556,33 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
[UI_MENU_WALK_SCALE] = "Intensidade do andar",
[UI_MENU_WALK_SCALE_DESC] = "A inclinação dos analógicos do teclado enquanto a tecla de andar está segura. Metade "
"é andar, a inclinação total é correr.",
[UI_MENU_GROUP_GAMEPLAY_TWEAKS] = "Ajustes de jogabilidade",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED] = "Ajustes de jogabilidade",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED_DESC] = "Controles com a roda do mouse para rotação e distância na Ultramão, seleção de armas e itens, e zoom suave no mapa.",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE] = "Rotação com roda (Ultramão)",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE_DESC] = "Gira objetos segurados pela Ultramão diretamente com a roda do mouse.",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS] = "Eixo de rotação C (Ultramão)",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS_DESC] = "Segure C ao rolar a roda do mouse para girar o objeto no terceiro eixo.",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY] = "Sensibilidade de rotação (Ultramão)",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY_DESC] = "Define a velocidade de rotação do objeto com a roda do mouse.",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE] = "Distância com roda (Ultramão)",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE_DESC] = "Botão direito do mouse + roda aproxima ou afasta o objeto.",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY] = "Sensibilidade de distância (Ultramão)",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY_DESC] = "Define a velocidade de ajuste de distância com a roda do mouse.",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL] = "Seleção de armas com a roda",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL_DESC] = "Role a roda do mouse no modo livre para trocar de arma. Confirme com E.",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY] = "Sensibilidade de seleção de armas",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY_DESC] = "Passos da roda necessários para avançar para a próxima arma.",
[UI_MENU_GAMEPLAY_ITEM_WHEEL] = "Seleção do menu rápido com a roda",
[UI_MENU_GAMEPLAY_ITEM_WHEEL_DESC] = "Role a roda do mouse para navegar por itens com o menu rápido aberto.",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY] = "Sensibilidade do menu rápido",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY_DESC] = "Passos da roda necessários para avançar itens nos menus rápidos.",
[UI_MENU_GAMEPLAY_ITEM_AD] = "Navegação A / D no menu rápido",
[UI_MENU_GAMEPLAY_ITEM_AD_DESC] = "Teclas A / D para navegar para esquerda e direita nos menus rápidos.",
[UI_MENU_GAMEPLAY_MAP_ZOOM] = "Zoom suave no mapa",
[UI_MENU_GAMEPLAY_MAP_ZOOM_DESC] = "Zoom inercial suave no mapa do Purah Pad usando a roda do mouse.",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY] = "Sensibilidade do zoom no mapa",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY_DESC] = "Define a velocidade de zoom no mapa com a roda do mouse.",
[UI_MENU_OV_SCALE_DOWN] = "bilinear (o FSR só amplia)",
[UI_MENU_HDR_HUE] = "Correção de matiz dos realces",
[UI_MENU_HDR_HUE_DESC] = "Cores fortes como fogo e faíscas vão para o branco como na imagem SDR do próprio jogo e "
@@ -1451,6 +1595,10 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
[UI_MENU_SHADOW_RANGE_DESC] = "Afasta os degraus em que as sombras ficam mais suaves (20, 40, 80 e 160 m no "
"jogo). Espalha o mapa de sombras por mais terreno: aumente a Resolução das sombras "
"junto. Vale no próximo início.",
[UI_MENU_GRASS_RANGE] = "Alcance da grama",
[UI_MENU_GRASS_RANGE_DESC] = "Até onde a grama cresce ao redor da câmera (62,5 m no jogo). Mais alto mantém a "
"grama dos campos mais longe em vez de ela surgir logo à sua frente; mais baixo "
"desenha menos grama. Vale no próximo início.",
[UI_MENU_CONTACT_SHADOWS] = "Sombras de contato",
[UI_MENU_CONTACT_SHADOWS_DESC] = "Pequenas sombras do sol que os mapas de sombra não pegam: nos pés, sob pedras, "
"na grama e em dobras. Traçadas na tela depois da iluminação. Vale no próximo "
@@ -1486,6 +1634,11 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
[UI_MENU_FXAA] = "Antisserrilhado do jogo (FXAA)",
[UI_MENU_FXAA_DESC] = "A suavização de bordas FXAA do próprio jogo. Borra um pouco os detalhes finos; com o DLAA "
"ligado não é necessária.",
[UI_MENU_REFLEX] = "NVIDIA Reflex Low Latency",
[UI_MENU_REFLEX_DESC] = "Reduz a latência do sistema em GPUs NVIDIA usando VK_NV_low_latency2. Ligado + Boost mantém os clocks da GPU altos quando limitado pela CPU.",
[UI_MENU_REFLEX_OFF] = "Desligado",
[UI_MENU_REFLEX_ON] = "Ligado",
[UI_MENU_REFLEX_BOOST] = "Ligado + Boost",
[UI_MENU_TAB_CHEATS] = "Cheats",
[UI_MENU_CHEATS_NONE] = "Nenhum cheat para esta versão do jogo. Os cheats de um mod são um arquivo de cheats do "
"Atmosphere na pasta cheats dele, com o nome da build do jogo: mods\\<mod>\\cheats\\%s. "
@@ -1552,7 +1705,8 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
[UI_MENU_MODS_CHEATS] = "金手指:%d 个。在“金手指”标签页中开关。",
[UI_MENU_MODS_CHEATS_FILE] = "此游戏版本的金手指在启动时从此模组的 cheats\\%s 读取。",
[UI_MENU_MODS_BAD_NAME] = "文件夹名称含有 |,模组列表用它分隔名称。请重命名该文件夹。",
[UI_MENU_MODS_OTHER_VERSION] = "它有 %u 个文件是为其他游戏版本制作的,已被跳过。请寻找适用于你的游戏版本的此模组。",
[UI_MENU_MODS_OTHER_VERSION] = "它有 %u 个文件的文件名带有其他游戏版本号。只有在有内容请求这些文件名时,游戏才会读取它们。"
"如果模组不起作用,请寻找适用于你的游戏版本的此模组。",
[UI_MENU_MODS_UNUSED] = "未使用",
[UI_MENU_MODS_FPS60] = "60 FPS 补丁",
[UI_MENU_MODS_FPS60_DESC] = "移植版自带的 60 帧补丁。在“游戏”页的帧率上限中设置。",
@@ -1624,7 +1778,7 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
[UI_MENU_MOVIE_ASPECT_STRETCH] = "拉伸",
[UI_MENU_FOV] = "视野",
[UI_MENU_FOV_DESC] = "镜头能看到多大范围,以游戏自身视野的百分比表示。"
"仅限游戏版本 1.4.3。",
"支持游戏版本 1.1.0 和 1.4.3。",
[UI_MENU_SHARPNESS] = "FSR 锐度",
[UI_MENU_SHARPNESS_DESC] = "FSR 缩放后的锐化强度;0 为关闭。",
[UI_MENU_COLOR] = "色彩",
@@ -1680,6 +1834,12 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
"这样被打断的读取可能会永久卡住。",
[UI_MENU_VOLUME] = "音量",
[UI_MENU_VOLUME_DESC] = "游戏的主音量。",
[UI_MENU_VOLUME_MUSIC] = "音乐音量",
[UI_MENU_VOLUME_MUSIC_DESC] = "背景音乐的音量。",
[UI_MENU_VOLUME_SFX] = "音效音量",
[UI_MENU_VOLUME_SFX_DESC] = "声音特效的音量。",
[UI_MENU_VOLUME_VOICE] = "语音音量",
[UI_MENU_VOLUME_VOICE_DESC] = "角色语音的音量。",
[UI_MENU_AUDIO_CHANNELS] = "扬声器",
[UI_MENU_AUDIO_CHANNELS_DESC] = "立体声或 5.1 环绕声输出。选择自动时,若 Windows 扬声器设置有六个或更多声道则使用 5.1。重启后生效。",
[UI_MENU_CHANNELS_AUTO] = "自动", [UI_MENU_CHANNELS_STEREO] = "立体声", [UI_MENU_CHANNELS_51] = "5.1 环绕声",
@@ -2045,10 +2205,21 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
[UI_MENU_MOUSE_DIRECT] = "直接",
[UI_MENU_MENU_CURSOR] = "在游戏菜单中使用鼠标",
[UI_MENU_MENU_CURSOR_DESC] = "在游戏自身的菜单中(标题、背包、商店、对话选项)显示指针:指针下的项目被选中,左键确认,右键返回。仅在最后使用的是鼠标或键盘时生效,因此使用手柄时菜单保持不变(游戏 1.4.3)。",
[UI_MENU_MAP_CLICK] = "在地图上左键单击",
[UI_MENU_MAP_CLICK_DESC] = "在游戏地图上,鼠标左键在地图光标处按下 A 键,而不是按下它所绑定的按键(默认为 Y)。需要开启“在游戏菜单中使用鼠标”(游戏 1.4.3)。",
[UI_MENU_DIALOGUE_CLICK] = "对话中的鼠标点击",
[UI_MENU_DIALOGUE_CLICK_DESC] = "对话框打开时,鼠标左键按下 B 键(继续对话并跳过文字滚动),右键按下 A 键,而不是它们所绑定的按键(默认为 Y,会打开对话记录;以及 ZL)。对话选项仍使用指针:左键选择(游戏 1.4.3)。",
[UI_MENU_POINTER_IMAGE] = "游戏指针",
[UI_MENU_POINTER_IMAGE_DESC] = "光标未被捕获时(游戏菜单、本菜单、按 Esc 之后),窗口显示自带的金色箭头,而不是系统箭头,大小随屏幕缩放。",
[UI_MENU_PROMPTS_MISSING] = "缺少按键提示文件:请重新运行安装程序",
[UI_MENU_PROMPTS_FAILED] = "按键提示文件已损坏:请重新运行安装程序",
[UI_MENU_PROMPTS_RESTART] = "按键提示重启后生效",
[UI_MENU_PROMPTS_OFF_SHAPE] = "此游戏分辨率下关闭(未为其制作布局)",
[UI_MENU_OUTPUT_RES_NO_LAYOUT] = "未为此比例制作布局:请重新运行安装程序",
[UI_MENU_OUTPUT_RES_PREPARING] = "布局正在后台制作;下次启动时使用",
[UI_MENU_SHAPE_PREPARE] = "为此屏幕准备布局",
[UI_MENU_SHAPE_PREPARE_DESC] = "使用安装程序的工具,在后台为此游戏分辨率的比例制作界面布局和所选按键提示,与安装程序为其检测到的显示器所做的相同。游戏继续运行;下次启动时生效。",
[UI_MENU_SHAPE_PREPARE_FAILED] = "安装程序的工具未能启动:请重新运行安装程序",
[UI_MENU_PROMPTS_OFF_MODS] = "已关闭:RomFS 模组替换了它们的文件",
[UI_MENU_PROMPTS_OFF_PATCHES] = "设置了 TOTK_ROMFS_PATCHES 时关闭",
[UI_MENU_RESTART] = "立即重启",
@@ -2063,6 +2234,33 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
[UI_MENU_WALK_KEY_TAKEN] = "同时为 %s",
[UI_MENU_WALK_SCALE] = "步行幅度",
[UI_MENU_WALK_SCALE_DESC] = "按住步行键时键盘摇杆的推动幅度。一半为走路,推满为奔跑。",
[UI_MENU_GROUP_GAMEPLAY_TWEAKS] = "游戏操作微调",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED] = "启用操作微调",
[UI_MENU_GAMEPLAY_TWEAKS_ENABLED_DESC] = "使用鼠标滚轮控制究极手物体旋转与距离、武器与道具切换以及地图平滑缩放。",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE] = "究极手滚轮旋转",
[UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE_DESC] = "究极手抓取物体时直接使用鼠标滚轮旋转物体,无需按住 R 键。",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS] = "究极手 C 轴旋转",
[UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS_DESC] = "滚动滚轮时按住 C 键可绕第三轴旋转物体。",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY] = "究极手旋转灵敏度",
[UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY_DESC] = "鼠标滚轮旋转物体的灵敏度倍率。",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE] = "究极手滚轮推拉距离",
[UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE_DESC] = "按住鼠标右键滚动滚轮可推远或拉近物体。",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY] = "究极手距离灵敏度",
[UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY_DESC] = "鼠标滚轮推拉物体距离的灵敏度倍率。",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL] = "自由状态滚轮切换武器",
[UI_MENU_GAMEPLAY_WEAPON_WHEEL_DESC] = "在自由行动时滚动鼠标滚轮切换武器,按 E 键确认。",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY] = "武器切换滚轮灵敏度",
[UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY_DESC] = "滚轮切换下一个武器所需的滚动步数灵敏度。",
[UI_MENU_GAMEPLAY_ITEM_WHEEL] = "快捷菜单滚轮选择",
[UI_MENU_GAMEPLAY_ITEM_WHEEL_DESC] = "快捷菜单打开时通过鼠标滚轮快速切换选择物品。",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY] = "快捷菜单滚轮灵敏度",
[UI_MENU_GAMEPLAY_ITEM_SENSITIVITY_DESC] = "在快捷菜单中切换下一个物品所需的滚轮灵敏度。",
[UI_MENU_GAMEPLAY_ITEM_AD] = "快捷菜单 A / D 键切换",
[UI_MENU_GAMEPLAY_ITEM_AD_DESC] = "快捷菜单打开时按 A / D 键向左或向右切换选择物品。",
[UI_MENU_GAMEPLAY_MAP_ZOOM] = "地图平滑缩放",
[UI_MENU_GAMEPLAY_MAP_ZOOM_DESC] = "在普尔亚平板地图上使用鼠标滚轮进行平滑惯性缩放。",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY] = "地图缩放灵敏度",
[UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY_DESC] = "鼠标滚轮缩放地图的灵敏度倍率。",
[UI_MENU_OV_SCALE_DOWN] = "双线性(FSR 只能放大)",
[UI_MENU_HDR_HUE] = "高光色调校正",
[UI_MENU_HDR_HUE_DESC] = "火焰、火花等明亮色彩像游戏自身的 SDR 画面一样趋向白色,与它们发出的光一致;0 保持完全饱和。",
@@ -2070,6 +2268,8 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
[UI_MENU_SHADOW_SCALE_DESC] = "将太阳阴影贴图的每条边绘制为游戏 960x960 的若干倍:阴影边缘和树叶阴影更清晰。下次启动时生效。",
[UI_MENU_SHADOW_RANGE] = "阴影级联范围",
[UI_MENU_SHADOW_RANGE_DESC] = "把阴影变柔和的分界(游戏中为 20、40、80 和 160 米)推得更远。阴影贴图会覆盖更大的地面,请同时提高阴影分辨率。下次启动时生效。",
[UI_MENU_GRASS_RANGE] = "草地范围",
[UI_MENU_GRASS_RANGE_DESC] = "镜头周围长草的距离(游戏中为 62.5 米)。调高后草地延伸得更远,不会在你面前才长出来;调低则少画一些草。下次启动时生效。",
[UI_MENU_CONTACT_SHADOWS] = "接触阴影",
[UI_MENU_CONTACT_SHADOWS_DESC] = "阴影贴图遗漏的细小太阳阴影:脚下、石头下、草丛和褶皱中。在光照之后于屏幕空间追踪。下次启动时生效。",
[UI_MENU_PCSS] = "柔和阴影",
@@ -2096,6 +2296,11 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
[UI_MENU_DLSS_CHARS_FULL] = "强",
[UI_MENU_FXAA] = "游戏抗锯齿(FXAA)",
[UI_MENU_FXAA_DESC] = "游戏自身的 FXAA 边缘平滑。会让细节略微模糊;开启 DLAA 时不需要。",
[UI_MENU_REFLEX] = "NVIDIA Reflex 低延迟",
[UI_MENU_REFLEX_DESC] = "在支持 VK_NV_low_latency2 的 NVIDIA 显卡上降低系统延迟。开 + 增强 (On + Boost) 会在 CPU 瓶颈时保持 GPU 高频率。",
[UI_MENU_REFLEX_OFF] = "关",
[UI_MENU_REFLEX_ON] = "开",
[UI_MENU_REFLEX_BOOST] = "开 + 增强",
[UI_MENU_TAB_CHEATS] = "金手指",
[UI_MENU_CHEATS_NONE] = "此游戏版本没有金手指。模组的金手指是它的 cheats 文件夹中以游戏构建命名的 Atmosphere "
"金手指文件:mods\\<模组>\\cheats\\%s。重启游戏后才会读取。对于修改游戏代码的金手指,"
+27 -1
View File
@@ -53,12 +53,14 @@ typedef enum {
UI_MENU_HDR_UI, UI_MENU_HDR_UI_DESC, UI_MENU_HDR_HUE, UI_MENU_HDR_HUE_DESC,
UI_MENU_SHADOW_SCALE, UI_MENU_SHADOW_SCALE_DESC,
UI_MENU_SHADOW_RANGE, UI_MENU_SHADOW_RANGE_DESC,
UI_MENU_GRASS_RANGE, UI_MENU_GRASS_RANGE_DESC,
UI_MENU_CONTACT_SHADOWS, UI_MENU_CONTACT_SHADOWS_DESC,
UI_MENU_PCSS, UI_MENU_PCSS_DESC,
UI_MENU_DLAA, UI_MENU_DLAA_DESC, UI_MENU_DLSS, UI_MENU_DLSS_DESC, UI_MENU_DLSS_DLAA, UI_MENU_DLSS_QUALITY,
UI_MENU_DLSS_BALANCED, UI_MENU_DLSS_PERFORMANCE, UI_MENU_DLSS_ULTRA, UI_MENU_DLSS_PRESET, UI_MENU_DLSS_PRESET_DESC,
UI_MENU_DLSS_PRESET_DEFAULT, UI_MENU_DLSS_PRESET_K, UI_MENU_DLSS_PRESET_J, UI_MENU_DLSS_CHARS, UI_MENU_DLSS_CHARS_DESC,
UI_MENU_DLSS_CHARS_OFF, UI_MENU_DLSS_CHARS_LIGHT, UI_MENU_DLSS_CHARS_MEDIUM, UI_MENU_DLSS_CHARS_FULL, UI_MENU_FXAA, UI_MENU_FXAA_DESC,
UI_MENU_REFLEX, UI_MENU_REFLEX_DESC, UI_MENU_REFLEX_OFF, UI_MENU_REFLEX_ON, UI_MENU_REFLEX_BOOST,
// Game
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,
@@ -88,7 +90,7 @@ typedef enum {
UI_MENU_MODS_EXEFS_OTHER,
UI_MENU_MODS_EXEFS_ON, // printf: its ExeFS patch files in use
UI_MENU_MODS_REPLACES_BUILTIN, // printf: its ExeFS patch files in use, the port's own patch sets they turn off
UI_MENU_MODS_OTHER_VERSION, // printf: files made for another game version, left out
UI_MENU_MODS_OTHER_VERSION, // printf: files named for another game version, read only when asked for by name
UI_MENU_MODS_UNUSED, // under the switch of a mod the port cannot use
UI_MENU_MODS_CHEATS, // printf: its cheats as read at start
UI_MENU_MODS_CHEATS_FILE, // printf: <build id>.txt, when none were read
@@ -97,6 +99,9 @@ typedef enum {
// Sound
UI_MENU_VOLUME, UI_MENU_VOLUME_DESC,
UI_MENU_VOLUME_MUSIC, UI_MENU_VOLUME_MUSIC_DESC,
UI_MENU_VOLUME_SFX, UI_MENU_VOLUME_SFX_DESC,
UI_MENU_VOLUME_VOICE, UI_MENU_VOLUME_VOICE_DESC,
UI_MENU_AUDIO_CHANNELS, UI_MENU_AUDIO_CHANNELS_DESC, UI_MENU_CHANNELS_AUTO, UI_MENU_CHANNELS_STEREO, UI_MENU_CHANNELS_51,
// Controls
@@ -109,6 +114,8 @@ typedef enum {
UI_MENU_PROMPTS, UI_MENU_PROMPTS_DESC, UI_MENU_PROMPTS_NINTENDO, UI_MENU_PROMPTS_XBOX, UI_MENU_PROMPTS_PC,
// the notes under the prompts: their files are missing or damaged, they change after restart, or why they are off
UI_MENU_PROMPTS_MISSING, UI_MENU_PROMPTS_FAILED, UI_MENU_PROMPTS_RESTART, UI_MENU_PROMPTS_OFF_SHAPE,
UI_MENU_OUTPUT_RES_NO_LAYOUT, UI_MENU_OUTPUT_RES_PREPARING, UI_MENU_SHAPE_PREPARE, UI_MENU_SHAPE_PREPARE_DESC,
UI_MENU_SHAPE_PREPARE_FAILED,
UI_MENU_PROMPTS_OFF_MODS, UI_MENU_PROMPTS_OFF_PATCHES,
// "Restart now" under the prompts while they change after restart, and its confirmation (Cancel: UI_MENU_RESET_NO)
UI_MENU_RESTART, UI_MENU_RESTART_DESC, UI_MENU_RESTART_CONFIRM, UI_MENU_RESTART_YES, UI_MENU_RESTART_SAVING,
@@ -116,9 +123,28 @@ typedef enum {
UI_MENU_STICK_DEADZONE_NOW, UI_MENU_STICK_SENS, UI_MENU_STICK_SENS_DESC,
UI_MENU_MOUSE_MODE, UI_MENU_MOUSE_MODE_DESC, UI_MENU_MOUSE_STICK, UI_MENU_MOUSE_DIRECT,
UI_MENU_MENU_CURSOR, UI_MENU_MENU_CURSOR_DESC,
UI_MENU_MAP_CLICK, UI_MENU_MAP_CLICK_DESC,
UI_MENU_DIALOGUE_CLICK, UI_MENU_DIALOGUE_CLICK_DESC,
UI_MENU_POINTER_IMAGE, UI_MENU_POINTER_IMAGE_DESC,
UI_MENU_MOUSE_SENS, UI_MENU_MOUSE_SENS_DESC,
UI_MENU_WALK_KEY, UI_MENU_WALK_KEY_DESC, UI_MENU_WALK_KEY_TAKEN, UI_MENU_WALK_SCALE, UI_MENU_WALK_SCALE_DESC,
// Controls tab: Gameplay tweaks
UI_MENU_GROUP_GAMEPLAY_TWEAKS,
UI_MENU_GAMEPLAY_TWEAKS_ENABLED, UI_MENU_GAMEPLAY_TWEAKS_ENABLED_DESC,
UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE, UI_MENU_GAMEPLAY_ULTRAHAND_ROTATE_DESC,
UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS, UI_MENU_GAMEPLAY_ULTRAHAND_C_AXIS_DESC,
UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY, UI_MENU_GAMEPLAY_ROTATION_SENSITIVITY_DESC,
UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE, UI_MENU_GAMEPLAY_ULTRAHAND_DISTANCE_DESC,
UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY, UI_MENU_GAMEPLAY_DISTANCE_SENSITIVITY_DESC,
UI_MENU_GAMEPLAY_WEAPON_WHEEL, UI_MENU_GAMEPLAY_WEAPON_WHEEL_DESC,
UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY, UI_MENU_GAMEPLAY_WEAPON_SENSITIVITY_DESC,
UI_MENU_GAMEPLAY_ITEM_WHEEL, UI_MENU_GAMEPLAY_ITEM_WHEEL_DESC,
UI_MENU_GAMEPLAY_ITEM_SENSITIVITY, UI_MENU_GAMEPLAY_ITEM_SENSITIVITY_DESC,
UI_MENU_GAMEPLAY_ITEM_AD, UI_MENU_GAMEPLAY_ITEM_AD_DESC,
UI_MENU_GAMEPLAY_MAP_ZOOM, UI_MENU_GAMEPLAY_MAP_ZOOM_DESC,
UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY, UI_MENU_GAMEPLAY_MAP_ZOOM_SENSITIVITY_DESC,
// Controls tab: the remapping rows (ui/binds_page.cpp)
UI_BINDS_HELP, UI_BINDS_COL_KEY1, UI_BINDS_COL_KEY2, UI_BINDS_COL_PAD,
UI_BINDS_GROUP_BUTTONS, UI_BINDS_GROUP_MOVE, UI_BINDS_GROUP_CAMERA,
+6 -1
View File
@@ -36,7 +36,8 @@ typedef struct VkCtx {
has_nv_checkpoints, // VK_NV_device_diagnostic_checkpoints (TOTK_PASS_CRUMBS=1, vk_crumbs.c)
has_astc_ldr, // textureCompressionASTC_LDR (enabled when reported)
has_calibrated, // VK_KHR/EXT_calibrated_timestamps (GPU idle split in the perf line)
has_hdr_metadata; // VK_EXT_hdr_metadata (vk_hdr.c vk_hdr_metadata)
has_hdr_metadata, // VK_EXT_hdr_metadata (vk_hdr.c vk_hdr_metadata)
has_nv_reflex; // VK_NV_low_latency2 (NVIDIA Reflex Low Latency)
// Feedback loops (maxwell.md 1.9, vk_exec_draw.c feedback_prepare): a draw samples a target of its open pass that
// an earlier draw of the pass wrote. TOTK_FEEDBACK=0: VK_FEEDBACK_OFF (sampled in GENERAL without a barrier, the
// old behaviour); VK_FEEDBACK_LAYOUT with VK_EXT_attachment_feedback_loop_layout and dynamicRenderingLocalRead
@@ -147,6 +148,10 @@ void vk_present_blit(VkImage src, VkImageLayout layout, VkFormat fmt, int w, int
int vk_fsr_record(VkCommandBuffer cb, unsigned slot, VkImage src, VkFormat fmt, int sw, int sh, const int crop[4],
VkImage dst, const int out[4]);
void vk_fsr_release(void); // before the device goes away
void vk_reflex_submit_frame(uint64_t id); // this thread's submissions belong to frame id (0: the game's current one)
uint64_t vk_reflex_submit_id(void);
void vk_reflex_present_frame(uint64_t id); // the present thread, before the blit of frame id
int vk_has_reflex(void);
// Colour adjustment on the present (vk_color.c): with TOTK_COLOR_* away from their defaults, records a pass that writes
// src's crop rectangle {x, y, w, h}, adjusted, into an RGBA16F image of that size in GENERAL and returns it (the caller
// scales that one instead, crop {0, 0, w, h}); VK_NULL_HANDLE = nothing recorded. src is in GENERAL, fmt its format.
+11 -8
View File
@@ -33,7 +33,7 @@
#define WEAK __attribute__((weak))
typedef struct { VkImage image; VkFormat format; int w, h, has_crop, crop[4]; uint64_t frame, at, queued, value; } PresentJob;
typedef struct { VkImage image; VkFormat format; int w, h, has_crop, crop[4]; uint64_t frame, at, queued, value, pid; } PresentJob; // pid: the frame's present ID (vk_reflex_frame)
static PlatMutex pl = PLAT_MUTEX_INIT;
static PlatCond pcv = PLAT_COND_INIT; // job queued, job taken, job submitted
@@ -60,6 +60,8 @@ static void present_main(void *arg) {
plat_cond_broadcast(&pcv);
plat_mutex_unlock(&pl);
if (flight_on) vk_thumbs_frame(j.frame);
vk_reflex_present_frame(j.pid); // the present of this blit, and the submission after it, are the frame's
vk_reflex_submit_frame(j.pid);
vk_present_blit(j.image, VK_IMAGE_LAYOUT_GENERAL, j.format, j.w, j.h, j.has_crop ? j.crop : NULL);
uint64_t f = vk_sync_submit(NULL, 0); // a timeline value after the blit: deferred destruction waits for the blit too
if (j.value && f != j.value)
@@ -99,7 +101,7 @@ void vk_present_drain(void) {
// The present after the frame count: resolves the image and hands the blit to the present thread. queued: when the game
// presented; value: the timeline value queued for this present (asynchronous replay), 0 for the next one (synchronous).
static void present_image(const tex_t *t, const int crop[4], uint64_t at_ns, uint64_t queued, uint64_t frame,
uint64_t value) {
uint64_t value, uint64_t pid) {
static volatile int32_t n_skipped;
vk_exec_frame_log(t, frame);
vk_dlaa_frame();
@@ -120,7 +122,7 @@ static void present_image(const tex_t *t, const int crop[4], uint64_t at_ns, uin
return;
}
PresentJob j = {.image = img->image, .format = img->format, .w = (int)img->width, .h = (int)img->height, .frame = frame,
.at = at_ns, .queued = queued, .value = value};
.at = at_ns, .queued = queued, .value = value, .pid = pid};
vk_hdr_present_source(img, &j.image, &j.format); // TOTK_HDR: the float picture the game copied into it, same size
if (crop) {
j.has_crop = 1;
@@ -144,7 +146,7 @@ static void present_image(const tex_t *t, const int crop[4], uint64_t at_ns, uin
enum { RI_SUBMIT, RI_PRESENT, RI_RELEASE };
typedef struct {
int kind, n, has_crop, crop[4];
uint64_t value, submit_no, at, queued;
uint64_t value, submit_no, at, queued, pid; // pid: the game's frame when it queued the item (present ID)
uint64_t *h;
const tex_t *tex; // RI_RELEASE: a copy the item owns (the game may reuse the object's memory)
} ReplayItem;
@@ -223,6 +225,7 @@ static void replay_main(void *arg) {
plat_cond_broadcast(&rcv);
plat_mutex_unlock(&rl);
if (it.kind == RI_SUBMIT) {
vk_reflex_submit_frame(it.pid); // the replay thread submits the frame the game was on when it queued it
uint64_t f = submit_sync(it.h, it.n);
if (f != it.value)
rt_fatal("vk: replayed submission signalled %llu, queued as %llu", (unsigned long long)f,
@@ -234,7 +237,7 @@ static void replay_main(void *arg) {
free((void *)it.tex);
} else {
uint64_t frame = __atomic_add_fetch(&gfx_counters.frames, 1, __ATOMIC_RELAXED);
present_image(it.tex, it.has_crop ? it.crop : NULL, it.at, it.queued, frame, it.value);
present_image(it.tex, it.has_crop ? it.crop : NULL, it.at, it.queued, frame, it.value, it.pid);
}
plat_mutex_lock(&rl);
if (it.kind != RI_RELEASE) r_value_done = it.value;
@@ -345,7 +348,7 @@ static void vk_be_present(const tex_t *t, const int crop[4], uint64_t at_ns) {
if (!gfx_replay_async()) {
uint64_t frame = __atomic_add_fetch(&gfx_counters.frames, 1, __ATOMIC_RELAXED);
perf_present(frame); // before vk_exec_frame_log, which resets the frame's exec counts the flight recorder reads
present_image(t, crop, at_ns, kern_now_ns(), frame, 0);
present_image(t, crop, at_ns, kern_now_ns(), frame, 0, vk_reflex_frame());
return;
}
// Frame bound: the replay thread handled the previous present before this one is queued.
@@ -361,7 +364,7 @@ static void vk_be_present(const tex_t *t, const int crop[4], uint64_t at_ns) {
uint64_t frame = ++game_frames;
perf_present(frame);
if (frame % 1800 == 0) replay_log(frame, 0);
ReplayItem it = {.kind = RI_PRESENT, .tex = t, .at = at_ns, .queued = kern_now_ns()};
ReplayItem it = {.kind = RI_PRESENT, .tex = t, .at = at_ns, .queued = kern_now_ns(), .pid = vk_reflex_frame()};
if (crop) {
it.has_crop = 1;
for (int i = 0; i < 4; i++) it.crop[i] = crop[i];
@@ -408,7 +411,7 @@ static void vk_be_program_release(const prog_t *p) { replay_drain(DR_PROG_RELEAS
static uint64_t vk_be_submit(const uint64_t *handles, int n) {
if (!gfx_replay_async()) return submit_sync(handles, n);
vk_sync_start();
ReplayItem it = {.kind = RI_SUBMIT, .n = n, .submit_no = nvn_submit_count()};
ReplayItem it = {.kind = RI_SUBMIT, .n = n, .submit_no = nvn_submit_count(), .pid = vk_reflex_frame()};
if (n > 0) {
it.h = malloc(sizeof *it.h * (size_t)n);
if (!it.h) rt_fatal("vk: out of memory (replay queue)");
+20 -2
View File
@@ -283,6 +283,7 @@ typedef struct {
VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT fbl;
VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR lr;
VkPhysicalDeviceAddressBindingReportFeaturesEXT abr;
VkPhysicalDevicePresentIdFeaturesKHR pid;
} FeatureChain;
static int create_device(void) {
@@ -290,7 +291,7 @@ static int create_device(void) {
vkEnumerateDeviceExtensionProperties(g_vk.phys, NULL, &ne, NULL);
VkExtensionProperties *ep = calloc(ne ? ne : 1, sizeof *ep);
vkEnumerateDeviceExtensionProperties(g_vk.phys, NULL, &ne, ep);
const char *ext[48];
const char *ext[52];
uint32_t n_ext = 0;
for (size_t i = 0; i < sizeof k_required_ext / sizeof *k_required_ext; i++) ext[n_ext++] = k_required_ext[i];
@@ -334,7 +335,7 @@ static int create_device(void) {
CHAIN(fbl, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
CHAIN(lr, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR);
}
vk_dlaa_device_exts(ep, ne, ext, &n_ext, 40); // NGX's; the eight slots after it stay for the seven below
vk_dlaa_device_exts(ep, ne, ext, &n_ext, 40); // NGX's; the twelve slots after it stay for the nine below
if (has_ext(ep, ne, VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) { g_vk.has_memory_budget = 1; ext[n_ext++] = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME; }
// GPU timestamps on the CPU clock (vk_sync.c): the perf line splits GPU idle time into waiting for a submission or not.
if (has_ext(ep, ne, VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME)) { g_vk.has_calibrated = 2; ext[n_ext++] = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME; }
@@ -351,6 +352,18 @@ static int create_device(void) {
g_vk.has_nv_checkpoints = 1;
ext[n_ext++] = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME;
}
// NVIDIA Reflex Low Latency (VK_NV_low_latency2 requires VK_KHR_present_id)
const char *rv = cfg_value("TOTK_REFLEX");
if (rv && strcmp(rv, "off") != 0 && strcmp(rv, "0") != 0) {
if (has_ext(ep, ne, VK_KHR_PRESENT_ID_EXTENSION_NAME) && has_ext(ep, ne, "VK_NV_low_latency2")) {
g_vk.has_nv_reflex = 1;
ext[n_ext++] = VK_KHR_PRESENT_ID_EXTENSION_NAME;
ext[n_ext++] = "VK_NV_low_latency2";
CHAIN(pid, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
} else {
rt_log("Reflex: VK_NV_low_latency2 not available");
}
}
// Graphics pipeline library: chained last so it can be dropped again when vk_caps_gpl declines it.
void **gpl_link = NULL;
if (has_ext(ep, ne, VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME) && has_ext(ep, ne, VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME)) {
@@ -392,6 +405,11 @@ static int create_device(void) {
: !ab_want ? "off (TOTK_ADDR_REPORT=0 or no VK_EXT_debug_utils)"
: "unavailable (no VK_EXT_device_address_binding_report)");
g_vk.has_buffer_device_address = c->f12.bufferDeviceAddress;
// VkPresentIdKHR on a present needs the presentId feature, not just the extension
if (g_vk.has_nv_reflex && !c->pid.presentId) {
g_vk.has_nv_reflex = 0;
rt_log("Reflex: VK_NV_low_latency2 not available (no presentId feature)");
}
g_vk.has_astc_ldr = h->textureCompressionASTC_LDR;
{
const char *e = cfg_get("TOTK_FEEDBACK");
+17 -1
View File
@@ -294,6 +294,7 @@ static struct {
unsigned cfg_seen; // cfg_version when preset was read
uint64_t last_eval_ns; // plat_now_ns of the previous evaluation (FrameTimeDeltaInMsec)
} D = {.mv_ok = -1, .cfg_seen = ~0u};
#define DLSS_SIZES (sizeof D.sizes / sizeof D.sizes[0])
const VkTexImage *vk_dlaa_swap_img;
VkImageView vk_dlaa_swap_view;
@@ -949,7 +950,7 @@ static void evaluate(VkExec *ex, const VkExecTarget *dst) {
VkCommandBuffer cb = ex->cb;
vk_exec_barrier(ex); // what drew the scene is done (no pass is open here)
if (D.preset_dirty) { // another model: features are created with it, so every size gets a new one
for (int i = 0; i < 3; i++)
for (size_t i = 0; i < DLSS_SIZES; i++)
if (D.sizes[i].out) free_size(&D.sizes[i]);
D.last = NULL, D.preset_dirty = 0;
}
@@ -1305,6 +1306,21 @@ int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs) {
}
if (fxaa && !D.up) return 0; // nothing to skip: no shader lookup per draw at the defaults
if (!fs) return 0;
// 1.2.1 scales the light target to the output with an upscaler of its own (12 texelFetch taps around the source
// pixel, fragment shader e6f7ae35b8479ef3 with this build's translator), not with the FXAA one, in a pass without
// depth. It addresses its source in the scene's pixels (constant bank 3), so DLSS's output-sized picture swapped in
// (tex_info) showed only its top-left part, the scene's share of the output (two thirds at DLSS quality), over
// the whole screen (#1106). DLSS already wrote its picture into that pass's target
// (evaluate), so on 1.2.1 a draw there that samples the light target is skipped instead; the HUD drawn later into
// the same target samples other textures and stays. On 1.4.3 a tonemap can be the draw that scales (the comment
// above struct D), and it keeps the swap.
if (D.up && !RT_V143 && !ex->depth.image && vk_dlaa_swap_img && ex->pass_w > vk_dlaa_swap_img->width + 1 &&
vk_exec_draw_samples(ex, fs, vk_dlaa_swap_img)) {
static int logged;
if (!logged) logged = 1, rt_log("dlaa: DLSS replaces the game's scaling draw (fragment shader %016llx)",
(unsigned long long)spirv_hash(fs));
return 1;
}
uint64_t h = spirv_hash(fs);
int known = 0;
for (size_t i = 0; i < sizeof FXAA_FS / sizeof FXAA_FS[0]; i++) known |= h == FXAA_FS[i];
+25 -2
View File
@@ -528,15 +528,38 @@ static void tfr_note(const VkExecTarget *t, uint64_t stamp) {
plat_mutex_lock(&tfr_lock);
TargetFrames *e = tfr_find(t);
if (!e) {
e = tfr_set(t);
// the way rendered longest ago, indexed from the set's start: the ways past the last set are RP's words
TargetFrames *s = tfr_set(t);
e = s;
for (int i = 1; i < TFR_WAYS; i++)
if (e[i].last < e->last) e = &e[i];
if (s[i].last < e->last) e = &s[i];
*e = (TargetFrames){t->image, t->level, t->base_layer, 0, 0};
}
if (e->last != stamp) e->prev = e->last, e->last = stamp;
plat_mutex_unlock(&tfr_lock);
}
// --probe-vkexec: a new target noted into a full set takes the way rendered longest ago, and the set after it keeps
// its entries. The ways are stamped so that a search stepping from the way it picked last would leave the set. 1 when
// it holds; the two sets are cleared afterwards.
int vk_exec_tfr_check(void) {
VkExecTarget t[TFR_WAYS + 1];
for (int n = 0, k = 1; n <= TFR_WAYS; k++) {
t[n] = (VkExecTarget){.image = (VkImage)(uintptr_t)k};
n += tfr_set(&t[n]) == tfr[0];
}
static const uint64_t last[TFR_WAYS] = {8, 7, 100, 6, 100, 100, 5, 100};
TargetFrames next[TFR_WAYS];
for (int i = 0; i < TFR_WAYS; i++) tfr[0][i] = (TargetFrames){t[i].image, 0, 0, last[i], 0};
memcpy(next, tfr[1], sizeof next);
tfr_note(&t[TFR_WAYS], 200);
plat_mutex_lock(&tfr_lock);
int ok = tfr_find(&t[TFR_WAYS]) == &tfr[0][6] && !memcmp(next, tfr[1], sizeof next);
plat_mutex_unlock(&tfr_lock);
memset(tfr, 0, sizeof tfr[0] * 2);
return ok;
}
static int tfr_recent(const VkExecTarget *t, uint64_t stamp) {
plat_mutex_lock(&tfr_lock);
const TargetFrames *e = tfr_find(t);
+4
View File
@@ -195,6 +195,9 @@ void vk_exec_inline_end(int reopen);
// vk_exec_draw.c: forget what the command buffer being recorded has bound (pipeline, sets, dynamic state, vertex
// buffers): the replay continues in a new one (vk_sync_split).
void vk_exec_draw_new_cb(VkExec *ex);
// vk_exec_draw.c: the fragment stage of the draw being recorded samples img through one of its bound combined
// textures (OP_BIND_TEX, the handles tex_info swaps; vk_dlaa.c vk_dlaa_skip_draw). Takes the texture lock.
int vk_exec_draw_samples(VkExec *ex, const GfxShader *fs, const VkTexImage *img);
// The recording threads of the chunked replay as this run read TOTK_REPLAY_WORKERS (0 off), -1 before the first
// submission read it (the settings menu shows it).
int vk_exec_replay_workers(void);
@@ -219,6 +222,7 @@ void vk_exec_noatt_dims(const VkExec *ex, uint32_t *w, uint32_t *h); // pass s
int vk_exec_targets_recent(VkExec *ex, int any);
// The current pass's targets with their formats, extents and the frames they were last rendered in (diagnostics).
void vk_exec_targets_describe(VkExec *ex, char *buf, size_t cap);
int vk_exec_tfr_check(void); // --probe-vkexec: a new target replaces a way of its own set; 1 when it does
extern VkExecFrame vk_exec_frame;
void vk_exec_frame_written(const tex_t *t); // vk_texture_gpu_written: t rendered or copied into
+17
View File
@@ -1709,6 +1709,23 @@ static Twin *twin_update(VkExec *ex, const VkTexImage *img) {
return t;
}
int vk_exec_draw_samples(VkExec *ex, const GfxShader *fs, const VkTexImage *img) {
const GfxShaderRes *res;
int n = fs && img ? gfx_shader_resources(fs, GFX_RES_TEX, &res) : 0, hit = 0;
if (!n) return 0;
vk_texture_lock();
for (int i = 0; i < n && !hit; i++) {
if (res[i].separate || res[i].slot < 0) continue;
for (int k = 0; k < (res[i].count ? res[i].count : 1) && !hit; k++) {
int slot = res[i].slot + k;
uint64_t h = slot < 128 ? ex->tex[NVN_STAGE_FS][slot] : 0;
hit = h && vk_texture_by_id_locked((int)(h & 0xfffff), NULL, NULL) == img;
}
}
vk_texture_unlock();
return hit;
}
// The image descriptor of slot h; in a dispatch, a compare-sampled colour image the driver cannot compare is swapped
// for its depth twin; in a pass larger than it, the scene's light target, once DLSS scaled it this frame, for DLSS's
// output (vk_dlaa.c).
+2
View File
@@ -966,6 +966,8 @@ int probe_vkexec(void) {
layouts_equal = 0;
main_tid = plat_thread_id();
const GfxBackend *b = &gfx_vulkan_backend;
CHECK(vk_exec_tfr_check(), "a target noted into a full set of the target history did not take that set's oldest way");
printf("probe-vkexec: target history part passed (a new target replaces the oldest way of its own set)\n");
uint64_t heap = 0;
CHECK(mem_set_heap_size(16ull << 20, &heap) == 0 && heap, "SetHeapSize 16 MiB");
// Out-of-memory waits (oom.c): the first two staging buffers, the first texture image and the first draw-data chunk
+2 -2
View File
@@ -18,8 +18,8 @@
// 3. vk_hdr_encode: on the present, the crop rectangle goes to PQ code values in an RGBA16F image (shaders/hdr_encode.comp)
// that FSR 1 or the blit scale into the swapchain. vk_hdr_ui_*: the in-game menu draws into an RGBA8 image and
// shaders/hdr_ui.frag blends it onto the swapchain at the HUD's white.
// The tonemap's approach is RenoDX's TotK mod by souperman9 and Musa on ShortFuse's RenoDX (github.com/clshortfuse/renodx,
// src/games/totk, MIT); the code is ours.
// The tonemap's colour reconstruction is adapted from RenoDX's TotK mod by souperman9 and Musa on ShortFuse's RenoDX
// (github.com/clshortfuse/renodx, src/games/totk, MIT; THIRD_PARTY_NOTICES.md); the rest of this file is ours.
#include "vk.h"
#include <math.h>
+17 -4
View File
@@ -318,8 +318,14 @@ int rec_end_cb(VkCommandBuffer cb, int crumb, uint64_t n) {
return 1;
}
// At most two command buffers and one signal: the shape vk_sync.c submits.
typedef struct { uint32_t ncb, nsig; VkCommandBufferSubmitInfo cbi[2]; VkSemaphoreSubmitInfo sig; } A_Submit;
// At most two command buffers and one signal: the shape vk_sync.c submits. The only pNext it chains is Reflex's
// VkLatencySubmissionPresentIdNV (vk_sync_submit), carried as its present ID.
typedef struct {
uint32_t ncb, nsig, has_pid;
uint64_t present_id;
VkCommandBufferSubmitInfo cbi[2];
VkSemaphoreSubmitInfo sig;
} A_Submit;
VkResult rec_submit(const VkSubmitInfo2 *si) {
if (!sub_pending) {
vk_queue_lock();
@@ -328,12 +334,16 @@ VkResult rec_submit(const VkSubmitInfo2 *si) {
return r;
}
sub_pending = 0;
if (si->commandBufferInfoCount > 2 || si->signalSemaphoreInfoCount > 1 || si->waitSemaphoreInfoCount || si->pNext)
const VkBaseInStructure *nx = si->pNext;
int pid = nx && nx->sType == VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV && !nx->pNext;
if (si->commandBufferInfoCount > 2 || si->signalSemaphoreInfoCount > 1 || si->waitSemaphoreInfoCount ||
(nx && !pid))
rt_fatal("vk_rec: a submission of %u command buffers, %u waits and %u signals the recorder cannot carry",
si->commandBufferInfoCount, si->waitSemaphoreInfoCount, si->signalSemaphoreInfoCount);
A_Submit *a = put(R_Submit, sizeof *a);
memset(a, 0, sizeof *a);
a->ncb = si->commandBufferInfoCount, a->nsig = si->signalSemaphoreInfoCount;
if (pid) a->has_pid = 1, a->present_id = ((const VkLatencySubmissionPresentIdNV *)nx)->presentID;
for (uint32_t i = 0; i < a->ncb; i++) a->cbi[i] = si->pCommandBufferInfos[i];
if (a->nsig) a->sig = si->pSignalSemaphoreInfos[0];
__atomic_store_n(&q_subs, q_subs + 1, __ATOMIC_RELEASE);
@@ -354,7 +364,10 @@ VkResult rec_submit(const VkSubmitInfo2 *si) {
}
static void submit_run(const A_Submit *a) {
VkSubmitInfo2 si = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, .commandBufferInfoCount = a->ncb,
VkLatencySubmissionPresentIdNV lsid = {.sType = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV,
.presentID = a->present_id};
VkSubmitInfo2 si = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, .pNext = a->has_pid ? &lsid : NULL,
.commandBufferInfoCount = a->ncb,
.pCommandBufferInfos = a->cbi, .signalSemaphoreInfoCount = a->nsig,
.pSignalSemaphoreInfos = a->nsig ? &a->sig : NULL};
vk_queue_lock();
+8
View File
@@ -474,12 +474,20 @@ uint64_t vk_sync_submit(const uint64_t *handles, int n) {
{.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, .commandBuffer = s->cb}};
VkSemaphoreSubmitInfo sig = {.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, .semaphore = c->timeline,
.value = fence, .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT};
VkLatencySubmissionPresentIdNV lsid = {
.sType = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV,
.pNext = NULL,
.presentID = vk_reflex_submit_id()
};
VkSubmitInfo2 si = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
.pNext = (c->has_nv_reflex) ? &lsid : NULL,
.commandBufferInfoCount = (pro ? 1u : 0u) + (recorded ? 1u : 0u),
.pCommandBufferInfos = pro ? cbi : cbi + 1, .signalSemaphoreInfoCount = 1,
.pSignalSemaphoreInfos = &sig};
ts_submitted();
if (recorded && c->has_nv_reflex) vk_reflex_marker(2, lsid.presentID); // VK_LATENCY_MARKER_RENDERSUBMIT_START_NV
VkResult r = rec_submit(&si); // by the recorder when it recorded the part
if (recorded && c->has_nv_reflex) vk_reflex_marker(3, lsid.presentID); // VK_LATENCY_MARKER_RENDERSUBMIT_END_NV
if (r != VK_SUCCESS) {
vk_device_fault_report(r);
rt_fatal("vk: vkQueueSubmit2 of value %llu failed (%d)", (unsigned long long)fence, (int)r);
+139 -2
View File
@@ -16,7 +16,7 @@ from unittest import mock
ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT))
from installer import ini, runner, state, steps # noqa: E402
from installer import ini, runner, screens, state, steps # noqa: E402
from installer.events import Reporter # noqa: E402
from installer.layout import Layout # noqa: E402
@@ -384,6 +384,57 @@ class LiftRunTest(unittest.TestCase):
self.assertIn('warn.exefs_skipped', self.ctx.reporter.out.getvalue())
class CompileLockedTest(unittest.TestCase):
"""Compile.run when the linker cannot write its totk.exe: another program holds the file (a game started from the
temp build folder, an antivirus that quarantined it), which gets its own message instead of the plain failure."""
LLD = ("ld.lld: error: failed to write output 'temp/totk-1/build/totk.exe': Permission denied\n"
"clang-23: error: unable to remove file: Permission denied\n")
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
base = Path(tmp.name)
dest, temp = base / 'install', base / 'temp'
dest.mkdir()
temp.mkdir()
layout = SimpleNamespace(tools=ROOT / 'tools', llvm=base / 'llvm', deps=None, sysroot=None, runtime=base,
ninja=base / 'ninja', dlls=[], runtime_lib_for=lambda cpu: None,
pgo=lambda version: None, expected=lambda version: base / 'expected.json')
self.ctx = SimpleNamespace(dest=dest, temp=temp, layout=layout, state={'version': '1.4.3'},
reporter=Reporter(out=io.StringIO()))
self.addCleanup(self.ctx.reporter.close)
self.log_text = ''
saved = steps.run_tool
self.addCleanup(lambda: setattr(steps, 'run_tool', saved))
steps.run_tool = self.run_tool
def run_tool(self, ctx, step, script, args, parse=None, cwd=None):
log = ctx.temp / 'compile.log'
log.write_text(self.log_text, encoding='utf-8')
return 1, log
def test_locked_link_output(self):
self.log_text = 'link: 0.8 s\n' + self.LLD
with self.assertRaises(steps.InstallError) as e:
steps.Compile().run(self.ctx)
self.assertEqual(e.exception.id, 'compile.exe_locked')
self.assertTrue(e.exception.params['path'].endswith('totk' + steps.EXE))
def test_other_failure(self):
self.log_text = 'runtime/x.c:1:1: error: expected expression\n'
with self.assertRaises(steps.InstallError) as e:
steps.Compile().run(self.ctx)
self.assertEqual(e.exception.id, 'compile.failed')
def test_message_in_every_language(self):
for path in sorted((ROOT / 'installer' / 'text').glob('*.json')):
text = json.loads(path.read_text(encoding='utf-8'))
self.assertIn('compile.exe_locked', text, path.name)
self.assertIn('{path}', text['compile.exe_locked'], path.name)
self.assertIn('{log}', text['compile.exe_locked'], path.name)
class IniTest(unittest.TestCase):
EXAMPLE = '[display]\n# vk_present = mailbox\n\n[language]\n# locale = en-US\n# lang = en-US\n# x = 1\n'
@@ -537,6 +588,92 @@ class BaseGameCheckTest(unittest.TestCase):
self.assertEqual(steps.program_nca(records)[0]['title_id'], self.BASE)
class ShapesTest(unittest.TestCase):
"""installer/screens.py and the shapes step: one folder per screen shape, only for the displays and the prompts
style this player has (runtime/cfg.c cfg_shape_size maps the game resolution the same way)."""
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.dest = Path(self.tmp.name)
self.ctx = SimpleNamespace(dest=self.dest, keys={'prepare': 'p'}, layout=SimpleNamespace(tools=ROOT / 'tools'),
reporter=Reporter(out=io.StringIO()))
self.saved = steps.run_tool, steps.game_version, screens.displays
steps.game_version = lambda ctx: '1.4.3'
self.calls = []
def run(ctx, step, script, args, parse=None, cwd=None):
self.calls.append([str(a) for a in args])
out = Path(args[args.index('--out') + 1])
out.mkdir(parents=True)
(out / 'manifest.tsv').write_text('#\n')
return 0, None
steps.run_tool = run
def tearDown(self):
steps.run_tool, steps.game_version, screens.displays = self.saved
self.ctx.reporter.close()
self.tmp.cleanup()
def test_shape_rule(self):
self.assertEqual([screens.shape_size(*s) for s in ((5120, 2160), (3440, 1440), (1920, 800), (2560, 1600),
(1920, 1080), (1024, 768))],
['2560x1080', '3440x1440', '3840x1600', '1280x800', None, None])
self.assertEqual(screens.default_size(3440, 1440), '2560x1080') # runtime/cfg.c screen_default
self.assertEqual(screens.default_size(1280, 800), '1280x800')
def test_prompts_style_as_the_game_picks_it(self):
self.assertEqual([screens.prompts_style(t) for t in ('', 'prompts = pc', 'prompts = xbox',
'pad_layout = nintendo\nprompts = xbox',
'pad_layout = xbox_prompts', 'prompts = nintendo')],
[None, 'pc', 'xbox-label', 'xbox', 'xbox', None])
def test_wanted_from_displays_and_ini(self):
(self.dest / 'totk.ini').write_text('[display]\noutput_res = 3000x2000\n[input]\nprompts = pc\n')
self.assertEqual(screens.wanted(self.dest, [(3440, 1440), (1920, 1080), (800, 1280)]),
(['2560x1080', '3440x1440', '1280x800', '1920x1280'], 'pc'))
self.assertEqual(screens.wanted(self.dest / 'none', [(2560, 1440)]), ([], None))
def test_run_writes_only_the_wanted_folders(self):
screens.displays = lambda: [(2560, 1080)]
(self.dest / 'totk.ini').write_text('pad_layout = nintendo\nprompts = xbox\n')
for old in ('romfs-patches-3440x1440', 'romfs-patches-pc-1280x800', 'romfs-patches-xbox'):
(self.dest / old).mkdir()
(self.dest / 'romfs-patches-xbox' / 'manifest.tsv').write_text('#\n')
step = steps.Shapes()
step.key(self.ctx)
record = step.run(self.ctx)
self.assertEqual(record['folders'], ['romfs-patches-2560x1080', 'romfs-patches-xbox-2560x1080'])
self.assertEqual(sorted(p.name for p in self.dest.iterdir() if p.is_dir()),
['romfs-patches-2560x1080', 'romfs-patches-xbox', 'romfs-patches-xbox-2560x1080'])
self.assertEqual(self.calls[0][-2:], ['--aspect', '2560x1080'])
self.assertTrue(step.current(self.ctx, record))
def test_pc_prompts_shapes_follow_the_bindings(self):
screens.displays = lambda: [(3440, 1440)]
(self.dest / 'totk.ini').write_text('[input]\nprompts = pc\nbind_attack = key:f\n')
(self.dest / 'romfs-patches-pc').mkdir()
(self.dest / 'romfs-patches-pc' / 'manifest.tsv').write_text('#\n')
step = steps.Shapes()
self.ctx.keys['pc_prompts'] = 'a'
key = step.key(self.ctx)
self.ctx.keys['pc_prompts'] = 'b'
self.assertNotEqual(step.key(self.ctx), key)
record = step.run(self.ctx)
# the display's own shape and that of the 2560x1080 the game defaults to on it (runtime/cfg.c screen_default)
self.assertEqual(record['folders'], ['romfs-patches-2560x1080', 'romfs-patches-pc-2560x1080',
'romfs-patches-3440x1440', 'romfs-patches-pc-3440x1440'])
self.assertEqual(self.calls[1][-4:], ['--reuse', str(self.dest / 'romfs-patches-pc'), '--binds',
str(self.dest / 'totk.ini')])
self.assertNotIn('--binds', self.calls[0])
def test_pc_prompts_writes_only_the_16_9_folder(self):
(self.dest / 'totk.ini').write_text('[input]\nbind_attack = key:f\n')
self.assertEqual(steps.PcPrompts().run(self.ctx), {})
self.assertEqual([p.name for p in self.dest.iterdir() if p.is_dir()], ['romfs-patches-pc'])
self.assertEqual(len(self.calls), 1)
self.assertEqual(self.calls[0][-2:], ['--binds', str(self.dest / 'totk.ini')])
class FontsTest(unittest.TestCase):
"""The fonts step: keyed by language and firmware, a no-op without firmware, writes dest/shared-fonts."""
@@ -575,7 +712,7 @@ class FontsTest(unittest.TestCase):
def test_all_steps_order(self):
self.assertEqual([s.id for s in steps.all_steps()],
['check', 'fonts', 'extract', 'lift', 'compile', 'prepare', 'dlss', 'cleanup'])
['check', 'fonts', 'extract', 'lift', 'compile', 'prepare', 'pc_prompts', 'shapes', 'dlss', 'cleanup'])
def test_extracts_into_the_install_folder(self):
self.fake_tool()
+13 -9
View File
@@ -1,9 +1,9 @@
"""The mods folder served as RomFS overlays (runtime/romfs.c, runtime/mods.c): load order, added files, case, Unicode.
.venv\\Scripts\\python tests\\mods_romfs_check.py --exe build\\v121-<tag>\\totk.exe --version v121
.venv\\Scripts\\python tests\\mods_romfs_check.py --exe build\\v121-<tag>\\totk.exe --version v121 [--romfs <dir>]
Builds a mods folder in a temp directory with files of its own bytes at real RomFS paths (from
build/extracted/<version>/romfs/index.json), runs `totk.exe --probe-fs` on it and reads the `mods:` lines of the log.
build/extracted/<version>/romfs/index.json unless --romfs says otherwise), runs `totk.exe --probe-fs` on it and reads the `mods:` lines of the log.
--probe-fs compares the bytes it reads through the RomFS with every overlay file, so a wrong winner fails it too.
A second folder checks the merged resource size table the start writes to the profile (runtime/romfs.c
restbl_overlay): a grown file's entry, an added file's, a shipped table's and another version's table's.
@@ -25,8 +25,8 @@ ROOT = Path(__file__).resolve().parents[1]
UNI = 'Ж мод'
def pick_paths(version):
index = json.loads((ROOT / 'build/extracted' / version / 'romfs/index.json').read_text())
def pick_paths(version, romfs):
index = json.loads((romfs / 'index.json').read_text(encoding='utf-8'))
paths = [f['path'] for f in index['files'] if 1024 <= f['size'] <= 65536]
have = set(f['path'] for f in index['files'])
p1 = next(p for p in paths if any(c.isalpha() for c in p.rsplit('/', 1)[-1]))
@@ -83,8 +83,7 @@ def key(path):
return zlib.crc32((path[:-3] if path.endswith(('.zs', '.mc')) else path).encode())
def restbl_case(exe, version, check, tmp):
romfs = ROOT / 'build/extracted' / version / 'romfs'
def restbl_case(exe, version, romfs, check, tmp):
index = json.loads((romfs / 'index.json').read_text())
files = {f['path']: f for f in index['files']}
table_path = next(p for p in files if p.startswith('System/Resource/ResourceSizeTable.') and
@@ -129,8 +128,11 @@ def main():
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
ap.add_argument('--exe', type=Path, required=True)
ap.add_argument('--version', choices=('v121', 'v143'), required=True)
ap.add_argument('--romfs', type=Path,
default=ROOT / 'build/extracted' / 'v143' / 'romfs',
help='the extracted romfs (its index.json names the real file paths)')
args = ap.parse_args()
p1, p2, p1case = pick_paths(args.version)
p1, p2, p1case = pick_paths(args.version, args.romfs)
fails = 0
def check(ok, what, log=None):
@@ -152,13 +154,15 @@ def main():
put(mods, UNI, p2, b'mod-G')
# a file of another game version's (no RomFS has a Product.999 table): counted, never served
put(mods, 'Low', 'System/Resource/ResourceSizeTable.Product.999.rsizetable.zs', b'mod-H')
# any other file named for another version: counted, and served under its name as an added file
put(mods, 'Case', 'Sound/Resource/Named.Product.999.bars', b'mod-J')
put(mods, 'Lite', 'Lite/added.bin', b'mod-I', part='romfslite') # TKMM's romfslite folder
code, log = run(args.exe, mods, f'Top|Low|{UNI}|Case')
check(code == 0, 'probe-fs passes with five mods (served bytes equal the winners\' files)', log)
for line in ('mods: Top: 2 files served (1 replaced, 1 added), 0 overridden',
'mods: Low: 1 files served (1 replaced, 0 added), 2 overridden by Top, 1 for another game version',
'mods: Case: 0 files served (0 replaced, 0 added), 1 overridden by Top',
'mods: Case: 1 files served (0 replaced, 1 added), 1 overridden by Top, 1 for another game version',
f'mods: {UNI}: 0 files served (0 replaced, 0 added), 1 overridden by Low',
'mods: Lite: 1 files served (0 replaced, 1 added), 0 overridden'):
check(line in log, line, log)
@@ -169,7 +173,7 @@ def main():
check('mods: Low: 3 files served (2 replaced, 1 added), 0 overridden' in log, 'Low serves P1 and the added file', log)
check('mods: Top: ' not in log.replace('mods: Top: off', ''), 'a switched-off mod serves nothing', log)
restbl_case(args.exe, args.version, check, tmp)
restbl_case(args.exe, args.version, args.romfs, check, tmp)
print('mods_romfs_check:', 'FAIL' if fails else 'ok')
return 1 if fails else 0
+8
View File
@@ -591,6 +591,14 @@ InputMap input_map;
// Other input entry points are linked by PE unwind metadata; reaching them is outside this script-only test.
void ikb_cursor_update(void) { abort(); }
void ikb_menu_closed(void) { abort(); }
int gameplay_tweaks_capture_needed(void) { return 0; }
int gameplay_tweaks_map_zoom(void) { return 0; }
int gameplay_tweaks_strip_wheel(uint64_t b) { (void)b; return 0; }
void gameplay_tweaks_reset(void) {}
void gameplay_tweaks_prepare_keys(uint8_t *d, uint64_t b) { (void)d; (void)b; }
void gameplay_tweaks_apply(uint64_t f, int a, uint64_t *b, int32_t *lx, int32_t *ly, int32_t *rx, int32_t *ry) {
(void)f; (void)a; (void)b; (void)lx; (void)ly; (void)rx; (void)ry;
}
int cfg_bool(const char *key) { (void)key; abort(); }
int input_menu_gate(int *h,int open,uint64_t *b,int32_t s[4]) { (void)h;(void)open;(void)b;(void)s;abort(); }
int input_overlay_gate(int *h,uint64_t *b) { (void)h;(void)b;abort(); }
+169
View File
@@ -0,0 +1,169 @@
"""Check the v110 patch contracts without game data; optionally check every site and spin against local ExeFS.
python tests/patches_v110_check.py --exefs <local ExeFS> [--cflags=-march=x86-64-v2]
Uses the differential harness, Clang (CC) and Unicorn. Extracted bytes and generated C stay in build/.
"""
import argparse
import math
import struct
import sys
import tempfile
import zlib
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests' / 'diff'))
from common import BUF, BUF_SIZE, Emu, build_harness, diff_state, run_harness
import patches
from lifter import Lifter
from layout import layout
from module import Module
# Set, offset, target register, result kind. The patch file owns the instruction words.
SITES = [
('realtime', 0xa20518, 1, 'zero'),
('cursor', 0xf31e80, 0, 'map'),
('cursor', 0x1d55f24, 12, 'aim'),
('cursor', 0x1d556a4, 3, 'gyro'),
*[('aspect', a, 0, 'aspect') for a in (0xcdbf30, 0x1261a64, 0x19c2260, 0x1ed8fa4)],
*[('fov', a, 0, 'fov') for a in (0xcdbef8, 0x1261a2c)],
('pooloff', 0x9b93a8, 2, 'offset'), ('pooloff', 0x9b93c4, 1, 'source'),
('shadow', 0xd0760c, 11, 'shadow'),
*[('cascade', a, 8, 'cascade') for a in (0x1157fb8, 0x1158040, 0x11580c8, 0x115814c)],
]
def f32(v):
return struct.unpack('<f', struct.pack('<f', v))[0]
def scalar(v):
return struct.unpack('<f', (v & 0xffffffff).to_bytes(4, 'little'))[0]
def main():
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument('--exefs', type=Path)
ap.add_argument('--cflags', default='-march=x86-64-v3')
args = ap.parse_args()
mods = layout(args.exefs) if args.exefs else [
('main', 0x7000000000, 0x472d000), ('subsdk0', 0x7004800000, 0x400000),
('sdk', 0x7004c00000, 0x800000)]
table = patches.load(ROOT / 'recomp' / 'patches-v110.txt', mods)
base = mods[0][1]
if args.exefs:
for name, at, _ in mods:
mod = Module(name, args.exefs / name, at)
patches.check(table, mod, name)
print(f'v110: all {sum(len(s) for s in table.sites.values())} sites and '
f'{sum(len(s) for s in table.spins.values())} spin back-edges match local ExeFS')
by_name = {name: i for i, (name, _, _) in enumerate(table.sets)}
resolved = table.for_module('main', base)
bodies, words = [], []
lift = Lifter(base, 'c')
for name, off, _, _ in SITES:
alternatives = table.sites['main'][off]
assert len(alternatives) == 1 and alternatives[0][0] == by_name[name]
orig = alternatives[0][2]
repl = resolved[base + off][0][1]
original = lift.lift(orig, base + off)
replacement = [lift.lift(w, base + off) for w in repl]
assert original.kind == 'op' and all(i.kind == 'op' for i in replacement)
bodies.append('if (c->x[30]) { ' + ' '.join(i.code for i in replacement) +
' } else { ' + original.code + ' }')
words.append((orig, repl))
build = ROOT / 'build'
build.mkdir(exist_ok=True)
groups = {ratio: ([], []) for ratio in (1.0, 0.5, 0.25)}
page = bytearray(0x1000)
# Distinct fields reveal an accidental load from the neighboring page slot.
for off, value in ((0, 0.5), (4, 1 / 60), (56, 21 / 9), (60, 1.2),
(64, 25), (68, 50), (72, 100), (76, 200)):
struct.pack_into('<f', page, off, value)
struct.pack_into('<I', page, 92, 2048)
initial = bytearray(BUF_SIZE)
for off, value in ((0, 3), (4, 5), (8, 0.5), (0x13c, 0.9), (0x140, 16 / 9)):
struct.pack_into('<f', initial, 0x2000 + off, value)
struct.pack_into('<Q', initial, 0x2000, BUF + 0x3000)
struct.pack_into('<f', initial, 0x3008, 0.5)
with tempfile.TemporaryDirectory(prefix='patch-v110-', dir=build) as temp:
work = Path(temp)
exe = build_harness(work, bodies, 2, args.cflags)
for k, (name, off, target, kind) in enumerate(SITES):
pc = base + off
for enabled in (0, 1):
for ratio in (1.0, 0.5, 0.25):
for offset in (0, 0x7fffffff, 0x80000000, 0xffffffff):
mem = bytearray(initial)
struct.pack_into('<f', mem, 0x2008, ratio)
struct.pack_into('<f', mem, 0x3008, ratio)
code = words[k][1] if enabled else [words[k][0]]
lo = pc & ~0xffff
text = bytearray((pc - lo) + len(code) * 4)
struct.pack_into('<' + 'I' * len(code), text, pc - lo, *code)
emu = Emu([(lo, text), (table.page, page)])
emu.mu.mem_write(BUF, bytes(mem))
x = [0x1234567800000000 + i for i in range(31)]
for i in (8, 19, 20, 23, 27):
x[i] = BUF + 0x2000
x[25], x[30] = offset, enabled
v = [(0x123456789abcdef << 32) | int.from_bytes(struct.pack('<f', 2.0), 'little')] * 32
v[1] = int.from_bytes(struct.pack('<f', 4.0), 'little')
v[9] = int.from_bytes(struct.pack('<f', 3.0), 'little')
v[10] = int.from_bytes(struct.pack('<f', 4.0), 'little')
v[12] = int.from_bytes(struct.pack('<f', 8.0), 'little')
sp, nzcv = BUF + BUF_SIZE - 0x100, 0xa0000000
ex, esp, enz, epc, ev = emu.run(pc, 0, x, sp, nzcv, v, count=len(code))
assert esp == sp and enz == nzcv
if enabled:
want = {'zero': 0, 'map': 2 * ratio, 'aim': 2 * ratio, 'gyro': 6 * ratio,
'aspect': f32(21 / 9), 'fov': f32(f32(0.9) * f32(1.2))}
if kind in want:
assert math.isclose(scalar(ev[target]), want[kind], rel_tol=1e-6, abs_tol=1e-7), (kind, off)
elif kind == 'offset':
assert ex[target] == offset
elif kind == 'source':
assert ex[target] == x[8] + offset
elif kind == 'shadow':
assert ex[target] == 2055
elif kind == 'cascade':
slot = (64, 68, 72, 76)[(0x1157fb8, 0x1158040, 0x11580c8, 0x115814c).index(off)]
assert ex[target] == struct.unpack_from('<I', page, slot)[0]
# The stack save must preserve the complete x10, not just its lower word.
if name in ('aspect', 'fov'):
assert ex[10] == x[10]
allowed_x = {target} if kind in ('offset', 'source', 'shadow', 'cascade') else {9} if kind == 'map' else set()
# Integer destinations do not authorize writes to the same-numbered SIMD register.
allowed_v = set() if kind in ('offset', 'source', 'shadow', 'cascade') else {0, 1} if kind == 'map' else {target}
if enabled and kind in ('map', 'aim', 'gyro'):
allowed_v |= {16}
if kind == 'map':
allowed_v |= {1}
if enabled and kind == 'fov':
allowed_v |= {8}
assert all(ex[i] == x[i] for i in range(31) if i not in allowed_x)
assert all(ev[i] == v[i] for i in range(32) if i not in allowed_v)
cases, expect = groups[ratio]
cases.append((k, 0, x, sp, nzcv, v, True))
memory = zlib.crc32(emu.mu.mem_read(BUF, BUF_SIZE))
expect.append((ex, esp, enz, epc, ev, memory))
page_path = work / 'page.bin'
page_base = table.page & ~0xffff # Windows reserves at 64 KiB allocation granularity
page_path.write_bytes(bytes(table.page - page_base) + page)
total = 0
for ratio, (cases, expect) in groups.items():
mem = bytearray(initial)
struct.pack_into('<f', mem, 0x2008, ratio)
struct.pack_into('<f', mem, 0x3008, ratio)
records, err = run_harness(exe, work, mem, cases, [(page_base, page_path)])
assert not err and len(records) == len(cases), err
for case, want, got in zip(cases, expect, records):
differences = diff_state(got, want, False, True)
assert not differences, (SITES[case[0]], differences)
total += len(cases)
print(f'v110: {len(SITES)} patch contracts, {total} native/Unicorn cases passed (on and off)')
return 0
if __name__ == '__main__':
sys.exit(main())
+10
View File
@@ -41,6 +41,16 @@ with tempfile.TemporaryDirectory() as tmp:
shadow.mkdir(parents=True)
(shadow / '__init__.py').write_text('# stands in for the PyPI "installer" package: no gui submodule\n')
# The test only means something if this interpreter would put the user site on sys.path without AppRun's
# setting. A venv has no user site, so run it with the system Python; otherwise the shadow is never tried.
probe_env = dict(env)
probe_env.pop('PYTHONNOUSERSITE', None)
probe = subprocess.run([sys.executable, '-c', 'import sys; print(sys.argv[1] in sys.path)', str(user_site)],
env=probe_env, capture_output=True, text=True, cwd=tmp)
assert probe.stdout.strip() == 'True', (
f'user site {user_site} is not on sys.path for {sys.executable}; run this test with the system Python, '
'not a venv, or it cannot catch the shadowing')
bundle = tmp / 'bundle'
(bundle / 'installer').mkdir(parents=True)
(bundle / 'installer' / '__init__.py').write_text('')
+15
View File
@@ -528,7 +528,12 @@ class PromptsTest(unittest.TestCase):
drawn = font(sarc_files(romfs.read(out, DEFAULT_FONT))['scft/External.bfotf'])
advances = icons.font_advances(sarc_files(romfs.contents[DEFAULT_FONT])['scft/External.bfotf'])
pc = icons.pc_icons(icons.text_glyphs(romfs.text_fonts), advances)
text = icons.pc_icons(icons.text_glyphs(romfs.text_fonts), advances, icons.pc_binds(text=True))
self.assertIn(0xE05E, pc) # the left stick's W A S D
# In the font Y is T (PC_TEXT_KEYS); the button guide's Y image below stays the left mouse button
otf = unbfotf(sarc_files(romfs.contents[DEFAULT_FONT])['scft/External.bfotf'])
t = TTFont(io.BytesIO(icons.redraw_font(otf, {0xE043: text[0xE043]})))
self.assertEqual(glyph(drawn, 0xE043)[0], glyph(t, 0xE043)[0])
for cp in range(0xE040, 0xE069):
outline, advance = glyph(drawn, cp)
if cp in pc:
@@ -565,6 +570,16 @@ class PromptsTest(unittest.TestCase):
self.assertEqual({b: panes[f'T_{b}_00'] for b in PC_PANES}, {**PC_PANES, 'A': 'F'})
self.assertEqual(icons.pc_binds(ini.read_text(encoding='utf-8')), {**icons.PC_BINDS, 'A': 'f'})
def test_pc_text_prompts_show_y_as_its_first_key_that_is_not_a_mouse_button(self):
def y(line=None, text=True):
return icons.pc_binds(f'[input]\n{line}\n' if line else None, text=text)['Y']
self.assertEqual((y(), y(text=False)), ('t', 'mouse_l'))
self.assertEqual(y('bind_Y = pad:north, key:mouse_l, key:h'), 'h')
self.assertEqual(y('bind_Y = key:g, key:mouse_l'), 'g')
self.assertEqual(y('bind_Y = key:mouse_l'), 'mouse_l') # no key besides the mouse: the mouse button
self.assertEqual(y('bind_Y = key:default'), 't')
self.assertEqual(y('bind_Y = key:h, key:mouse_l', text=False), 'h')
def test_same_input_same_output_and_the_older_flag(self):
romfs = self.romfs['v121']
for flags in (('--prompts', 'xbox'), ('--xbox-prompts',)):
+252
View File
@@ -0,0 +1,252 @@
"""Run every test in tests/ through one command, and say what each one needed.
The tests were written to be run one at a time (each header says how). This keeps that layout and adds the two
things it lacked: one entry point, and a report that separates a failure from a test that could not run here.
python tests/run_all.py # the ones that need no game files: fast, safe in a loop
python tests/run_all.py --all # also the ones that read game files or a built totk.exe
python tests/run_all.py --only ncz_test,spin_waits_test
python tests/run_all.py --list
Each test declares its interpreter (.venv for the lifter, .venv-py314 for the extraction tools) and what it
needs. A need that cannot be met is SKIP with the reason, never a failure: a missing game dump is not a broken
build. Exit is 0 when nothing failed, 1 when something did.
No third-party imports: this runs before any venv is trusted.
"""
import argparse
import json
import os
import shutil
import subprocess
import sys
import time
import tomllib
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
WIN = os.name == 'nt'
MSYS_BIN = Path(r'C:\msys64\ucrt64\bin') # clang/gcc for flags_check and excl_mt
# The needs that only --all meets: game files, a build, the embeddable Python, a desktop. A compiler (cc) is not one.
GAME_NEEDS = {'exefs', 'exe', 'romfs', 'embed', 'gui'}
def interp(venv):
""".venv / .venv-py314, falling back to this interpreter when the venv is absent."""
d = ROOT / venv
p = d / ('Scripts/python.exe' if WIN else 'bin/python')
return p if p.exists() else Path(sys.executable)
# name: (venv, needs, args, why the need is there)
# needs: None | needs joined by '+' (exefs | exe | romfs | embed | gui | cc)
# name: the script below tests/, without .py (diff/simd is tests/diff/simd.py)
TESTS = {
# ---- no game files, no build ----
'flags_check': ('.venv', None, [], ''),
'excl_mt': ('.venv', None, [], ''),
'pack_shader_cache_test': ('.venv', None, [], ''),
'spin_waits_test': ('.venv', None, [], ''),
'worktree_test': ('.venv', None, [], ''),
'installer_test': ('.venv-py314', None, [], ''),
'ncz_test': ('.venv-py314', None, [], ''),
'romfs_prompts_test': ('.venv-py314', None, [], ''),
'exefs_patches_test': ('.venv', None, [], ''),
'settings_doc_check': ('.venv', None, [], ''),
'mouse_direct_check': ('.venv', 'cc', ['--cc', '<cc>'], 'compiles its checks with clang'),
'cheats_vm_check': ('.venv', 'cc', ['--cc', '<cc>'], 'compiles runtime/cheats.c into a harness with clang'),
'diff/atomic': ('.venv', None, [], ''),
'diff/simd': ('.venv', None, [], ''),
# ---- read the game or a build ----
'diff/lift': ('.venv', 'exefs', ['--exefs', '<exefs>'],
'samples instructions from the game modules; needs an unpacked exefs'),
'diff/func': ('.venv', 'exefs', ['--exefs', '<exefs>'],
'lifts whole functions of the game modules; needs an unpacked exefs'),
'jumptables_check': ('.venv', 'exefs', ['--exefs', '<exefs>'],
'replays the modules through Unicorn; needs an unpacked exefs'),
'mods_romfs_check': ('.venv', 'exe+romfs', ['--exe', '<exe>', '--version', 'v143', '--romfs', '<romfs>'],
'runs the built totk.exe against a mod layout, on the extracted romfs'),
'installer_e2e': ('.venv-py314', 'embed', [],
'the release launcher runs installer on the embeddable Python'),
'installer_gui_test': ('.venv-py314', 'gui', [],
'drives the installer window; needs an interactive desktop'),
}
def load_work_dir():
"""[work] dir from config.local.toml, so a game test finds the extracted files."""
cfg = ROOT / 'config.local.toml'
if not cfg.exists():
return ROOT / 'build'
try:
with open(cfg, 'rb') as f:
d = tomllib.load(f).get('work', {}).get('dir')
return Path(d) if d else ROOT / 'build'
except Exception:
return ROOT / 'build'
def find_exefs():
work = load_work_dir()
for c in (work / 'exefs-v143', work / 'extracted' / 'v143' / 'exefs',
ROOT / 'build' / 'extracted' / 'v143' / 'exefs'):
if (c / 'main').exists():
return c
return None
def find_exe():
"""A built totk.exe: the plain v143 tree, else the newest variant (v143-heropath, ...)."""
if (ROOT / 'build' / 'v143' / 'totk.exe').exists():
return ROOT / 'build' / 'v143' / 'totk.exe'
builds = sorted(ROOT.glob('build/v143-*/totk.exe'),
key=lambda p: p.stat().st_mtime, reverse=True)
return builds[0] if builds else None
def find_romfs():
"""The extracted romfs of v143: its index.json names the real file paths."""
cands = [ROOT / 'build' / 'extracted' / 'v143' / 'romfs', load_work_dir() / 'romfs']
gui = ROOT / 'build' / 'build_gui.json' # the GUI builder remembers where it built from
if gui.exists():
try:
r = json.loads(gui.read_text(encoding='utf-8')).get('romfs')
if r:
cands.append(Path(r))
except Exception:
pass
for c in cands:
if (c / 'index.json').exists():
return c
return None
def find_embed():
for c in (ROOT / 'build' / 'py314-embed',):
if (c / ('python.exe' if WIN else 'bin/python3')).exists():
return c
return None
def find_cc():
"""clang for the tests that compile C: MSYS2 UCRT64's on Windows, else the one on PATH."""
c = MSYS_BIN / 'clang.exe'
if WIN and c.exists():
return c
w = shutil.which('clang')
return Path(w) if w else None
def resolve(needs):
"""({placeholder: what the arg takes}, or the reasons the needs cannot be met here)."""
if needs is None:
return {}, None
vals, missing = {}, []
for need in needs.split('+'):
if need == 'exefs':
p = find_exefs()
if p is None: missing.append('no unpacked exefs (run tools/extract.py)')
else: vals['<exefs>'] = str(p)
elif need == 'exe':
p = find_exe()
if p is None: missing.append('no built build/v143/totk.exe')
else: vals['<exe>'] = str(p)
elif need == 'romfs':
p = find_romfs()
if p is None: missing.append('no extracted romfs index (run tools/extract.py)')
else: vals['<romfs>'] = str(p)
elif need == 'embed':
p = find_embed()
if p is None: missing.append('no build/py314-embed (tools/make_release.py makes it)')
else: vals['<embed>'] = str(p)
elif need == 'cc':
p = find_cc()
if p is None: missing.append('no clang (MSYS2 UCRT64 on Windows)')
else: vals['<cc>'] = str(p)
elif need == 'gui':
missing.append('drives a window; run it by hand on a desktop session')
else:
return {}, f'unknown need {need!r}'
return vals, ('; '.join(missing) if missing else None)
def run_one(name, all_ok, timeout, verbose):
venv, needs, args, why = TESTS[name]
if not (ROOT / 'tests' / f'{name}.py').exists():
return 'SKIP', 0.0, 'not on this branch', ''
if needs is not None and not all_ok and set(needs.split('+')) & GAME_NEEDS:
return 'SKIP', 0.0, f'needs {needs}: {why} (--all)', ''
value, reason = resolve(needs)
if reason:
return 'SKIP', 0.0, reason, ''
argv = [str(interp(venv)), str(ROOT / 'tests' / f'{name}.py')]
for a in args: # fill each placeholder with its need's value
s = a
for k, v in value.items():
s = s.replace(k, v)
argv.append(s)
env = dict(os.environ)
if MSYS_BIN.is_dir(): # flags_check and excl_mt compile C
env['PATH'] = str(MSYS_BIN) + os.pathsep + env.get('PATH', '')
t0 = time.time()
try:
r = subprocess.run(argv, cwd=str(ROOT), env=env, capture_output=True,
text=True, encoding='utf-8', errors='replace', timeout=timeout)
except subprocess.TimeoutExpired:
return 'FAIL', time.time() - t0, f'timed out after {timeout}s', ''
dt = time.time() - t0
out = (r.stdout or '') + (r.stderr or '')
if r.returncode == 0:
return 'PASS', dt, '', out if verbose else ''
tail = '\n'.join(out.strip().splitlines()[-12:])
return 'FAIL', dt, f'exit {r.returncode}', tail
def main():
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
ap.add_argument('--all', action='store_true', help='also run the tests that read game files or a build')
ap.add_argument('--only', help='comma-separated test names')
ap.add_argument('--list', action='store_true', help='list the tests and their needs')
ap.add_argument('--timeout', type=int, default=1800, help='per test, seconds (default 1800)')
ap.add_argument('-v', '--verbose', action='store_true', help='print every test\'s output')
a = ap.parse_args()
if a.list:
for n in TESTS:
venv, needs, _, why = TESTS[n]
print(f'{n:26} {venv:12} {needs or "-":9} {why}')
return 0
names = list(TESTS)
if a.only:
want = [s.strip() for s in a.only.split(',') if s.strip()]
missing = [w for w in want if w not in TESTS]
if missing:
print(f'unknown test(s): {", ".join(missing)}', file=sys.stderr)
return 2
names = want
print(f'{len(names)} test(s), cwd {ROOT}')
rows, failed = [], 0
for n in names:
status, dt, note, out = run_one(n, a.all, a.timeout, a.verbose)
failed += status == 'FAIL'
rows.append((n, status, dt, note))
line = f' {status:4} {n:26} {dt:6.1f}s'
print(line + (f' {note}' if note else ''))
if out:
print('\n'.join(' ' + s for s in out.splitlines()))
print()
counts = {k: sum(1 for r in rows if r[1] == k) for k in ('PASS', 'FAIL', 'SKIP')}
print(f'{counts["PASS"]} passed, {counts["FAIL"]} failed, {counts["SKIP"]} skipped')
if failed:
print('failed: ' + ', '.join(r[0] for r in rows if r[1] == 'FAIL'))
return 1 if failed else 0
if __name__ == '__main__':
sys.exit(main())
+20 -4
View File
@@ -187,8 +187,10 @@ LLVM_LINK_LIBS = ['-lpsapi', '-lbcrypt', '-luser32', '-lgdi32', '-ldwmapi', '-li
DEFAULT_DEPS = ROOT / 'toolchain' / 'deps-mingw'
# Runtime sources compiled per install, not in the library: romfs.c includes romfs_config.h, patches.c and ov_zstd.c
# the patches.h of the player's game version (its patch page is the page after that version's main; ov_zstd.c's host
# functions sit on it). mouse_direct.c also registers host callbacks relative to that version's patch page.
INSTALL_SIDE = {'romfs.c', 'patches.c', 'ov_zstd.c', 'mouse_direct.c'}
# functions sit on it). mouse_direct.c and ov_ability.c also register host callbacks relative to that version's patch
# page. A library source that includes one of PER_VERSION_HEADERS stops the library build (library_sources).
INSTALL_SIDE = {'romfs.c', 'patches.c', 'ov_zstd.c', 'mouse_direct.c', 'ov_ability.c'}
PER_VERSION_HEADERS = ('"patches.h"', '"romfs_config.h"')
LIB_NAME = 'libtotkrt.a'
AR = UCRT / 'llvm-ar.exe' if WIN else on_path('llvm-ar')
WINDRES = UCRT / 'windres.exe' # runtime/totk.rc: the manifest of totk.exe
@@ -324,6 +326,19 @@ def runtime_sources(skip=()):
return sorted(p for pat in pats for p in RUNTIME.glob(pat) if p.name not in skip and not other_os(p.name))
def library_sources(sources):
"""The runtime sources of libtotkrt.a: all but INSTALL_SIDE. The library is built once per release from one game
version's generated headers, so a source that includes a per-version header there bakes that version's addresses
into every install: a host function on the 1.2.1 patch page lies inside 1.4.3's sdk and the game stops at start."""
lib = [p for p in sources if p.name not in INSTALL_SIDE]
baked = [p.name for p in lib if p.suffix in ('.c', '.cpp')
and any(h in p.read_text(encoding='utf-8', errors='replace') for h in PER_VERSION_HEADERS)]
if baked:
sys.exit(f'build_game: library sources with a per-version header ({", ".join(PER_VERSION_HEADERS)}): {", ".join(baked)}; '
'add them to INSTALL_SIDE')
return lib
def install_stamp(out, runtime_lib):
"""Write obj/runtime/inputs.sha256, one hash over the runtime library, the INSTALL_SIDE sources and every runtime
header, and return its path. The release zip dates every file 1980-01-01 (make_release.py write_zip), so a new
@@ -451,7 +466,7 @@ def ninja_file(gen, out, mods, pool_depth, skip=(), prebuilt=False, runtime_lib=
rt = []
sources = runtime_sources(skip)
if make_lib:
sources = [p for p in sources if p.name not in INSTALL_SIDE]
sources = library_sources(sources)
elif runtime_lib:
sources = [p for p in sources if p.name in INSTALL_SIDE] + [out / 'modules.c']
else:
@@ -986,7 +1001,8 @@ def main():
code, dt, peak_one, _ = run_measured(base + [flag_path(exe)], env)
print(f'link: {dt:.1f} s, peak {mib(peak_one)}')
if code:
print(f'build_game: link failed, {flag_path(exe)} is the old one (a running totk.exe from this dir locks it)',
print(f'build_game: link failed, {flag_path(exe)} is the old one (a running totk.exe from this dir, or an '
f'antivirus that holds the file, locks it)',
file=sys.stderr)
sys.exit(code)
if args.make_runtime_lib:
+17 -6
View File
@@ -18,7 +18,9 @@ start, MacNativeGames found).
The button guide in play (bottom right) draws its buttons, L and ZL among them, from images of the common layout
archive instead (timg/__Combined.bntx, Nt_KeyTexL_00 and Nt_KeyTexZL_00): bntx_redraw paints the same icons into them,
the size unchanged. The Xbox prompts redraw L and ZL, the keyboard and mouse ones every image (PC_HUD_TEXTURES: A, B, X,
Y, L, ZL and the stick's two). Prompts drawn as fixed images (some tutorial animations) keep the Switch icons.
Y, L, ZL and the stick's two) with the keys of pc_binds. The font's glyphs use pc_binds(text=True): a text prompt shows
Y as T, the button guide the left mouse button. Prompts drawn as fixed images (some tutorial animations) keep the
Switch icons.
Needs fontTools (tools/requirements-installer.txt, tools/requirements-py314.txt).
"""
@@ -212,12 +214,18 @@ PC_HUD_TEXTURES = {'Nt_KeyTexA_00': 0xE040, 'Nt_KeyTexB_00': 0xE041, 'Nt_KeyTexX
'Nt_KeyTexL_00': 0xE044, 'Nt_KeyTexZL_00': 0xE046, 'Nt_KeyTexLSt_00': 0xE052,
'Nt_KeyTexLSt_01': 0xE05E}
PC_MOUSE = ('mouse_l', 'mouse_r', 'mouse_m')
# The text prompts (the button font: the menus' guides, the dialogue log's) show Y as T, the key runtime/input_map.c
# binds next to the left mouse button: while a game menu has the pointer the left button is that menu's A
# (runtime/menu_cursor.c), and T presses Y everywhere. The button guide in play and the action prompt keep the left
# button (PC_BINDS), which attacks there.
PC_TEXT_KEYS = {'Y': 't'}
def pc_binds(ini_text=None):
def pc_binds(ini_text=None, text=False):
"""PC_BINDS with the first key of each bind_<action> line of a totk.ini text over it (a line without a key entry,
or with key:default, keeps the default)."""
binds = dict(PC_BINDS)
or with key:default, keeps the default). text: the binds the button font is drawn with, where a button of
PC_TEXT_KEYS shows its first key that is not a mouse button (PC_TEXT_KEYS's without a line)."""
binds = dict(PC_BINDS, **(PC_TEXT_KEYS if text else {}))
for line in (ini_text or '').splitlines():
line = line.split('#')[0].split(';')[0].strip()
if not line.lower().startswith('bind_') or '=' not in line:
@@ -225,8 +233,11 @@ def pc_binds(ini_text=None):
action, value = (s.strip() for s in line.split('=', 1))
keys = [e.strip()[4:].strip().lower() for e in value.split(',') if e.strip().lower().startswith('key:')]
keys = [k for k in keys if k != 'default']
if keys and action[5:].upper() in binds:
binds[action[5:].upper()] = keys[0]
button = action[5:].upper()
if text and button in PC_TEXT_KEYS:
keys = [k for k in keys if not k.startswith('mouse_')] or keys
if keys and button in binds:
binds[button] = keys[0]
return binds
+6 -4
View File
@@ -11,7 +11,7 @@ cached in toolchain/release-dl/ and checked against the sha256 in PINS; a mismat
the installer is never run)
llvm/ llvm-mingw, x86_64 only, the files clang and lld need to compile and link totk.exe
runtime/ libtotkrt.a and libtotkrt-v2.a (build_game.py --make-runtime-lib with llvm/, x86-64-v3 and v2), the
runtime headers, romfs.c, patches.c and ov_zstd.c (compiled per install), deps/ (headers and import
runtime headers, the INSTALL_SIDE sources of build_game.py (compiled per install), deps/ (headers and import
libraries of SDL3, Opus, libvpx, Vulkan and VMA)
bin/ totk_xlate.exe (+ .id), hactool.exe, SDL3.dll (upstream), libopus-0.dll, ninja.exe
recomp/, tools/, data/, installer/, licenses/, THIRD_PARTY_NOTICES.md, totk.ini.example
@@ -168,10 +168,12 @@ def fetch(name):
def unpack(name, member_filter=None):
"""Extract a pinned archive into toolchain/release-work/<name> (once) and return that directory."""
"""Extract a pinned archive into toolchain/release-work/<name> and return that directory. The stamp holds the pin's
sha256, so a bumped pin unpacks its new archive instead of reusing the old one's files."""
dest = WORK / name
stamp = dest / '.unpacked'
if stamp.is_file():
key = PINS[name][1]
if stamp.is_file() and stamp.read_text() == key:
return dest
shutil.rmtree(dest, ignore_errors=True)
dest.mkdir(parents=True)
@@ -182,7 +184,7 @@ def unpack(name, member_filter=None):
else:
with tarfile.open(path) as t:
t.extractall(dest, filter='data')
stamp.write_text('')
stamp.write_text(key)
return dest
+6 -4
View File
@@ -15,7 +15,7 @@ the .NET 10 SDK and Python 3.12+ with Pillow (.venv). The folder holds:
llvm/ LLVM 23 (clang, lld, llvm-ar, the clang resource headers) and llvm/sysroot: the files of the sniper SDK
sysroot the game's compile and link read, nothing else (recorded while building the runtime library)
runtime/ libtotkrt.a and libtotkrt-v2.a (build_game.py --make-runtime-lib --sysroot, x86-64-v3 and v2), the
runtime headers, romfs.c, patches.c and ov_zstd.c (compiled per install), totk.png (the window icon),
runtime headers, the INSTALL_SIDE sources of build_game.py (compiled per install), totk.png (the window icon),
deps/ (Vulkan headers 1.4.363, VMA, zstd built static; SDL3, Opus and libvpx come from the sysroot)
bin/ totk_xlate (+ .id), hactool, ninja, libSDL3.so.0 (the sysroot's; the game finds it beside itself)
recomp/, tools/, data/, installer/, licenses/, THIRD_PARTY_NOTICES.md, totk.ini.example, VERSION
@@ -103,9 +103,11 @@ def run(cmd, **kw):
def tar_extract(name, dest, members, strip=0):
"""Extract only members (path prefixes inside the archive) of a pinned tarball with the system tar, once."""
"""Extract only members (path prefixes inside the archive) of a pinned tarball with the system tar. The stamp holds
the pin's sha256 and the members, so a bumped pin or a changed member list extracts again."""
stamp = dest / '.unpacked'
if stamp.is_file():
key = '\n'.join((mr.PINS[name][1], str(strip), *members))
if stamp.is_file() and stamp.read_text() == key:
return dest
shutil.rmtree(dest, ignore_errors=True)
dest.mkdir(parents=True)
@@ -114,7 +116,7 @@ def tar_extract(name, dest, members, strip=0):
run(['tar', '-xf', path, '-C', dest, f'--strip-components={strip}', '--wildcards', '--no-wildcards-match-slash',
*members])
print(f'{name}: unpacked in {time.time() - t0:.0f} s')
stamp.write_text('')
stamp.write_text(key)
return dest
+10 -5
View File
@@ -43,8 +43,10 @@ romfs-patches-xbox-label-<w>x<h>: the same prompts with that shape's UI layout.
--prompts pc: keyboard and mouse prompts, for prompts = pc (romfs-patches-pc, or romfs-patches-pc-<w>x<h> with
--aspect): every button of the button font is drawn as the key or mouse button the keyboard defaults put on it
(button_icons.pc_icons; --binds <totk.ini> takes the first key of its bind_ lines instead), and so are the button
guide's images (A, B, X, Y, L, ZL and the stick's two). The one-letter panes around the action prompt name the keys
with one character of the Normal font (E, an arrow for Shift, a bar for Space, L and R for the mouse buttons).
guide's images (A, B, X, Y, L, ZL and the stick's two). In the font Y is T, the key that presses it next to the left
mouse button, which is A in the game's menus (button_icons.PC_TEXT_KEYS); the button guide keeps the left button. The
one-letter panes around the action prompt name the keys with one character of the Normal font (E, an arrow for Shift,
a bar for Space, L and R for the mouse buttons).
--reuse <folder>: an overlay made before, such as romfs-patches-pc for romfs-patches-pc-<w>x<h>. Each file of it whose
contents match the new one is hard-linked (copied where links fail) instead of compressed again; the summary's reused
@@ -403,12 +405,15 @@ if args.prompts:
assert not missing, f'no {", ".join(missing)} in {icons.TEXT_ARCHIVE}'
glyphs = icons.text_glyphs(archives[icons.TEXT_ARCHIVE][slice(*text[name])] for name in icons.TEXT_FONTS)
if pc:
binds = icons.pc_binds(args.binds.read_text(encoding='utf-8', errors='replace') if args.binds else None)
ini = args.binds.read_text(encoding='utf-8', errors='replace') if args.binds else None
binds = icons.pc_binds(ini)
advances = icons.font_advances(archives[icons.TEXT_ARCHIVE][slice(*text[icons.FONT])])
drawn = icons.pc_icons(glyphs, advances, binds)
# The text prompts show Y as T (button_icons.PC_TEXT_KEYS); the button guide's images keep the left click
font_drawn = icons.pc_icons(glyphs, advances, icons.pc_binds(ini, text=True))
pane_letters = {letter: icons.pc_letter(binds[letter]) for letter in 'ABXY'}
else:
drawn = icons.xbox_icons(glyphs)
drawn = font_drawn = icons.xbox_icons(glyphs)
pane_letters = KEY_LETTERS
bntx = members['timg/__Combined.bntx'][0]
letters = {}
@@ -431,7 +436,7 @@ if args.prompts:
lo, hi = sarc_members(bfarc)[icons.FONT]
otf, key = icons.bfotf_decode(bfarc[lo:hi])
if otf not in fonts:
fonts[otf] = icons.redraw_font(otf, drawn, KEY_GLYPHS if by_position else ())
fonts[otf] = icons.redraw_font(otf, font_drawn, KEY_GLYPHS if by_position else ())
outputs[path] = sarc_replace(bfarc, {icons.FONT: icons.bfotf_encode(fonts[otf], key, bfarc[lo:hi])})
messages = {}
for path in MALS if letter_panes else []:
+58 -3
View File
@@ -26,10 +26,12 @@
# cloth_realtime = 1
# Fix for physics that bounce at high frame rates.
# highfps_fix = 1
# Climbing walls and ladders at full speed above 60 fps; 30 and 60 fps are unchanged. Needs realtime = 1.
# climb_fix = 1
[performance]
# The keys of this section and of [diagnostics] are for testing and troubleshooting, and take effect at the next start.
# The Advanced tab of the settings menu (F1) shows all of them except zstd_native and zstd_check.
# The Advanced tab of the settings menu (F1) shows all of them except zstd_native, zstd_check and the crash guards.
# Scheduling.
# A thread waiting for a virtual core interrupts the owner when it runs game code: 1 = on, 2 = priority inheritance
@@ -101,6 +103,14 @@
# zstd_native = 1
# zstd_check = 0
# Crash guards: game code that crashes on stale data skips it instead (0 = the game's own code).
# An optional reference holding an invalid value is treated as absent.
# optref_guard = 1
# A Recall or Ultrahand target the game would crash on is skipped for that frame.
# ability_guard = 1
# A model scene report row with an out-of-range index is skipped for that frame (1.4.3 only).
# report_guard = 1
# Render fixes.
# Wait for the game to finish rewriting level-of-detail data before the GPU reads it: stops objects flashing in the
# wrong place and a flat far field for a frame.
@@ -198,7 +208,7 @@
# does. Read when a movie starts, so a change takes effect at the next movie.
# movie_aspect = keep
# Field of view, in percent of the game's own: 70 to 140, 100 (the default) leaves the camera as it is. Higher shows
# more of the world around Link. Game version 1.4.3 only. Changes while the game runs take effect at once.
# more of the world around Link. Game versions 1.1.0 and 1.4.3. Changes while the game runs take effect at once.
# fov = 100
# Anisotropic filtering of surface textures: game (the level the game asks for, as on the Switch) or 2, 4, 8, 16. Keeps
# ground, roads and walls seen at a shallow angle sharp into the distance. Only filtered, mipmapped textures that tile
@@ -226,6 +236,11 @@
# Sun shadow cascade range in percent of the game's (its cascades end at 20, 40, 80 and 160 m), 50 to 400: higher moves
# the steps where shadows turn softer further away, and spreads the shadow map over more ground. Read at start.
# shadow_range = 100
# How far around the camera grass grows, in percent of the game's (its near grass map covers 62.5 m), 50 to 400.
# Higher keeps the grass in meadows further out instead of growing it in a short way in front of you, and draws more of
# it; the grass map's textures grow with it, so its detail per metre stays the game's, and the grass heap grows by about
# 9 MiB times (percent / 100)^2 - 1. Lower draws less grass. Read at start.
# grass_range = 100
# Screen-space contact shadows, strength in percent (0 = off): after the game lights its scene, each pixel traces a
# short way toward the sun through the depth buffer and darkens where something close blocks it, adding the small
# shadows at feet, under stones and in grass that the shadow maps miss. Read at start.
@@ -259,6 +274,9 @@
# frame before, DLSS is told to favour the current frame by this percentage (0, 35, 65 or 100; 0 off). Higher removes
# more of the trails and leaves those edges a little less smooth. Changes while the game runs take effect at once.
# dlss_char_mask = 65
# NVIDIA Reflex Low Latency (NVIDIA GPUs supporting VK_NV_low_latency2): off, on, or boost.
# Reduces system input latency; boost keeps GPU clocks high in CPU-bound scenes. Read at start.
# reflex = off
# The game's own FXAA after the post effects; with DLAA on it is not needed. Changes while the game runs take effect at
# once.
# fxaa = 1
@@ -273,7 +291,7 @@
# hdr_ui_nits = 203
# Highlight hue correction in percent (0 to 100): bright colours such as fire turn towards white as in the game's SDR
# picture, matching the light they cast; 0 keeps them fully saturated. Changes take effect at once.
# hdr_hue = 80
# hdr_hue = 70
[language]
# Language: a Windows locale such as de-DE, or a Switch code (en-US, ja, zh-Hant, ...). Default: the Windows locale.
@@ -304,6 +322,12 @@
# audio_prefill_ms = 20
# Volume in percent (0 to 100), on top of the game's own. Changes while the game runs take effect at once.
# volume = 100
# Music, sound effects and voices (characters, creatures, Link) in percent, on top of volume. Live like volume. Below
# 100 the port tells the three apart by the sound files the game loads; a value moved during play reaches sounds
# loaded after the change at once and earlier ones by their next stream read, the rest count as effects.
# volume_music = 100
# volume_sfx = 100
# volume_voice = 100
# Speakers: stereo, 5.1 or auto (5.1 when the Windows speaker setup has six or more channels, stereo otherwise). The
# game is told the same channel count and mixes for it. Takes effect at the next start.
# audio_channels = stereo
@@ -348,6 +372,21 @@
# right click is B. On the map the mouse moves the map's cursor and the scroll wheel zooms. 0 leaves the menus and
# the map to the keys and the pad. Changes while the game runs.
# menu_cursor = 1
# The left mouse button on the Purah Pad's map, 1.4.3 only. 1: it presses A at the map's cursor instead of the button
# it is bound to (Y by default). Needs menu_cursor = 1, which finds the map. 0 (the default) leaves the left button on
# its binding there, one key per controller button. Changes while the game runs.
# map_click = 0
# The mouse buttons in dialogue, 1.4.3 only. 1: while a dialogue box is open left click presses B (it continues the
# text and skips its scroll) and right click presses A, instead of their bindings (Y by default, which opens the
# dialogue log, and ZL). Dialogue choices keep the pointer, where left click picks. Works with menu_cursor = 0 too. The
# clicks stay B and A for half a second after a box closes, as the game closes the box between two lines of a
# conversation. 0 (the default) leaves both buttons on their bindings there, one key per controller button. Changes
# while the game runs.
# dialogue_click = 0
# The mouse pointer over the game window while the cursor is not captured (the game's menus, the settings menu, after
# Esc). 1: a gold arrowhead with a dark edge and a turquoise gem, drawn by the port at the window's DPI, instead of
# the system arrow. 0 (the default) keeps the system arrow. Changes while the game runs.
# pointer_image = 0
# Mouse camera sensitivity (0 to 10; 0 = no mouse camera and no cursor capture). With mouse_mode = direct, 1 turns the
# camera 0.08 degrees per count, the same in every camera mode (about 14.3 cm a turn at 800 DPI).
# mouse_sens = 1
@@ -412,6 +451,22 @@
# Default: shared-fonts next to totk.exe. TOTK_SHARED_FONTS overrides it.
# shared_fonts =
# Gameplay Tweaks: independent live switches.
[gameplay tweaks]
# gameplay_tweaks_enabled = 0
# gameplay_ultrahand_rotate = 1
# gameplay_ultrahand_c_axis = 1
# gameplay_ultrahand_distance = 1
# gameplay_weapon_wheel = 1
# gameplay_weapon_sensitivity = 1
# gameplay_item_wheel = 1
# gameplay_item_ad = 1
# gameplay_map_zoom = 1
# gameplay_map_zoom_sensitivity = 1
# gameplay_rotation_sensitivity = 1
# gameplay_distance_sensitivity = 1
# gameplay_item_sensitivity = 1
[cheats]
# One line per cheat of the mods' cheat files, mods\<mod>\cheats\<build id>.txt (docs/cheats.md); the Cheats tab of
# the menu writes them. cheat_<hash> = 1 switches a cheat on, the hash being FNV-1a 32 of "<mod folder>/<cheat name>".