WIP: fix(vk): the fixed shares' fallback upscale gets an edge pass and FSR 1 EASU #1552

Draft
zeldaootr wants to merge 3 commits from zeldaootr/Longshot:vk-fallback-upscale-aa into main
Contributor

Type: fix · Risk: medium · Tested on: Linux, Steam Deck OLED (RADV VANGOGH) · Needs: Windows, an AMD or Intel GPU

TL;DR

At Render resolution 50% on a Steam Deck (what Minimum and Auto pick there) the game's picture had no anti-aliasing at all. The game's own upscaler for that size can't run on the Deck, so its stand-in just stretched the small picture: every edge became a 2-pixel staircase and every bright speck a square. This PR smooths the edges at the small size first, then enlarges the picture with AMD's edge-following FSR 1 upscaler. On a Deck the outlines are continuous and calm in motion, with no new artefact in three areas, at 0.52 ms of GPU a frame and no fps cost that could be measured.

Breakdown

  • Who it helps: players with the game's own upscaler at Render resolution 50% or 67% on a GPU where the game's network for that size can't run: the Steam Deck (on defaults), desktop AMD and Intel GPUs, GTX 10 cards.
  • What was wrong: the stand-in for those networks was a plain stretch of the small picture, with no anti-aliasing.
  • What changes: the stand-in runs FXAA on the small picture, then FSR 1 EASU to the screen's size.
  • What does not change: 75% and 100%, Upscaler Off, the temporal upscalers when they draw, PCs that run the game's networks, saves, settings and the shader cache.
  • How it was checked:
    • three game-free checks that fail on main;
    • 21 runs on a Steam Deck against main: outlines continuous, nothing new in Kokiri Forest, Hyrule Field or the Market;
    • the new pass costs 0.52 ms of GPU a frame;
    • fps unchanged within the runs' spread.
  • What is still open: Windows; desktop AMD, Intel and GTX 10 cards; outputs above 1280x720.
  • Risk: medium: the picture changes at 50% and 67% on every GPU that leaves those networks out.

Why

At Render resolution 50% on a Steam Deck the edges look hard and stair-stepped, with bright specks along Link's hat and on the grass that crawl as the camera moves. 50% is what the Minimum preset sets and what Auto picks on a Deck, so that is every Deck player on defaults.

The game draws the 3D at a fixed share of the screen and enlarges it with a network of its own for each share: 67%, 58%, 50% and 33% each have one. These networks need cooperative matrices, and the renderer leaves them out (vk_shader.cpp) in these cases:

  • every GPU that is not NVIDIA's: the Steam Deck, desktop AMD on Windows and Linux, Intel's integrated GPUs and Arc;
  • a GPU whose matrix multiplies run in software;
  • one without f16 shaders: GTX 10, and Polaris on RADV;
  • RX_VK_NO_F16.

On an NVIDIA RTX card the movie networks' linear rule also takes them:

  • once movie_networks_slow trips (a frame over 40 ms of GPU in under 40 draws);
  • with RX_VK_MOVIE_UPSCALE=linear;
  • with RX_VK_FORCE_UPSCALE_STUB.

There, with the game's own upscaler, upscale_stub's generic fallback stretched the small picture linearly with no anti-aliasing. At 75% a different network is replaced by a stand-in that does run FXAA, which is why 75% looks better.

Which shares a player can reach on this path: with the game's own upscaler the Render resolution row offers Auto, 100%, 75%, 67% and 50% (upscaler_rows.h kGameSteps), on every output size and OS. 58% and 33% are not offered with it:

  • a saved resolution=5 or =6 is snapped to 50% at start (snap_render);
  • a live set answers no step reaches 5 on this PC (host/control.c);
  • Auto's 33% rule for a 4-thread integrated GPU snaps to 50% the same way.

58% and 33% are steps of DLSS, FSR 3.1, FSR 4 and XeSS (and 33% of Off), whose own paths draw the picture. So this PR changes what players see at 67% and 50%. The 58% and 33% keys stay in the list for the one case that still reaches this fallback: a temporal upscaler at those shares that fails to draw a frame (temporal_rejected_network returns false), which would otherwise get the plain stretch. That case was not run.

This fixes edges, not resolution: Render 75% still shows more texture detail inside the hat and the plants, because it draws 2.25x the pixels.

See #275: an RX 570 on this same fallback at 50%, with bright dots on hair and foliage.

How to reproduce

Seen on: SteamOS 3.9.5, Steam Deck OLED, RADV VANGOGH, Mesa 26.2.0-devel
Settings and switches: Render resolution 50%, Upscaler the game's own (the Minimum preset, or Auto on a Deck); 1280x720
Steps: load a child save in Kokiri Forest and look at Link's hat and the ferns against the path, standing, then turning the camera
Expected: anti-aliased edges, as at Render 75%
Actual: on main, outlines are dashed lines of 2x2 blocks, with bright 2x2 specks. The log has vk: program 72ba090c70fe2614 not translated: a network left out on this card and vk: typed upscale helper generic RGB9E5 fallback, packed output; RX_VK_TAAU_FXAA=2 marks no pixel at 50%.

What changed

When a fixed share's network is left out, its output is now drawn in two compute passes: FXAA on the input's texel centres at the Render resolution, then AMD FSR 1 EASU up to the output's size.

EASU runs only up to 2x a side, the largest ratio AMD's FSR 1 integration guide has a mode for (Performance, 2.0x per dimension): 67% (1.5x), 58% (1.72x) and 50% (2x). 33% (3x) gets the FXAA pass and the linear stretch, and the log says so once.

Every other program that reaches the same fallback is drawn as before.

  • renderer: gpu/vk/vk_draw.cpp.
    • fixed_share_network() names the four keys: 67% 6676619641320ba7, 58% f10782f9e58b6a7c, 50% 72ba090c70fe2614, 33% 0775215f8da720e6. The 33% key at 1280x720 was confirmed on the Deck with Upscaler Off.
    • upscale_stub calls fixed_share_upscale() for them before typed_upscale.
    • These keep typed_upscale as before:
      • the 3/4 (fd029a317a9a4b94) and full-size (9dc98871eb7fc101) networks;
      • every other program;
      • a failed pipeline;
      • an image that cannot be made.
    • fixed_share_upscale():
      • its own pipeline and push descriptors;
      • an RGBA16F image of the input's size: made once, made again at a new size with the old one given back 120 presents later, logged when made; one that cannot be made is logged once and not retried at that size;
      • a transition to GENERAL at creation;
      • stage 0 writes the image, a compute write to sampled-read barrier, then stage 1 reads it and writes the output;
      • every binding a valid image in both dispatches;
      • EASU's constants from AMD's ffxFsrPopulateEasuConstants;
      • each dispatch in an RX_VK_PASS_TIMING span of its own name.
  • shader: gpu/vk/shaders/fixed_share_upscale.comp, with fixed_share_upscale_comp_spv.h generated by glslang 16.6.0.
    • The input is the network's: the square root of the scene colour.
    • Stage 0 runs the 3/4 stand-in's FXAA (the same thresholds) on texel centres.
    • Stage 1 runs EASU from third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h (MIT), included unchanged, then squares the result back into the R11G11B10 output.
    • EASU's deringing holds each result between its four nearest texels. A non-finite result takes the linear sample, and the value is clamped at 0 before the square.
  • switches: gpu/vk/switches.def.
    • New kill row RX_VK_FIXED_SHARE_EASU.
    • RX_VK_TAAU_FXAA's row now says it covers this pass too, so the 3/4 stand-in's FXAA and this one can't be turned off apart.
  • tests:
    • tests/test_fixed_share_upscale.py: the passes with Vulkan spies and their spans, both switches, the 3x case, an image that cannot be made, and the four keys against the same keys a bit off.
    • tests/test_fixed_share_upscale_shader.py: header against source, spirv-val, the shader's shape.
    • tests/test_upscale_fallback.py: each of the four keys takes the new path; 50%'s key a bit off does not.
  • docs:
    • docs/development.md, beside the TAAU replacement's paragraph;
    • README.md's credits name FSR 1 beside FSR 3.1 and FSR 4;
    • 21 files in docs/tested/, one per measured run.

Measurements

Verdict: the fix holds on a Steam Deck. At 50% and 67% the outlines are continuous, with no 2x2 blocks, and calm while the camera turns. Navi, the fairies, the fireflies and the HUD are unchanged, and the Market and Hyrule Field show no halo, ring or fringe. The new passes cost 0.52 ms of GPU a frame in Hyrule Field, and no fps cost is resolved in any of the three areas. Both switches off is main's path exactly.

Hardware: Steam Deck OLED, SteamOS 3.9.5 (20261023.100), RADV VANGOGH Mesa 26.2.0-devel, GPU clock manual 1600 MHz; AMD Custom APU 0932, 16 GB
Scene: Kokiri Forest (child save's spot), Hyrule Field (night arrival, camera turned), the Market entrance; 1280x720, Render 50% (and 67%), the game's own upscaler, Lanczos window filter, Sharpness 50, frame generation off, no cap; headless
Method: presents per second over a 90 s standing sample (the control bridge's replayed), Kokiri interleaved A B B A B A A B, median; GPU time from RX_VK_PASS_TIMING=1 (four 600-present reports inside the sample); stills after the window pass and four consecutive presents of a camera turn; RX_VK_TAAU_FXAA=2 marks counted on the bridge shots
How to reproduce: this PR's two code commits on main 8e3dfde6e (00eaca4aa, branch aa-final-on-8e3dfde6; the same code as this PR's head) as a renderer pack (scripts/dev_packs.py), against that main's own renderer, with the settings above

Before: main @ 8e3dfde6e After: this PR @ 00eaca4aa After, RX_VK_TAAU_FXAA=0 RX_VK_FIXED_SHARE_EASU=0: this PR @ 00eaca4aa
Kokiri 50%, fps, median (range) 18.82 (18.39-19.12), 4 runs 19.44 (17.71-20.98), 4 runs 21.30, 1 run
Kokiri 67%, fps 19.93, 1 run 18.62, 1 run
Hyrule Field 50%, fps 40.11, 1 run 39.82, 1 run
Market 50%, fps 14.52, 1 run 14.90, 1 run
Field 50%, GPU ms a frame in timed spans 10.71-10.73 11.08-11.12
Field 50%, the new passes none 0.518 ms a frame: FSR 1 EASU 0.469 ms (469 us a pass), FXAA ~0.05 ms
RX_VK_TAAU_FXAA=2 marks, 50% / 67% / 75% (red+blue) 37+0 / 37+0 / 11,637+4,250 1,802+517 / 2,846+986 / 11,411+3,696
RGBA16F image made lines none one per Render size used (1 at 50%; 2 with 67%), never per frame none
Path in the log typed upscale helper fixed shares' upscale: FXAA ... then FSR 1 EASU, no helper typed upscale helper (main's)
  • fps: the Kokiri runs drift between 18 and 21 fps by themselves; the scene is CPU-bound. B0, main's path, ran fastest of all. So no cost and no gain is resolved.
  • GPU time: in the Field the timed frame is 0.36-0.39 ms longer. The new passes are 0.52 ms; the plain stretch they replace sat inside other spans.
  • Marks: at 50%/67% they are drawn at the Render size and then stretched, so they are not comparable with 75%'s. A's 37 pure-red pixels are the hat's berries. 75% is unchanged (−1.9% red, −13% blue, within the run-to-run bar).
vk: program 72ba090c70fe2614 not translated: a network left out on this card
vk: fixed shares' upscale: FXAA at the Render resolution, then FSR 1 EASU
vk: fixed shares' upscale: its 640x360 RGBA16F image made (1800 KB)
vk:   0.469 ms  ... fixed shares' upscale: FSR 1 EASU      (gtB-1, Hyrule Field, each 600-present report)

The PR's base: the Deck build is these commits backported onto main 8e3dfde6e, because the Deck's base and caches are at that commit. Between 8e3dfde6e and this PR's base, these commits touch the upscale path:

  • #718 (the full-size network through the same fallback at 100%: not one of the four keys, so it doesn't reach this pass);
  • #1464 (FSR 3.1 frame generation notes upscale_stub's output picture: no change to what is drawn);
  • #1309 (the switch table: the reason the backport leaves out the switches.def rows).

None changes how the fixed shares reach upscale_stub or what it draws for them, so the numbers carry over.

How this design was chosen (a prototype, not this build):

  • On the same Deck and rows, the 3/4 stand-in's FXAA simply added to the fallback barely changed the picture. It runs once per screen pixel, so the four screen pixels of one small texel move independently.
  • A prototype with a switch for each part then compared the options in one session:
    • FXAA at the small size, then a linear stretch: soft;
    • the same, then FSR 1 EASU: crisp and continuous, the closest to Render 75%, cleaner than FSR 3.1 at 50%;
    • a speck clamp before it: held no pixel, so it was dropped.
  • This PR is the EASU variant; on lavapipe its output is byte-identical to that prototype mode.

What it costs where it was not measured

  • Desktop AMD (Windows and Linux), Intel Arc and integrated, GTX 10, Polaris on RADV, at Render 50% or 67% with the game's own upscaler: the picture changes there too, from a plain stretch to this. Not run on any of them.

  • GPU time at larger outputs: EASU's cost grows with the output. It measured 0.47 ms at 1280x720 on the Deck at 1600 MHz:

    Output Pixels vs 1280x720
    2048x1152 2.6x
    2560x1440 4x
    3840x2160 9x

    It is unmeasured on any of them, and on a weak integrated GPU at 1080p least of all.

  • Memory: the intermediate RGBA16F image has the Render resolution's size; briefly two exist during a size change.

    Render resolution Measured on the Deck Computed
    640x360 (50% of 1280x720) 1800 KB
    854x480 (67% of 1280x720) 3202 KB
    1024x576 (50% of 2048x1152) 4608 KB
    ~1372x772 (67% of 2048x1152) about 8,300 KB

Flags and settings

One switch added, one row's text changed.

Flag What it is Before this PR After this PR Effect Helps / doesn't help / untested Recommendation
RX_VK_FIXED_SHARE_EASU (new, kill) the stretch of the fixed shares' fallback (none: linear) on (unset) =0: linear stretch after the edge pass helps on the Steam Deck; untested on desktop GPUs on for everyone
RX_VK_TAAU_FXAA FXAA in the 3/4 stand-in, now also this edge pass 1 1 =0 leaves both out; =2 marks moved pixels as above on (1)

Both off gives main's plain stretch through typed_upscale (measured on the Deck: the same path and picture). Documented in docs/development.md.

Testing

Tested:

  • On my own Steam Deck OLED, in the game (2026-11-18), 21 runs against main at 1280x720 with the game's own upscaler (files in docs/tested/):
    • Kokiri Forest at 50%, A B B A B A A B (gA-1..4, gB-1..4);
    • both passes off (gB0-1);
    • 67% (gA67-1, gB67-1);
    • the marks at 50/67/75% (gxA-1, gxB-1);
    • 2048x1152 at 50% (gA1152-1, gB1152-1);
    • Hyrule Field (gFA-1, gFB-1) and the Market (gMA-1, gMB-1);
    • RX_VK_PASS_TIMING=1 in the Field (gtA-1, gtB-1).
    • Every run exited 0, with no device fault, validation or VK_ERROR line and no shader preparation.
    • How to reproduce no longer shows the bug: the outlines are continuous, and the two-pass line replaces the helper line.
  • Game-free:
    • the three new checks fail on main and pass here with g++ 13.3 and clang 23.1;
    • spirv-val passes;
    • the translator stamp is unchanged (nx2/translator_files.py);
    • scripts/check_third_party.py passes.
  • python -I -B tests/run_all.py --changed main (26 files, 167 checks) at this PR's head on main 79d4a1436: 159 passed, 11 failed, 2 skipped. All 11 fail on plain main the same way (11 failed of 11 there):
    test_compute_warm_apart, test_dev_packs, test_draw_stream_visibility, test_fsr_uniform_ownership,
    test_hud_layout_row, test_linux_pressure, test_pipeline_play_cache, test_switch_table (rows for eight host and
    replay switches, none of this PR's), test_upscaler_rows, test_vk_occlusion_queries, test_walk_key.
    • Under heavy load earlier, the timing checks test_pipeline_cache_save, test_prepare_stall and test_draw_side_effects failed once; they read nothing this PR changes and pass alone.

Not testable by hand: Render 58% and 33% with the game's own upscaler, because that row doesn't offer them on any PC (see Why). The one way they reach this pass is a temporal upscaler at those shares failing to draw, which can't be caused on purpose. tests/test_fixed_share_upscale.py stands in for the 3x case and tests/test_upscale_fallback.py for those keys.

Not tested:

  • Windows;
  • any GPU but the Deck's;
  • outputs above 1280x720 beyond 2048x1152's 50% stills;
  • dungeons;
  • the game's Auto (dynamic) size with the game's own upscaler.

Must be tested:

  • Windows, an AMD or Intel GPU without the game's networks (any Radeon RX 5000 or later, or Intel Arc or Xe): Render resolution 50% and 67% with the game's own upscaler at 1080p or 1440p.
    • Expect continuous outlines on Link and the foliage, no halo or ring on high-contrast edges, and the log line vk: fixed shares' upscale: FXAA at the Render resolution, then FSR 1 EASU.
    • Expect no fps cost against RX_VK_FIXED_SHARE_EASU=0 RX_VK_TAAU_FXAA=0 beyond the run-to-run spread.
    • Test Farm: @Beanstalk windows amd and windows intel: this PR against main at Render resolution 50% and 67% with the game's own upscaler, Kokiri Forest and Hyrule Field, screenshots of Link's outline and fps.

Risks

What could break:

  • The picture at 50% and 67% on every GPU that leaves those networks out.
  • AMD's guide wants EASU's input anti-aliased (it is, by the FXAA pass) and normalised to 0-1 in a perceptual space. This input is perceptual (the network's square root of the scene colour) but HDR, with highlights above 1. EASU's deringing keeps every result between its four nearest texels, and a non-finite one takes the linear sample; on the Deck no artefact showed in three areas.
  • A driver that fails the new pipeline or image falls back to the plain stretch, with a log line.

Known, not fixed: the intermediate image (1800 KB at 640x360, up to about 8,300 KB at 67% of 2048x1152) stays allocated for the rest of the run once a fixed share has been used, even after the player moves to 75% or 100%. It is given back only when a new size replaces it.

Turning it off: RX_VK_TAAU_FXAA=0 and RX_VK_FIXED_SHARE_EASU=0 give main's path; reverting is enough.

Compatibility: nothing for saves or options. The shader cache stamp is unchanged, so nothing is translated again. MKWVK_API_VERSION is unchanged (vk_api.h untouched). The new built-in compute pipeline is built at the first 50% or 67% frame.

Issues

See #275

Checklist

Everyone

  • One topic.
  • The title is a Conventional Commit (type(scope): description) of the status line's type.
  • Why gives the reason plainly and links the issues that fit (the tracker searched).
  • Tested on my own PC where it runs (in the game, for a change the game runs), as Testing's Tested says; what can't be run by hand is in Testing's Not testable by hand, with why. (My Steam Deck OLED, 21 runs on 2026-11-18: gA-1..4, gB-1..4, gB0-1, gA67-1, gB67-1, gxA-1, gxB-1, gA1152-1, gB1152-1, gFA-1, gFB-1, gMA-1, gMB-1, gtA-1, gtB-1. 58% and 33% are in Not testable by hand.)
  • Measurements has a verdict, or one line saying why there is nothing to measure.
  • Nothing gets worse that I know of: any cost (speed, latency, memory, a setup that worked before) is measured and in Risks. (Measured: 0.36-0.52 ms of GPU a frame at 1280x720 / 50% on the Deck, no fps cost resolved, 1800-4608 KB of memory. Unmeasured: larger outputs, desktop AMD and Intel, Windows; all in Testing and What it costs where it was not measured.)
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named).
  • No game files, dumps, build output or generated files. (The *_spv.h header is the project's checked-in generated kind, regenerated with glslang.)
  • third_party/ untouched (a new folder with a PROVENANCE.md instead).
  • The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. (AMD's FSR 1 header is MIT, already in third_party/fidelityfx-sdk with its notice, and included unchanged.)

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
  • Numbers from the same PC, scene and settings, at least 2 interleaved runs each, the median reported. (Kokiri four each, interleaved; the Field and Market pairs are single runs, labelled.)
  • Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value.
  • Screenshots of the same spot, captioned like the Measurements columns, for a change that shows on screen. (In the screenshots comment: the hat at 4x and its outline at 8x, the fern, the camera turn before and after, the Market.)
  • A file in docs/tested/ for each new measured run (format in docs/tested-configurations.md).
  • The SPIR-V headers regenerated with glslang (a shader changed).
  • A game-free test added for the fix, failing on main and passing here.
  • A check under tests/ that reads changed source updated in this PR, not weakened.
  • Docs updated.
  • Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. (Built on Linux only, clang for the Deck. The change is renderer code with no OS calls (vk_draw.cpp, a shader header); a Windows llvm-mingw build has not been run: needed from someone with the Windows builder, or the Test Farm run in Must be tested.)
**Type:** fix · **Risk:** medium · **Tested on:** Linux, Steam Deck OLED (RADV VANGOGH) · **Needs:** Windows, an AMD or Intel GPU ## TL;DR At Render resolution 50% on a Steam Deck (what Minimum and Auto pick there) the game's picture had no anti-aliasing at all. The game's own upscaler for that size can't run on the Deck, so its stand-in just stretched the small picture: every edge became a 2-pixel staircase and every bright speck a square. This PR smooths the edges at the small size first, then enlarges the picture with AMD's edge-following FSR 1 upscaler. On a Deck the outlines are continuous and calm in motion, with no new artefact in three areas, at 0.52 ms of GPU a frame and no fps cost that could be measured. ## Breakdown - **Who it helps:** players with the game's own upscaler at Render resolution 50% or 67% on a GPU where the game's network for that size can't run: the Steam Deck (on defaults), desktop AMD and Intel GPUs, GTX 10 cards. - **What was wrong:** the stand-in for those networks was a plain stretch of the small picture, with no anti-aliasing. - **What changes:** the stand-in runs FXAA on the small picture, then FSR 1 EASU to the screen's size. - **What does not change:** 75% and 100%, Upscaler Off, the temporal upscalers when they draw, PCs that run the game's networks, saves, settings and the shader cache. - **How it was checked:** - three game-free checks that fail on `main`; - 21 runs on a Steam Deck against `main`: outlines continuous, nothing new in Kokiri Forest, Hyrule Field or the Market; - the new pass costs 0.52 ms of GPU a frame; - fps unchanged within the runs' spread. - **What is still open:** Windows; desktop AMD, Intel and GTX 10 cards; outputs above 1280x720. - **Risk:** medium: the picture changes at 50% and 67% on every GPU that leaves those networks out. ## Why At Render resolution 50% on a Steam Deck the edges look hard and stair-stepped, with bright specks along Link's hat and on the grass that crawl as the camera moves. 50% is what the Minimum preset sets and what Auto picks on a Deck, so that is every Deck player on defaults. The game draws the 3D at a fixed share of the screen and enlarges it with a network of its own for each share: 67%, 58%, 50% and 33% each have one. These networks need cooperative matrices, and the renderer leaves them out (`vk_shader.cpp`) in these cases: - every GPU that is not NVIDIA's: the Steam Deck, desktop AMD on Windows and Linux, Intel's integrated GPUs and Arc; - a GPU whose matrix multiplies run in software; - one without f16 shaders: GTX 10, and Polaris on RADV; - `RX_VK_NO_F16`. On an NVIDIA RTX card the movie networks' linear rule also takes them: - once `movie_networks_slow` trips (a frame over 40 ms of GPU in under 40 draws); - with `RX_VK_MOVIE_UPSCALE=linear`; - with `RX_VK_FORCE_UPSCALE_STUB`. There, with the game's own upscaler, `upscale_stub`'s generic fallback stretched the small picture linearly with no anti-aliasing. At 75% a different network is replaced by a stand-in that does run FXAA, which is why 75% looks better. **Which shares a player can reach on this path:** with the game's own upscaler the Render resolution row offers Auto, 100%, 75%, 67% and 50% (`upscaler_rows.h` `kGameSteps`), on every output size and OS. 58% and 33% are not offered with it: - a saved `resolution=5` or `=6` is snapped to 50% at start (`snap_render`); - a live set answers `no step reaches 5 on this PC` (`host/control.c`); - Auto's 33% rule for a 4-thread integrated GPU snaps to 50% the same way. 58% and 33% are steps of DLSS, FSR 3.1, FSR 4 and XeSS (and 33% of Off), whose own paths draw the picture. So this PR changes what players see at **67% and 50%**. The 58% and 33% keys stay in the list for the one case that still reaches this fallback: a temporal upscaler at those shares that fails to draw a frame (`temporal_rejected_network` returns false), which would otherwise get the plain stretch. That case was not run. This fixes edges, not resolution: Render 75% still shows more texture detail inside the hat and the plants, because it draws 2.25x the pixels. See https://git.magicbean.dev/MagicBeanDev/Longshot/issues/275: an RX 570 on this same fallback at 50%, with bright dots on hair and foliage. ## How to reproduce **Seen on:** SteamOS 3.9.5, Steam Deck OLED, RADV VANGOGH, Mesa 26.2.0-devel **Settings and switches:** Render resolution 50%, Upscaler the game's own (the Minimum preset, or Auto on a Deck); 1280x720 **Steps:** load a child save in Kokiri Forest and look at Link's hat and the ferns against the path, standing, then turning the camera **Expected:** anti-aliased edges, as at Render 75% **Actual:** on main, outlines are dashed lines of 2x2 blocks, with bright 2x2 specks. The log has `vk: program 72ba090c70fe2614 not translated: a network left out on this card` and `vk: typed upscale helper generic RGB9E5 fallback, packed output`; `RX_VK_TAAU_FXAA=2` marks no pixel at 50%. ## What changed When a fixed share's network is left out, its output is now drawn in two compute passes: FXAA on the input's texel centres at the Render resolution, then AMD FSR 1 EASU up to the output's size. EASU runs only up to 2x a side, the largest ratio AMD's FSR 1 integration guide has a mode for (Performance, 2.0x per dimension): 67% (1.5x), 58% (1.72x) and 50% (2x). 33% (3x) gets the FXAA pass and the linear stretch, and the log says so once. Every other program that reaches the same fallback is drawn as before. - **renderer:** `gpu/vk/vk_draw.cpp`. - `fixed_share_network()` names the four keys: 67% `6676619641320ba7`, 58% `f10782f9e58b6a7c`, 50% `72ba090c70fe2614`, 33% `0775215f8da720e6`. The 33% key at 1280x720 was confirmed on the Deck with Upscaler Off. - `upscale_stub` calls `fixed_share_upscale()` for them before `typed_upscale`. - These keep `typed_upscale` as before: - the 3/4 (`fd029a317a9a4b94`) and full-size (`9dc98871eb7fc101`) networks; - every other program; - a failed pipeline; - an image that cannot be made. - `fixed_share_upscale()`: - its own pipeline and push descriptors; - an RGBA16F image of the input's size: made once, made again at a new size with the old one given back 120 presents later, logged when made; one that cannot be made is logged once and not retried at that size; - a transition to GENERAL at creation; - stage 0 writes the image, a compute write to sampled-read barrier, then stage 1 reads it and writes the output; - every binding a valid image in both dispatches; - EASU's constants from AMD's `ffxFsrPopulateEasuConstants`; - each dispatch in an `RX_VK_PASS_TIMING` span of its own name. - **shader:** `gpu/vk/shaders/fixed_share_upscale.comp`, with `fixed_share_upscale_comp_spv.h` generated by glslang 16.6.0. - The input is the network's: the square root of the scene colour. - Stage 0 runs the 3/4 stand-in's FXAA (the same thresholds) on texel centres. - Stage 1 runs EASU from `third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h` (MIT), included unchanged, then squares the result back into the R11G11B10 output. - EASU's deringing holds each result between its four nearest texels. A non-finite result takes the linear sample, and the value is clamped at 0 before the square. - **switches:** `gpu/vk/switches.def`. - New `kill` row `RX_VK_FIXED_SHARE_EASU`. - `RX_VK_TAAU_FXAA`'s row now says it covers this pass too, so the 3/4 stand-in's FXAA and this one can't be turned off apart. - **tests:** - `tests/test_fixed_share_upscale.py`: the passes with Vulkan spies and their spans, both switches, the 3x case, an image that cannot be made, and the four keys against the same keys a bit off. - `tests/test_fixed_share_upscale_shader.py`: header against source, `spirv-val`, the shader's shape. - `tests/test_upscale_fallback.py`: each of the four keys takes the new path; 50%'s key a bit off does not. - **docs:** - `docs/development.md`, beside the TAAU replacement's paragraph; - `README.md`'s credits name FSR 1 beside FSR 3.1 and FSR 4; - 21 files in `docs/tested/`, one per measured run. ## Measurements **Verdict:** the fix holds on a Steam Deck. At 50% and 67% the outlines are continuous, with no 2x2 blocks, and calm while the camera turns. Navi, the fairies, the fireflies and the HUD are unchanged, and the Market and Hyrule Field show no halo, ring or fringe. The new passes cost 0.52 ms of GPU a frame in Hyrule Field, and no fps cost is resolved in any of the three areas. Both switches off is main's path exactly. Hardware: Steam Deck OLED, SteamOS 3.9.5 (20261023.100), RADV VANGOGH Mesa 26.2.0-devel, GPU clock manual 1600 MHz; AMD Custom APU 0932, 16 GB Scene: Kokiri Forest (child save's spot), Hyrule Field (night arrival, camera turned), the Market entrance; 1280x720, Render 50% (and 67%), the game's own upscaler, Lanczos window filter, Sharpness 50, frame generation off, no cap; headless Method: presents per second over a 90 s standing sample (the control bridge's `replayed`), Kokiri interleaved A B B A B A A B, median; GPU time from `RX_VK_PASS_TIMING=1` (four 600-present reports inside the sample); stills after the window pass and four consecutive presents of a camera turn; `RX_VK_TAAU_FXAA=2` marks counted on the bridge shots How to reproduce: this PR's two code commits on main 8e3dfde6e (`00eaca4aa`, branch `aa-final-on-8e3dfde6`; the same code as this PR's head) as a renderer pack (`scripts/dev_packs.py`), against that main's own renderer, with the settings above | | Before: main @ 8e3dfde6e | After: this PR @ 00eaca4aa | After, RX_VK_TAAU_FXAA=0 RX_VK_FIXED_SHARE_EASU=0: this PR @ 00eaca4aa | |---|---|---|---| | Kokiri 50%, fps, median (range) | 18.82 (18.39-19.12), 4 runs | 19.44 (17.71-20.98), 4 runs | 21.30, 1 run | | Kokiri 67%, fps | 19.93, 1 run | 18.62, 1 run | | | Hyrule Field 50%, fps | 40.11, 1 run | 39.82, 1 run | | | Market 50%, fps | 14.52, 1 run | 14.90, 1 run | | | Field 50%, GPU ms a frame in timed spans | 10.71-10.73 | 11.08-11.12 | | | Field 50%, the new passes | none | 0.518 ms a frame: FSR 1 EASU 0.469 ms (469 us a pass), FXAA ~0.05 ms | | | `RX_VK_TAAU_FXAA=2` marks, 50% / 67% / 75% (red+blue) | 37+0 / 37+0 / 11,637+4,250 | 1,802+517 / 2,846+986 / 11,411+3,696 | | | `RGBA16F image made` lines | none | one per Render size used (1 at 50%; 2 with 67%), never per frame | none | | Path in the log | `typed upscale helper` | `fixed shares' upscale: FXAA ... then FSR 1 EASU`, no helper | `typed upscale helper` (main's) | - **fps:** the Kokiri runs drift between 18 and 21 fps by themselves; the scene is CPU-bound. B0, main's path, ran fastest of all. So no cost and no gain is resolved. - **GPU time:** in the Field the timed frame is 0.36-0.39 ms longer. The new passes are 0.52 ms; the plain stretch they replace sat inside other spans. - **Marks:** at 50%/67% they are drawn at the Render size and then stretched, so they are not comparable with 75%'s. A's 37 pure-red pixels are the hat's berries. 75% is unchanged (−1.9% red, −13% blue, within the run-to-run bar). ``` vk: program 72ba090c70fe2614 not translated: a network left out on this card vk: fixed shares' upscale: FXAA at the Render resolution, then FSR 1 EASU vk: fixed shares' upscale: its 640x360 RGBA16F image made (1800 KB) vk: 0.469 ms ... fixed shares' upscale: FSR 1 EASU (gtB-1, Hyrule Field, each 600-present report) ``` **The PR's base:** the Deck build is these commits backported onto main 8e3dfde6e, because the Deck's base and caches are at that commit. Between 8e3dfde6e and this PR's base, these commits touch the upscale path: - #718 (the full-size network through the same fallback at 100%: not one of the four keys, so it doesn't reach this pass); - #1464 (FSR 3.1 frame generation notes `upscale_stub`'s output picture: no change to what is drawn); - #1309 (the switch table: the reason the backport leaves out the `switches.def` rows). None changes how the fixed shares reach `upscale_stub` or what it draws for them, so the numbers carry over. **How this design was chosen (a prototype, not this build):** - On the same Deck and rows, the 3/4 stand-in's FXAA simply added to the fallback barely changed the picture. It runs once per screen pixel, so the four screen pixels of one small texel move independently. - A prototype with a switch for each part then compared the options in one session: - FXAA at the small size, then a linear stretch: soft; - the same, then FSR 1 EASU: crisp and continuous, the closest to Render 75%, cleaner than FSR 3.1 at 50%; - a speck clamp before it: held no pixel, so it was dropped. - This PR is the EASU variant; on lavapipe its output is byte-identical to that prototype mode. ### What it costs where it was not measured - **Desktop AMD (Windows and Linux), Intel Arc and integrated, GTX 10, Polaris on RADV, at Render 50% or 67% with the game's own upscaler:** the picture changes there too, from a plain stretch to this. Not run on any of them. - **GPU time at larger outputs:** EASU's cost grows with the output. It measured 0.47 ms at 1280x720 on the Deck at 1600 MHz: | Output | Pixels vs 1280x720 | |---|---| | 2048x1152 | 2.6x | | 2560x1440 | 4x | | 3840x2160 | 9x | It is unmeasured on any of them, and on a weak integrated GPU at 1080p least of all. - **Memory:** the intermediate RGBA16F image has the Render resolution's size; briefly two exist during a size change. | Render resolution | Measured on the Deck | Computed | |---|---|---| | 640x360 (50% of 1280x720) | 1800 KB | | | 854x480 (67% of 1280x720) | 3202 KB | | | 1024x576 (50% of 2048x1152) | 4608 KB | | | ~1372x772 (67% of 2048x1152) | | about 8,300 KB | ### Flags and settings One switch added, one row's text changed. | Flag | What it is | Before this PR | After this PR | Effect | Helps / doesn't help / untested | Recommendation | |---|---|---|---|---|---|---| | `RX_VK_FIXED_SHARE_EASU` (new, kill) | the stretch of the fixed shares' fallback | (none: linear) | on (unset) | `=0`: linear stretch after the edge pass | helps on the Steam Deck; untested on desktop GPUs | on for everyone | | `RX_VK_TAAU_FXAA` | FXAA in the 3/4 stand-in, now also this edge pass | 1 | 1 | `=0` leaves both out; `=2` marks moved pixels | as above | on (1) | Both off gives main's plain stretch through `typed_upscale` (measured on the Deck: the same path and picture). Documented in `docs/development.md`. ## Testing **Tested:** - **On my own Steam Deck OLED, in the game (2026-11-18), 21 runs against main** at 1280x720 with the game's own upscaler (files in `docs/tested/`): - Kokiri Forest at 50%, A B B A B A A B (gA-1..4, gB-1..4); - both passes off (gB0-1); - 67% (gA67-1, gB67-1); - the marks at 50/67/75% (gxA-1, gxB-1); - 2048x1152 at 50% (gA1152-1, gB1152-1); - Hyrule Field (gFA-1, gFB-1) and the Market (gMA-1, gMB-1); - `RX_VK_PASS_TIMING=1` in the Field (gtA-1, gtB-1). - Every run exited 0, with no device fault, validation or `VK_ERROR` line and no shader preparation. - How to reproduce no longer shows the bug: the outlines are continuous, and the two-pass line replaces the helper line. - **Game-free:** - the three new checks fail on `main` and pass here with g++ 13.3 and clang 23.1; - `spirv-val` passes; - the translator stamp is unchanged (`nx2/translator_files.py`); - `scripts/check_third_party.py` passes. - **`python -I -B tests/run_all.py --changed main`** (26 files, 167 checks) at this PR's head on main `79d4a1436`: 159 passed, 11 failed, 2 skipped. All 11 fail on plain `main` the same way (11 failed of 11 there): `test_compute_warm_apart`, `test_dev_packs`, `test_draw_stream_visibility`, `test_fsr_uniform_ownership`, `test_hud_layout_row`, `test_linux_pressure`, `test_pipeline_play_cache`, `test_switch_table` (rows for eight host and replay switches, none of this PR's), `test_upscaler_rows`, `test_vk_occlusion_queries`, `test_walk_key`. - Under heavy load earlier, the timing checks `test_pipeline_cache_save`, `test_prepare_stall` and `test_draw_side_effects` failed once; they read nothing this PR changes and pass alone. **Not testable by hand:** Render 58% and 33% with the game's own upscaler, because that row doesn't offer them on any PC (see Why). The one way they reach this pass is a temporal upscaler at those shares failing to draw, which can't be caused on purpose. `tests/test_fixed_share_upscale.py` stands in for the 3x case and `tests/test_upscale_fallback.py` for those keys. **Not tested:** - Windows; - any GPU but the Deck's; - outputs above 1280x720 beyond 2048x1152's 50% stills; - dungeons; - the game's Auto (dynamic) size with the game's own upscaler. **Must be tested:** - Windows, an AMD or Intel GPU without the game's networks (any Radeon RX 5000 or later, or Intel Arc or Xe): Render resolution 50% and 67% with the game's own upscaler at 1080p or 1440p. - Expect continuous outlines on Link and the foliage, no halo or ring on high-contrast edges, and the log line `vk: fixed shares' upscale: FXAA at the Render resolution, then FSR 1 EASU`. - Expect no fps cost against `RX_VK_FIXED_SHARE_EASU=0 RX_VK_TAAU_FXAA=0` beyond the run-to-run spread. - Test Farm: `@Beanstalk windows amd and windows intel: this PR against main at Render resolution 50% and 67% with the game's own upscaler, Kokiri Forest and Hyrule Field, screenshots of Link's outline and fps`. ## Risks **What could break:** - The picture at 50% and 67% on every GPU that leaves those networks out. - AMD's guide wants EASU's input anti-aliased (it is, by the FXAA pass) and normalised to 0-1 in a perceptual space. This input is perceptual (the network's square root of the scene colour) but HDR, with highlights above 1. EASU's deringing keeps every result between its four nearest texels, and a non-finite one takes the linear sample; on the Deck no artefact showed in three areas. - A driver that fails the new pipeline or image falls back to the plain stretch, with a log line. **Known, not fixed:** the intermediate image (1800 KB at 640x360, up to about 8,300 KB at 67% of 2048x1152) stays allocated for the rest of the run once a fixed share has been used, even after the player moves to 75% or 100%. It is given back only when a new size replaces it. **Turning it off:** `RX_VK_TAAU_FXAA=0` and `RX_VK_FIXED_SHARE_EASU=0` give main's path; reverting is enough. **Compatibility:** nothing for saves or options. The shader cache stamp is unchanged, so nothing is translated again. `MKWVK_API_VERSION` is unchanged (`vk_api.h` untouched). The new built-in compute pipeline is built at the first 50% or 67% frame. ## Issues See https://git.magicbean.dev/MagicBeanDev/Longshot/issues/275 ## Checklist ### Everyone - [x] One topic. - [x] The title is a Conventional Commit (`type(scope): description`) of the status line's type. - [x] Why gives the reason plainly and links the issues that fit (the tracker searched). - [x] Tested on my own PC where it runs (in the game, for a change the game runs), as Testing's Tested says; what can't be run by hand is in Testing's Not testable by hand, with why. *(My Steam Deck OLED, 21 runs on 2026-11-18: gA-1..4, gB-1..4, gB0-1, gA67-1, gB67-1, gxA-1, gxB-1, gA1152-1, gB1152-1, gFA-1, gFB-1, gMA-1, gMB-1, gtA-1, gtB-1. 58% and 33% are in Not testable by hand.)* - [x] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Nothing gets worse that I know of: any cost (speed, latency, memory, a setup that worked before) is measured and in Risks. *(Measured: 0.36-0.52 ms of GPU a frame at 1280x720 / 50% on the Deck, no fps cost resolved, 1800-4608 KB of memory. Unmeasured: larger outputs, desktop AMD and Intel, Windows; all in Testing and What it costs where it was not measured.)* - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [x] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). - [x] No game files, dumps, build output or generated files. *(The `*_spv.h` header is the project's checked-in generated kind, regenerated with glslang.)* - [x] `third_party/` untouched (a new folder with a `PROVENANCE.md` instead). - [x] The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. *(AMD's FSR 1 header is MIT, already in `third_party/fidelityfx-sdk` with its notice, and included unchanged.)* ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. - [x] Numbers from the same PC, scene and settings, at least 2 interleaved runs each, the median reported. *(Kokiri four each, interleaved; the Field and Market pairs are single runs, labelled.)* - [x] Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value. - [x] Screenshots of the same spot, captioned like the Measurements columns, for a change that shows on screen. *(In the screenshots comment: the hat at 4x and its outline at 8x, the fern, the camera turn before and after, the Market.)* - [x] A file in `docs/tested/` for each new measured run (format in `docs/tested-configurations.md`). - [x] The SPIR-V headers regenerated with glslang (a shader changed). - [x] A game-free test added for the fix, failing on `main` and passing here. - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. - [x] Docs updated. - [ ] Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. *(Built on Linux only, clang for the Deck. The change is renderer code with no OS calls (`vk_draw.cpp`, a shader header); a Windows llvm-mingw build has not been run: needed from someone with the Windows builder, or the Test Farm run in Must be tested.)*
Where the network of a fixed share of the Render resolution row (67% `6676619641320ba7`, 58% `f10782f9e58b6a7c`, 50%
`72ba090c70fe2614`, 33% `0775215f8da720e6`) is left out, `upscale_stub`'s generic RGB9E5 fallback stretches its input
linearly with no anti-aliasing. These checks want it drawn by `fixed_share_upscale` in two passes instead:
- `tests/test_fixed_share_upscale.py` runs it with Vulkan spies: the edge pass at the input's size into an RGBA16F image,
  a barrier, the stretch at the output's size, each pass in an `RX_VK_PASS_TIMING` span of its name, every binding a
  valid image, EASU's constants, the image made and logged once and given back 120 presents after a new size replaces
  it, EASU left out beyond 2x a side (33%), an image that cannot be made logged once and not tried again, and
  `RX_VK_TAAU_FXAA` / `RX_VK_FIXED_SHARE_EASU` (both off: the plain stretch). Also `fixed_share_network`: the four keys,
  and not the same keys a bit off nor the gameplay networks.
- `tests/test_upscale_fallback.py`'s `upscale_stub` fixture now has `fixed_share_upscale`: each of the four keys takes
  it; 50%'s key a bit off, the 3/4 and full-size networks and any other program keep `typed_upscale`, and a failed
  two-pass draw falls back to it.
- `tests/test_fixed_share_upscale_shader.py`: the shader's header is the source compiled with AMD's FSR 1 header, its
  SPIR-V validates, and nothing negative or non-finite is squared into the packed output.

All three fail on main.

Assisted-by: Claude
The game's network for each fixed share of the Render resolution row is a cooperative-matrix network. `vk_shader.cpp`
leaves those out on every GPU that is not NVIDIA's (the Steam Deck, desktop AMD on Windows and Linux, Intel), wherever the
multiplies run in software, without f16 shaders (GTX 10, Polaris on RADV) or with `RX_VK_NO_F16`; on an NVIDIA card the
movie networks' linear rule takes them too once `movie_networks_slow` trips, or with `RX_VK_MOVIE_UPSCALE=linear` or
`RX_VK_FORCE_UPSCALE_STUB=1`. With the game's own upscaler, `upscale_stub`'s generic RGB9E5 fallback then stretched the
picture linearly with no anti-aliasing: at 50% (Minimum, and Auto on a Deck) every edge a 2-pixel stair step, every bright
texel a 2x2 speck.

`fixed_share_upscale` now draws those four networks' output in two dispatches of `shaders/fixed_share_upscale.comp`:
FXAA 3.11 (the 3/4 stand-in's) on the input's texel centres at the Render resolution into an RGBA16F image of that size,
then AMD FSR 1 EASU from `third_party/fidelityfx-sdk` (MIT, included unchanged) to the output's size, squared back into
the packed output. EASU only up to 2x a side, the largest ratio AMD's FSR 1 guide has a mode for (Performance, 2.0x per
dimension): 67%, 58% and 50%; 33%'s 3x gets the edge pass and the linear stretch. EASU's result stays between its four
nearest texels and a non-finite one takes the linear sample. `fixed_share_network` names the four keys; every other
program that falls back there, the 3/4 (`fd029a317a9a4b94`) and full-size (`9dc98871eb7fc101`) networks included, keeps
`typed_upscale` as before, and so does a failed pipeline or an image that cannot be made (logged once, not tried again).
Each pass is an `RX_VK_PASS_TIMING` span of its own name.

`RX_VK_TAAU_FXAA=0` leaves the edge pass out, here and in the 3/4 stand-in alike (`=2` draws the texels it moved);
`RX_VK_FIXED_SHARE_EASU=0`, a new `kill` row, stretches linearly; both give the plain stretch as before. The extra image is
the input's size, 1.8 MB at 640x360, logged when made and kept for the rest of the run. The README credits FSR 1 beside
FSR 3.1 and FSR 4. The shader is a new built-in; nothing the translator reads changes, so the shader cache stamp stays.

Assisted-by: Claude
docs(tested): the fixed shares' edge pass and FSR 1 EASU on a Steam Deck OLED
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 5s
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/approval approved by futondestroyer (reviewed)
beanstalk/windows+amd 2/1 pass
beanstalk/windows+intel 0/1 pass, 0 running, 2 queued
ff0eec7ffb
Twenty-one runs of 2026-11-18 on a Steam Deck OLED (manual 1600 MHz, the owner's rows: 1280x720, Render 50%, the game's own
upscaler), this change's backport on main 8e3dfde6e against main:
- Kokiri Forest A B B A B A A B, 90 s standing (`gA-1..4`, `gB-1..4`), and both passes off (`gB0-1`);
- 67% (`gA67-1`, `gB67-1`);
- Hyrule Field and the Market (`gFA-1`, `gFB-1`, `gMA-1`, `gMB-1`);
- `RX_VK_PASS_TIMING=1` in the Field (`gtA-1`, `gtB-1`);
- the `RX_VK_TAAU_FXAA=2` marks (`gxA-1`, `gxB-1`) and 2048x1152 (`gA1152-1`, `gB1152-1`).

Assisted-by: Claude
Author
Contributor

Tested in game: Steam Deck OLED (SteamOS 3.9.5, RADV VANGOGH, Mesa 26.2.0-devel): this change backported onto main 8e3dfde6e, 21 runs on 2026-11-18 against main at 1280x720 and the game's own upscaler (Kokiri Forest A B B A B A A B at 50%, 67%, Hyrule Field, the Market, both passes off, and RX_VK_PASS_TIMING in the Field): the two passes ran at 50% and 67% with continuous outlines and no artefact, 0.52 ms of GPU a frame, no fps cost resolved.

Tested in game: Steam Deck OLED (SteamOS 3.9.5, RADV VANGOGH, Mesa 26.2.0-devel): this change backported onto main 8e3dfde6e, 21 runs on 2026-11-18 against main at 1280x720 and the game's own upscaler (Kokiri Forest A B B A B A A B at 50%, 67%, Hyrule Field, the Market, both passes off, and RX_VK_PASS_TIMING in the Field): the two passes ran at 50% and 67% with continuous outlines and no artefact, 0.52 ms of GPU a frame, no fps cost resolved.
Author
Contributor

Screenshots from the measured Deck runs: Steam Deck OLED, 1280x720, Render resolution 50% (640x360), the game's own upscaler, Lanczos window filter, Sharpness 50. Before: main @ 8e3dfde6e. After: this PR, backported onto main @ 8e3dfde6e (longshot_vk.so 061e414e…6076). Pictures are after the window pass; Link's idle pose differs between runs.

Link's hat standing, 4x. Left: Before, main @ 8e3dfde6e (gA-1). Middle: After, this PR (gB-1). Right: this PR with RX_VK_TAAU_FXAA=0 RX_VK_FIXED_SHARE_EASU=0 (gB0-1), main's path

The hat's outline, 8x. Left: Before, main @ 8e3dfde6e: 2-pixel steps. Middle: After, this PR (Link's head is turned in this frame). Right: both passes off, as main

The fern against the path, 3x. Left: Before, main @ 8e3dfde6e: notched stair steps. Middle: After, this PR. Right: both passes off, as main

Four consecutive presents while the camera turns, 3x. Before, main @ 8e3dfde6e (gA-1): the hat's outline crawls in 2x2 blocks

The same turn. After, this PR (gB-1): a continuous outline that stays calm

The Market, the same view, 3x: the castle on the horizon, the roofs and the bunting. Left: Before, main @ 8e3dfde6e (gMA-1). Right: After, this PR (gMB-1): smoother edges, no halo or ring

Screenshots from the measured Deck runs: Steam Deck OLED, 1280x720, Render resolution 50% (640x360), the game's own upscaler, Lanczos window filter, Sharpness 50. Before: main @ 8e3dfde6e. After: this PR, backported onto main @ 8e3dfde6e (`longshot_vk.so` 061e414e…6076). Pictures are after the window pass; Link's idle pose differs between runs. ![Link's hat standing, 4x. Left: Before, main @ 8e3dfde6e (gA-1). Middle: After, this PR (gB-1). Right: this PR with RX_VK_TAAU_FXAA=0 RX_VK_FIXED_SHARE_EASU=0 (gB0-1), main's path](https://git.magicbean.dev/attachments/77738c52-2d88-49e9-8a13-c5477dfc76ef) ![The hat's outline, 8x. Left: Before, main @ 8e3dfde6e: 2-pixel steps. Middle: After, this PR (Link's head is turned in this frame). Right: both passes off, as main](https://git.magicbean.dev/attachments/617a973b-d54e-4259-9d00-9dd2dac7a071) ![The fern against the path, 3x. Left: Before, main @ 8e3dfde6e: notched stair steps. Middle: After, this PR. Right: both passes off, as main](https://git.magicbean.dev/attachments/036bce4f-1118-4b52-95c8-116df9dc83e3) ![Four consecutive presents while the camera turns, 3x. Before, main @ 8e3dfde6e (gA-1): the hat's outline crawls in 2x2 blocks](https://git.magicbean.dev/attachments/631caec4-2b5d-4470-b37e-d663179e81ac) ![The same turn. After, this PR (gB-1): a continuous outline that stays calm](https://git.magicbean.dev/attachments/662c6d50-f7c3-4707-a72d-d1c71a3d5d83) ![The Market, the same view, 3x: the castle on the horizon, the roofs and the bunting. Left: Before, main @ 8e3dfde6e (gMA-1). Right: After, this PR (gMB-1): smoother edges, no halo or ring](https://git.magicbean.dev/attachments/790687be-8759-4576-b727-609fd9e6d77f)
Author
Contributor

@Beanstalk windows amd and windows intel: this PR against main at Render resolution 50% and 67% with the game's own upscaler, Kokiri Forest and Hyrule Field, screenshots of Link's outline and fps

@Beanstalk windows amd and windows intel: this PR against main at Render resolution 50% and 67% with the game's own upscaler, Kokiri Forest and Hyrule Field, screenshots of Link's outline and fps
Member

@zeldaootr only members of BigBeans can start the farm. One of them can approve this request by reacting 👍 to it or to this comment.

@zeldaootr only members of `BigBeans` can start the farm. One of them can approve this request by reacting 👍 to it or to this comment.
Member

Beanstalk test farm

Commit ff0eec7 · tier reviewed · approved by futondestroyer (👍 on zeldaootr's request) · dashboard

What will be tested · AI plan (gpt-6.1-terra)

Windows AMD and Intel PCs will compare the PR with main in Kokiri Forest and Hyrule Field, using the game's own upscaler at both 50% and 67% render resolution. The resolution matrix exercises both changed fallback paths; screenshots capture Link's outline and the surroundings, while FPS and frame times measure performance over roughly 13 minutes per tester. Crashes, large screenshot differences, a 10% FPS drop, or a 15% p99 frame-time increase fail the plan; the image threshold permits some intended edge smoothing but cannot prove that outlines improved. No Intel tester is currently listed online, so that target will wait for one. No tester online now matches windows+intel: that target waits for one.

  • Where: windows+amd (1-2 reports), windows+intel (1-2 reports).
  • Matrix: 2 cells, each on main and the PR: resolution 4 or 3.
  • outlines-and-fps: from a new save (settings dlss=0, frame_generation=0), then teleport to Kokiri Forest, measure forest for 20 s (after 5 s warm-up), take the picture forest-outline to compare with main, teleport to Hyrule Field, measure field for 20 s (after 5 s warm-up), take the picture field-outline to compare with main; 1 run on each side for each of 2 cells (1 game start a run).
  • Measured: crashes, draws and frame rate, frame times, stutters and hitches.
  • The PR fails if: it crashes; or frame rate is more than 10% below main; or a picture differs from main by more than 15%; or frame time (p99) is more than 15% above main.
  • Time: about 16 min of game runs per tester (2 game starts), plus the two builds.

Started at 13:09 UTC.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
windows+amd · 1: windows+amd+amd-proprietary+dgpu AMD Radeon RX 9070 XT, 2.0.416; 2: windows+amd+amd-proprietary+dgpu AMD Radeon RX 9070 XT, 2.0.416 2/1 1 2 none 19.0 vs 19.0 (−0%) — pass ⚠ outlier
windows+intel 0/1 — — — queued
Scenario · matrix cell Target Frame p99 (ms) vs main Result
outlines-and-fps · resolution=4 windows+amd 19.0 vs 19.0 (−0%) pass
outlines-and-fps · resolution=4 windows+intel — —
outlines-and-fps · resolution=3 windows+amd 19.1 vs 18.9 (+1%) pass
outlines-and-fps · resolution=3 windows+intel — —

Measurements · windows+amd

Verdict: pass on windows+amd (2/1 report): no rule failed and no PR run crashed.

Hardware: 1: windows+amd+amd-proprietary+dgpu AMD Radeon RX 9070 XT, 2.0.416 AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM; 2: windows+amd+amd-proprietary+dgpu AMD Radeon RX 9070 XT, 2.0.416 AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM
Scene: outlines-and-fps, from a new save (dlss=0, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); outlines-and-fps: 1 game start a side, forest 20 s after 5 s warm-up, field 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: main @ 79d4a14 After: this PR @ ff0eec7
outlines-and-fps · resolution=4 · field · frame rate 60.0 60.0 (+0%)
outlines-and-fps · resolution=4 · forest · frame rate 59.0 58.7 (−0%)
outlines-and-fps · resolution=4 · field · frame time (p99) (ms) 19.0 19.0 (−0%)
outlines-and-fps · resolution=4 · forest · frame time (p99) (ms) 20.7 21.5 (+4%)
outlines-and-fps · resolution=3 · field · frame rate 60.0 60.0 (+0%)
outlines-and-fps · resolution=3 · forest · frame rate 60.0 60.0 (+0%)
outlines-and-fps · resolution=3 · field · frame time (p99) (ms) 18.9 19.1 (+1%)
outlines-and-fps · resolution=3 · forest · frame time (p99) (ms) 18.9 18.9 (+0%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
resolution menu setting 4, 3 main's default the PR's default outlines-and-fps, the PR at 4 → at 3: 60.0 → 60.0 (−0%) no clear effect
Markdown for the PR description
## Measurements

**Verdict:** pass on windows+amd (2/1 report): no rule failed and no PR run crashed.

Hardware: 1: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM`  
Scene: outlines-and-fps, from a new save (dlss=0, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); outlines-and-fps: 1 game start a side, forest 20 s after 5 s warm-up, field 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: main @ 79d4a14 | After: this PR @ ff0eec7 |
|---|---|---|
| outlines-and-fps · `resolution=4` · field · frame rate | 60.0 | 60.0 (+0%) |
| outlines-and-fps · `resolution=4` · forest · frame rate | 59.0 | 58.7 (−0%) |
| outlines-and-fps · `resolution=4` · field · frame time (p99) (ms) | 19.0 | 19.0 (−0%) |
| outlines-and-fps · `resolution=4` · forest · frame time (p99) (ms) | 20.7 | 21.5 (+4%) |
| outlines-and-fps · `resolution=3` · field · frame rate | 60.0 | 60.0 (+0%) |
| outlines-and-fps · `resolution=3` · forest · frame rate | 60.0 | 60.0 (+0%) |
| outlines-and-fps · `resolution=3` · field · frame time (p99) (ms) | 18.9 | 19.1 (+1%) |
| outlines-and-fps · `resolution=3` · forest · frame time (p99) (ms) | 18.9 | 18.9 (+0%) |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `resolution` | menu setting | `4`, `3` | main's default | the PR's default | outlines-and-fps, the PR at 4 → at 3: 60.0 → 60.0 (−0%) | no clear effect |
<!-- beanstalk:sticky --> ### Beanstalk test farm Commit `ff0eec7` · tier **reviewed** · approved by futondestroyer (👍 on zeldaootr's request) · [dashboard](https://beanstalk.magicbean.dev/prs/1552) **What will be tested** · AI plan (`gpt-6.1-terra`) Windows AMD and Intel PCs will compare the PR with main in Kokiri Forest and Hyrule Field, using the game's own upscaler at both 50% and 67% render resolution. The resolution matrix exercises both changed fallback paths; screenshots capture Link's outline and the surroundings, while FPS and frame times measure performance over roughly 13 minutes per tester. Crashes, large screenshot differences, a 10% FPS drop, or a 15% p99 frame-time increase fail the plan; the image threshold permits some intended edge smoothing but cannot prove that outlines improved. No Intel tester is currently listed online, so that target will wait for one. No tester online now matches windows+intel: that target waits for one. - **Where:** windows+amd (1-2 reports), windows+intel (1-2 reports). - **Matrix:** 2 cells, each on main and the PR: resolution `4` or `3`. - **outlines-and-fps:** from a new save (settings dlss=0, frame_generation=0), then teleport to Kokiri Forest, measure forest for 20 s (after 5 s warm-up), take the picture forest-outline to compare with main, teleport to Hyrule Field, measure field for 20 s (after 5 s warm-up), take the picture field-outline to compare with main; 1 run on each side for each of 2 cells (1 game start a run). - **Measured:** crashes, draws and frame rate, frame times, stutters and hitches. - **The PR fails if:** it crashes; or frame rate is more than 10% below main; or a picture differs from main by more than 15%; or frame time (p99) is more than 15% above main. - **Time:** about 16 min of game runs per tester (2 game starts), plus the two builds. Started at 13:09 UTC. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | windows+amd · 1: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_071ec9da9d0d00a0) [2](https://beanstalk.magicbean.dev/reports/rp_3043e2ab95b4174d) | none | 19.0 vs 19.0 (−0%) | — | pass ⚠ outlier | | windows+intel | 0/1 | — | — | — | queued | | Scenario · matrix cell | Target | Frame p99 (ms) vs main | Result | | --- | --- | --- | --- | | outlines-and-fps · `resolution=4` | windows+amd | 19.0 vs 19.0 (−0%) | pass | | outlines-and-fps · `resolution=4` | windows+intel | — | — | | outlines-and-fps · `resolution=3` | windows+amd | 19.1 vs 18.9 (+1%) | pass | | outlines-and-fps · `resolution=3` | windows+intel | — | — | #### Measurements · windows+amd **Verdict:** pass on windows+amd (2/1 report): no rule failed and no PR run crashed. Hardware: 1: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM` Scene: outlines-and-fps, from a new save (dlss=0, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); outlines-and-fps: 1 game start a side, forest 20 s after 5 s warm-up, field 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 79d4a14 | After: this PR @ ff0eec7 | |---|---|---| | outlines-and-fps · `resolution=4` · field · frame rate | 60.0 | 60.0 (+0%) | | outlines-and-fps · `resolution=4` · forest · frame rate | 59.0 | 58.7 (−0%) | | outlines-and-fps · `resolution=4` · field · frame time (p99) (ms) | 19.0 | 19.0 (−0%) | | outlines-and-fps · `resolution=4` · forest · frame time (p99) (ms) | 20.7 | 21.5 (+4%) | | outlines-and-fps · `resolution=3` · field · frame rate | 60.0 | 60.0 (+0%) | | outlines-and-fps · `resolution=3` · forest · frame rate | 60.0 | 60.0 (+0%) | | outlines-and-fps · `resolution=3` · field · frame time (p99) (ms) | 18.9 | 19.1 (+1%) | | outlines-and-fps · `resolution=3` · forest · frame time (p99) (ms) | 18.9 | 18.9 (+0%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `resolution` | menu setting | `4`, `3` | main's default | the PR's default | outlines-and-fps, the PR at 4 → at 3: 60.0 → 60.0 (−0%) | no clear effect | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** pass on windows+amd (2/1 report): no rule failed and no PR run crashed. Hardware: 1: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM` Scene: outlines-and-fps, from a new save (dlss=0, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); outlines-and-fps: 1 game start a side, forest 20 s after 5 s warm-up, field 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 79d4a14 | After: this PR @ ff0eec7 | |---|---|---| | outlines-and-fps · `resolution=4` · field · frame rate | 60.0 | 60.0 (+0%) | | outlines-and-fps · `resolution=4` · forest · frame rate | 59.0 | 58.7 (−0%) | | outlines-and-fps · `resolution=4` · field · frame time (p99) (ms) | 19.0 | 19.0 (−0%) | | outlines-and-fps · `resolution=4` · forest · frame time (p99) (ms) | 20.7 | 21.5 (+4%) | | outlines-and-fps · `resolution=3` · field · frame rate | 60.0 | 60.0 (+0%) | | outlines-and-fps · `resolution=3` · forest · frame rate | 60.0 | 60.0 (+0%) | | outlines-and-fps · `resolution=3` · field · frame time (p99) (ms) | 18.9 | 19.1 (+1%) | | outlines-and-fps · `resolution=3` · forest · frame time (p99) (ms) | 18.9 | 18.9 (+0%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `resolution` | menu setting | `4`, `3` | main's default | the PR's default | outlines-and-fps, the PR at 4 → at 3: 60.0 → 60.0 (−0%) | no clear effect | ``` </details>
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 5s
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/approval approved by futondestroyer (reviewed)
beanstalk/windows+amd 2/1 pass
beanstalk/windows+intel 0/1 pass, 0 running, 2 queued
This pull request is marked as a work in progress.
Some workflows are waiting to be reviewed.
This branch is out-of-date with the base branch
View command line instructions

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u 'vk-fallback-upscale-aa:zeldaootr-vk-fallback-upscale-aa'
git switch 'zeldaootr-vk-fallback-upscale-aa'
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!1552
No description provided.