fix(vk): the compute fallback's indirect mesh draws are converted again, so the Steam Deck and every RADV GPU draw their grass and foliage #1946

Merged
HumanBean merged 2 commits from GummiNaomi/Longshot:fix/fallback-mesh-conv into main 2026-11-21 01:29:33 +00:00
Member

Summary

Since #1846, a GPU that runs the game's mesh programs through the compute fallback draws none of the GPU-culled vegetation: no grass, ferns, bushes, ivy, moss, tree leaves or fireflies. That is every RADV GPU by default (the Steam Deck among them: Automatic is the compute path there), every card without mesh shaders, and RX_VK_MESH_SHADERS=compute anywhere. A Steam Deck player's Hyrule Field had no grass at all. This puts the conversion back for those GPUs, so they draw it again.

Why: #1846 made mesh_indirect_convert return before converting when the device has no mesh shaders in use, on the belief that the compute fallback reads the game's own records. It does not: fallback_record dispatches each indirect draw's workgroups from the converted records (vkCmdDispatchIndirect from mesh_conv_buf) and has always left out a draw with none ("vk: fallback: an indirect mesh draw with no converted arguments is left out"). dev.mesh_shader is false wherever the fallback runs (create_device: if (mesh_mode_used == 2) dev.mesh_shader = false;), so every indirect mesh draw there was skipped (SKIP_HERE() right after fallback_record in draw()). AMD's Windows Navi 2x cards, whose task + mesh draws take the fallback with mesh shaders on, NVIDIA and Intel Arc are not affected.

To see it on main: any PC, RX_VK_MESH_SHADERS=compute, Kokiri Forest or Hyrule Field. The log says vk: skips a frame by vk_draw.cpp line: 8725: <40-49> and … <40-49> left as they are (no mesh shaders), and the vegetation is missing.

What changes: mesh_indirect_convert converts those draws again, one by one (no batch there: mesh_conv_batching still needs mesh shaders), and counts them for the log's line, which now says "for the compute fallback (no mesh shaders in use: one by one)" where it said "left as they are (no mesh shaders)". tests/test_mesh_conv.py checks that the conversion does not return early without mesh shaders while fallback_record dispatches from the converted records.

Read first: mesh_indirect_convert and fallback_record in gpu/vk/vk_draw.cpp, then the new check in tests/test_mesh_conv.py. See #1846.

Testing

Tested: Windows 11, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB, on a build of main with #1846 (not this PR's build), forced onto the compute fallback with RX_VK_MESH_SHADERS=compute; headless from kokiri-start with the control tool's test profile, 1920x1080, a shot each in Link's house, Hyrule Field's entrance, the Lost Woods and Kakariko. With main's default (RX_VK_MESH_CONV=2) the log left out 36-49 indirect mesh draws a frame at the SKIP_HERE() after fallback_record, with "an indirect mesh draw with no converted arguments is left out", and the shots had no ivy, moss, ferns, bushes, grass, tree leaves or fireflies. The same build with RX_VK_MESH_CONV=0 (the conversion before #1846, which this PR restores on the fallback) converted 40-49 a frame, skipped none there, and drew all of them. No errors in either log.
Checks: tests/test_mesh_conv.py passes on this head and fails on main @ 80bb1ccc with "mesh_indirect_convert returns without converting on a GPU without mesh shaders in use…"; tests/test_pass_timing_fallback.py, tests/test_mesh_fallback.py, tests/test_mesh_args_cleanup.py, tests/test_draw_side_effects.py, tests/test_fallback_loaded.py, tests/test_mesh_mode_switch.py and tests/test_prof_sampling.py pass (Windows, clang). gpu/vk/vk_draw.cpp and gpu/vk/vk_replay.cpp pass a syntax-only compile with the builder's Windows flags. This PR's own build has not been run in the game.

Still to test:

  • steamdeck: Hyrule Field and Kokiri Forest for 2 minutes on this PR's build, expecting the grass, ferns and leaves drawn, … for the compute fallback (no mesh shaders in use: one by one) above 0 in the log's indirect mesh draws line, and no skips a frame by vk_draw.cpp line for the line after fallback_record (@Beanstalk steamdeck, Hyrule Field and Kokiri Forest 2 minutes, the log and a screenshot of each)
  • A GPU without mesh shaders (RDNA 1 or older): Kokiri Forest for 2 minutes, expecting the vegetation drawn and the same log line above 0 (@Beanstalk a GPU without mesh shaders, Kokiri Forest 2 minutes, the log and a screenshot)
  • Windows, NVIDIA, defaults (native mesh shaders): Kokiri Forest, expecting nothing changed: the vegetation drawn and the log's line with the draws batched at the game's barriers and 0 for the compute fallback (by hand)
  • Windows, NVIDIA, RX_VK_MESH_SHADERS=compute: the shots above on this PR's build, expecting the vegetation drawn with RX_VK_MESH_CONV at its default (by hand)

Measurements

Nothing to measure against main's speed: on the compute fallback this draws again the 40-49 indirect mesh draws a frame that main leaves out (a correctness fix; their cost is the vegetation's own, as before #1846), and with mesh shaders in use nothing changes.

Risks

On the compute fallback the vegetation is drawn again, so a Steam Deck or RADV player's frame rate where there is grass and foliage goes back to what it was before #1846 (lower than main's, which draws none of it). Each such draw's arguments are copied between two full barriers (the RX_VK_MESH_CONV=1 path #1846 added, with the ring filled with 1s once), as main did per draw before #1846 with a fill as well. With native mesh shaders nothing changes. The log's indirect mesh draws line reads "for the compute fallback (no mesh shaders in use: one by one)" in place of "left as they are (no mesh shaders)"; no script in the tree reads that text. To go back: a revert, or RX_VK_MESH_CONV=0 (the conversion as before #1846). Nothing changes for saves, longshot_options.ini or the caches.

Checklist

Ready for review

  • One topic, on current main; the title is a Conventional Commit.
  • Tested on my own PC, in the game for a change the game runs, as Testing says. (The bug and the conversion this restores were run in the game on main's build; this PR's own build was not.)
  • mise run test passes (any failure that also fails on main is named). (Only the checks named in Testing ran.)
  • Measured against main, or Measurements says why there is nothing to measure.
  • No game files, build output or hand-edited generated files; third_party/ untouched; nothing GPL-incompatible.

When it applies

  • A fix: a game-free test that fails on main and passes here.
  • A check under tests/ that reads changed source is updated, not weakened.
  • Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (No build of this head: the two changed renderer files pass a syntax-only compile with the builder's Windows flags. A Linux build is left to someone else.)
  • Screenshots of the same spot on main and here, for a change that shows on screen. (Taken on main's build with and without the old conversion, described in Testing; not attached.)
  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.

Ready to merge

  • Everything in Still to test has run, its results in Tested.
  • Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers").
  • Approved in review, every comment answered.
  • CI passes on the head; on current main, measured again or a comment says why the numbers still hold.

🤖 Generated with Claude Code

## Summary Since #1846, a GPU that runs the game's mesh programs through the compute fallback draws none of the GPU-culled vegetation: no grass, ferns, bushes, ivy, moss, tree leaves or fireflies. That is every RADV GPU by default (the Steam Deck among them: Automatic is the compute path there), every card without mesh shaders, and `RX_VK_MESH_SHADERS=compute` anywhere. A Steam Deck player's Hyrule Field had no grass at all. This puts the conversion back for those GPUs, so they draw it again. Why: #1846 made `mesh_indirect_convert` return before converting when the device has no mesh shaders in use, on the belief that the compute fallback reads the game's own records. It does not: `fallback_record` dispatches each indirect draw's workgroups from the converted records (`vkCmdDispatchIndirect` from `mesh_conv_buf`) and has always left out a draw with none ("vk: fallback: an indirect mesh draw with no converted arguments is left out"). `dev.mesh_shader` is false wherever the fallback runs (`create_device`: `if (mesh_mode_used == 2) dev.mesh_shader = false;`), so every indirect mesh draw there was skipped (`SKIP_HERE()` right after `fallback_record` in `draw()`). AMD's Windows Navi 2x cards, whose task + mesh draws take the fallback with mesh shaders on, NVIDIA and Intel Arc are not affected. To see it on main: any PC, `RX_VK_MESH_SHADERS=compute`, Kokiri Forest or Hyrule Field. The log says `vk: skips a frame by vk_draw.cpp line: 8725: <40-49>` and `… <40-49> left as they are (no mesh shaders)`, and the vegetation is missing. What changes: `mesh_indirect_convert` converts those draws again, one by one (no batch there: `mesh_conv_batching` still needs mesh shaders), and counts them for the log's line, which now says "for the compute fallback (no mesh shaders in use: one by one)" where it said "left as they are (no mesh shaders)". `tests/test_mesh_conv.py` checks that the conversion does not return early without mesh shaders while `fallback_record` dispatches from the converted records. Read first: `mesh_indirect_convert` and `fallback_record` in `gpu/vk/vk_draw.cpp`, then the new check in `tests/test_mesh_conv.py`. See #1846. ## Testing **Tested:** Windows 11, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB, on a build of main with #1846 (not this PR's build), forced onto the compute fallback with `RX_VK_MESH_SHADERS=compute`; headless from `kokiri-start` with the control tool's test profile, 1920x1080, a shot each in Link's house, Hyrule Field's entrance, the Lost Woods and Kakariko. With main's default (`RX_VK_MESH_CONV=2`) the log left out 36-49 indirect mesh draws a frame at the `SKIP_HERE()` after `fallback_record`, with "an indirect mesh draw with no converted arguments is left out", and the shots had no ivy, moss, ferns, bushes, grass, tree leaves or fireflies. The same build with `RX_VK_MESH_CONV=0` (the conversion before #1846, which this PR restores on the fallback) converted 40-49 a frame, skipped none there, and drew all of them. No errors in either log. Checks: `tests/test_mesh_conv.py` passes on this head and fails on main @ 80bb1ccc with "mesh_indirect_convert returns without converting on a GPU without mesh shaders in use…"; `tests/test_pass_timing_fallback.py`, `tests/test_mesh_fallback.py`, `tests/test_mesh_args_cleanup.py`, `tests/test_draw_side_effects.py`, `tests/test_fallback_loaded.py`, `tests/test_mesh_mode_switch.py` and `tests/test_prof_sampling.py` pass (Windows, clang). `gpu/vk/vk_draw.cpp` and `gpu/vk/vk_replay.cpp` pass a syntax-only compile with the builder's Windows flags. This PR's own build has not been run in the game. **Still to test:** - steamdeck: Hyrule Field and Kokiri Forest for 2 minutes on this PR's build, expecting the grass, ferns and leaves drawn, `… for the compute fallback (no mesh shaders in use: one by one)` above 0 in the log's indirect mesh draws line, and no `skips a frame by vk_draw.cpp line` for the line after `fallback_record` (@Beanstalk steamdeck, Hyrule Field and Kokiri Forest 2 minutes, the log and a screenshot of each) - A GPU without mesh shaders (RDNA 1 or older): Kokiri Forest for 2 minutes, expecting the vegetation drawn and the same log line above 0 (@Beanstalk a GPU without mesh shaders, Kokiri Forest 2 minutes, the log and a screenshot) - Windows, NVIDIA, defaults (native mesh shaders): Kokiri Forest, expecting nothing changed: the vegetation drawn and the log's line with the draws batched at the game's barriers and 0 for the compute fallback (by hand) - Windows, NVIDIA, `RX_VK_MESH_SHADERS=compute`: the shots above on this PR's build, expecting the vegetation drawn with `RX_VK_MESH_CONV` at its default (by hand) ## Measurements Nothing to measure against main's speed: on the compute fallback this draws again the 40-49 indirect mesh draws a frame that main leaves out (a correctness fix; their cost is the vegetation's own, as before #1846), and with mesh shaders in use nothing changes. ## Risks On the compute fallback the vegetation is drawn again, so a Steam Deck or RADV player's frame rate where there is grass and foliage goes back to what it was before #1846 (lower than main's, which draws none of it). Each such draw's arguments are copied between two full barriers (the `RX_VK_MESH_CONV=1` path #1846 added, with the ring filled with 1s once), as main did per draw before #1846 with a fill as well. With native mesh shaders nothing changes. The log's indirect mesh draws line reads "for the compute fallback (no mesh shaders in use: one by one)" in place of "left as they are (no mesh shaders)"; no script in the tree reads that text. To go back: a revert, or `RX_VK_MESH_CONV=0` (the conversion as before #1846). Nothing changes for saves, `longshot_options.ini` or the caches. ## Checklist ### Ready for review - [x] One topic, on current `main`; the title is a Conventional Commit. - [ ] Tested on my own PC, in the game for a change the game runs, as Testing says. (The bug and the conversion this restores were run in the game on main's build; this PR's own build was not.) - [ ] `mise run test` passes (any failure that also fails on `main` is named). (Only the checks named in Testing ran.) - [x] Measured against `main`, or Measurements says why there is nothing to measure. - [x] No game files, build output or hand-edited generated files; `third_party/` untouched; nothing GPL-incompatible. ### When it applies - [x] A fix: a game-free test that fails on `main` and passes here. - [x] A check under `tests/` that reads changed source is updated, not weakened. - [ ] Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (No build of this head: the two changed renderer files pass a syntax-only compile with the builder's Windows flags. A Linux build is left to someone else.) - [ ] Screenshots of the same spot on `main` and here, for a change that shows on screen. (Taken on main's build with and without the old conversion, described in Testing; not attached.) - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. ### Ready to merge - [ ] Everything in Still to test has run, its results in Tested. - [ ] Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers"). - [ ] Approved in review, every comment answered. - [ ] CI passes on the head; on current `main`, measured again or a comment says why the numbers still hold. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
fix(vk): the compute fallback's indirect mesh draws are converted again, so the Steam Deck and every RADV GPU draw their grass and foliage
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 28s
CI / Workflow lint (actionlint) (pull_request) Successful in 44s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 27s
Third-party parts / As their notes say (pull_request) Successful in 32s
PR description / Description follows the template (pull_request_target) Failing after 16s
CI / Website build and checks (pull_request) Has been cancelled
64c8f00125
#1846 stopped converting indirect mesh draws' arguments where the device has no
mesh shaders in use, on the belief that the compute fallback reads the game's
own records. It does not: fallback_record dispatches each indirect draw's
workgroups from the converted ring (vkCmdDispatchIndirect from mesh_conv_buf)
and leaves the draw out when there is none ("an indirect mesh draw with no
converted arguments is left out"). dev.mesh_shader is false wherever the
fallback runs: every RADV GPU by default (mesh_mode 2, the Steam Deck among
them), cards without mesh shaders, and RX_VK_MESH_SHADERS=compute. There every
GPU-culled mesh draw (grass, ferns, foliage, falling leaves, fireflies) was
left out since #1846.

mesh_indirect_convert converts on those GPUs again, one by one (no batch
there: mesh_conv_batching needs mesh shaders), and counts them for the log's
line ("for the compute fallback"). tests/test_mesh_conv.py checks that the
conversion does not return early without mesh shaders while fallback_record
dispatches from the converted records; it fails on main.

Assisted-by: Claude Code
Co-Authored-By: Claude Opus 5.5 <[email protected]>
BeanBot left a comment

Recommendation: Request changes. Restoring conversion supplies the arguments the compute fallback needs to draw vegetation. The new counter can report conversions that failed, the regression test can pass while the draws are still skipped, and the frame-time cost on Steam Deck is unmeasured.

Restores per-draw indirect argument conversion for Steam Deck, RADV, GPUs without mesh shaders, and forced compute mode. It reuses the existing converter and leaves native batching in place. The fallback again pays for the vegetation, per-draw copies and synchronization, and a 4 MiB argument ring on first use.

Does it help: Unproven on this head. The author's Windows RTX 4070 SUPER comparison on main with compute forced reported 36–49 skipped indirect mesh draws per frame at the default and 40–49 conversions per frame with RX_VK_MESH_CONV=0, with vegetation visible and no skips at the fallback call. This head uses the fill-once copy path by default and has no reported game run or frame-time comparison.
Other systems: RADV and Steam Deck take the changed path in Automatic, as do older GPUs without mesh shaders and GPUs forced to compute. Native NVIDIA and Arc and Windows Navi 2x fallback with mesh shaders enabled retain their existing conversion paths. The draw changes can affect depth, culling and temporal inputs in foliage scenes. Replay still copies counts on the GPU and uses the existing pass and barrier helpers. The diff touches no save, cache, audio, input, build or host-path code. I found no in-tree consumer of the old log wording.
Switches: RX_VK_MESH_CONV keeps numeric default 2, but modes 1 and 2 now convert per draw when mesh shaders are disabled. Restoring conversion by default is required for correctness. The cost of mode 2 on the target hardware is unverified, and its table row should describe the per-draw fallback. Mode 0 still converts per draw and can compare conversion methods. RX_VK_MESH_SHADERS remains Automatic by default. No switches are added or removed.

Reviewed: 64c8f00125 against 80bb1ccc18: Read the base AGENTS.md, CONTRIBUTING.md, PR template, standards and fix-with-test guidance. No review-checklist.md was present. Read the full diff and commit message, tests/test_mesh_conv.py in full, and the relevant sections of vk_draw.cpp and vk_replay.cpp, including the caller, fallback consumer, batch gate, ring initialization, queue flush, barriers and stats reader. Read the device selection and switch definitions. The rest of the large renderer files was outside the reviewed paths. Skimmed #1846's recorded runs and read the supplied test report. No screenshots, raw run logs, comments, reviews, translations or generated changes were supplied. Tooling's separate checkout was unavailable.; nothing run (a code review).
Checked and fine:

  • The change has one topic and the commit includes the AI assistance trailers. The diff contains no game assets, build output, third-party changes or generated files.
  • The compute fallback uses the converted buffer for its first indirect dispatch. A task program's second dispatch still uses the fallback records written by the task stage.
  • Batch construction remains gated on mesh shaders, and the seven counter slots still match the log reader.
  • The Python change uses the standard library and adds no subprocess, download or external action. No renderer interface or shader changes require a version bump or regeneration.

Blocking (to change before merge)

  1. gpu/vk/vk_draw.cpp:7263: The fallback counter increments before argument binding and ring allocation succeed. If the argument buffer cannot be bound or the ring allocation fails, the new log still reports a fallback conversion even though the draw has no converted arguments. Increment it on the successful per-draw path alongside kMcOne.
  2. tests/test_mesh_conv.py:66: The check searches for one spelling of an early return and silently skips the check if the dispatch text changes. For example, replacing the converted-buffer dispatch with a return would leave vegetation missing and let this check pass. Compile the real conversion path with stand-ins and verify that an indirect draw with mesh shaders disabled and mode 2 records the copy, publishes the converted slot and lets the fallback dispatch from it. Keep the negative control against main.
  3. The switch table describes mode 2 as batching at the game's barriers. On Steam Deck Automatic it now converts one draw at a time, so the description omits the behavior this fix ships for those players. Update the RX_VK_MESH_CONV row to state when batching applies and when mode 2 uses per-draw conversion.

Waiting on the author (a run, a measurement or a decision; no edit does it)

  • gpu/vk/vk_draw.cpp:7263: On Steam Deck, a foliage-heavy frame now does per-draw copies and synchronization in addition to the restored draws. First use also allocates a 4 MiB ring and waits for its fill submission. Measure average and 1% low FPS, median and p99 frame time, and first-use cost on Deck or representative RADV hardware using matched, repeated main and head runs. Include an already-rendering baseline such as main at mode 0 to distinguish conversion cost from the cost of drawing the foliage. Record the results in Measurements and Risks.
  • The game evidence compares two modes on main. It leaves the actual head's default unverified, including whether the Deck renders Hyrule Field and Kokiri Forest correctly. Run the head with defaults on Deck and affected Tier 1 configurations, finish the listed Windows native, forced-compute and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux build results, the full suite and head CI, naming any failures shared with main.

Suggestions (the author may take or leave)

  • The repository's fix-with-test guide calls for a failing-test commit followed by the fix. Keep that split when replacing the source check.

Testing: Read-only review. The author reports the targeted checks passing on this head and Windows syntax-only compilation of both changed C++ files. The reported negative control fails on the base. There are no head gameplay results, full platform builds, full suite results or CI results in the supplied evidence.
Overlaps and merge order: #1846 introduced the regression and is already in the base. No pending overlap found in the supplied material or local history.


Automated code review by BeanBot (gpt-6.2-sol), on the pull request's opening. Nothing was run; a maintainer decides.

**Recommendation: Request changes.** Restoring conversion supplies the arguments the compute fallback needs to draw vegetation. The new counter can report conversions that failed, the regression test can pass while the draws are still skipped, and the frame-time cost on Steam Deck is unmeasured. Restores per-draw indirect argument conversion for Steam Deck, RADV, GPUs without mesh shaders, and forced compute mode. It reuses the existing converter and leaves native batching in place. The fallback again pays for the vegetation, per-draw copies and synchronization, and a 4 MiB argument ring on first use. **Does it help:** Unproven on this head. The author's Windows RTX 4070 SUPER comparison on main with compute forced reported 36–49 skipped indirect mesh draws per frame at the default and 40–49 conversions per frame with RX_VK_MESH_CONV=0, with vegetation visible and no skips at the fallback call. This head uses the fill-once copy path by default and has no reported game run or frame-time comparison. **Other systems:** RADV and Steam Deck take the changed path in Automatic, as do older GPUs without mesh shaders and GPUs forced to compute. Native NVIDIA and Arc and Windows Navi 2x fallback with mesh shaders enabled retain their existing conversion paths. The draw changes can affect depth, culling and temporal inputs in foliage scenes. Replay still copies counts on the GPU and uses the existing pass and barrier helpers. The diff touches no save, cache, audio, input, build or host-path code. I found no in-tree consumer of the old log wording. **Switches:** RX_VK_MESH_CONV keeps numeric default 2, but modes 1 and 2 now convert per draw when mesh shaders are disabled. Restoring conversion by default is required for correctness. The cost of mode 2 on the target hardware is unverified, and its table row should describe the per-draw fallback. Mode 0 still converts per draw and can compare conversion methods. RX_VK_MESH_SHADERS remains Automatic by default. No switches are added or removed. **Reviewed:** 64c8f00125bf against 80bb1ccc182d: Read the base AGENTS.md, CONTRIBUTING.md, PR template, standards and fix-with-test guidance. No review-checklist.md was present. Read the full diff and commit message, tests/test_mesh_conv.py in full, and the relevant sections of vk_draw.cpp and vk_replay.cpp, including the caller, fallback consumer, batch gate, ring initialization, queue flush, barriers and stats reader. Read the device selection and switch definitions. The rest of the large renderer files was outside the reviewed paths. Skimmed #1846's recorded runs and read the supplied test report. No screenshots, raw run logs, comments, reviews, translations or generated changes were supplied. Tooling's separate checkout was unavailable.; nothing run (a code review). **Checked and fine:** - The change has one topic and the commit includes the AI assistance trailers. The diff contains no game assets, build output, third-party changes or generated files. - The compute fallback uses the converted buffer for its first indirect dispatch. A task program's second dispatch still uses the fallback records written by the task stage. - Batch construction remains gated on mesh shaders, and the seven counter slots still match the log reader. - The Python change uses the standard library and adds no subprocess, download or external action. No renderer interface or shader changes require a version bump or regeneration. **Blocking** (to change before merge) 1. gpu/vk/vk_draw.cpp:7263: The fallback counter increments before argument binding and ring allocation succeed. If the argument buffer cannot be bound or the ring allocation fails, the new log still reports a fallback conversion even though the draw has no converted arguments. Increment it on the successful per-draw path alongside kMcOne. 2. tests/test_mesh_conv.py:66: The check searches for one spelling of an early return and silently skips the check if the dispatch text changes. For example, replacing the converted-buffer dispatch with a return would leave vegetation missing and let this check pass. Compile the real conversion path with stand-ins and verify that an indirect draw with mesh shaders disabled and mode 2 records the copy, publishes the converted slot and lets the fallback dispatch from it. Keep the negative control against main. 3. The switch table describes mode 2 as batching at the game's barriers. On Steam Deck Automatic it now converts one draw at a time, so the description omits the behavior this fix ships for those players. Update the RX_VK_MESH_CONV row to state when batching applies and when mode 2 uses per-draw conversion. **Waiting on the author** (a run, a measurement or a decision; no edit does it) - gpu/vk/vk_draw.cpp:7263: On Steam Deck, a foliage-heavy frame now does per-draw copies and synchronization in addition to the restored draws. First use also allocates a 4 MiB ring and waits for its fill submission. Measure average and 1% low FPS, median and p99 frame time, and first-use cost on Deck or representative RADV hardware using matched, repeated main and head runs. Include an already-rendering baseline such as main at mode 0 to distinguish conversion cost from the cost of drawing the foliage. Record the results in Measurements and Risks. - The game evidence compares two modes on main. It leaves the actual head's default unverified, including whether the Deck renders Hyrule Field and Kokiri Forest correctly. Run the head with defaults on Deck and affected Tier 1 configurations, finish the listed Windows native, forced-compute and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux build results, the full suite and head CI, naming any failures shared with main. **Suggestions** (the author may take or leave) - The repository's fix-with-test guide calls for a failing-test commit followed by the fix. Keep that split when replacing the source check. **Testing:** Read-only review. The author reports the targeted checks passing on this head and Windows syntax-only compilation of both changed C++ files. The reported negative control fails on the base. There are no head gameplay results, full platform builds, full suite results or CI results in the supplied evidence. **Overlaps and merge order:** #1846 introduced the regression and is already in the base. No pending overlap found in the supplied material or local history. --- <sub>Automated code review by BeanBot (gpt-6.2-sol), on the pull request's opening. Nothing was run; a maintainer decides.</sub>
@ -7261,0 +7260,4 @@
// Deck: Automatic is the compute path there, and dev.mesh_shader false), cards without mesh shaders, RX_VK_MESH_SHADERS=compute.
// There every GPU-culled mesh draw was left out: no grass, ferns, falling leaves or fireflies, and leaf cards whose depth was
// drawn without their colour. No batch there (mesh_conv_batching): each converts here, one by one, as mode 1 does
if (!dev.mesh_shader) st_mc[kMcFallback].fetch_add(1, std::memory_order_relaxed);
Member

Count successful conversions here only after the argument binding and ring allocation succeed. A draw with no converted slot currently increments this counter.

Count successful conversions here only after the argument binding and ring allocation succeed. A draw with no converted slot currently increments this counter.
Member

Please measure Deck frame times and first-use ring setup on main and this head. Include main with mode 0 so the comparison also shows the cost with foliage visible on both sides.

Please measure Deck frame times and first-use ring setup on main and this head. Include main with mode 0 so the comparison also shows the cost with foliage visible on both sides.
@ -60,0 +63,4 @@
# them: the conversion must not stop where the device has no mesh shaders in use, which is where the fallback runs. #1846
# returned there, and the Steam Deck drew no grass)
record = block(draw, "bool fallback_record(VkCommandBuffer cmd, Program& p, const DrawArgs& d) {")
if "vkCmdDispatchIndirect(cmd, mesh_conv_buf, mesh_conv_off);" in record:
Member

Removing the dispatch would make this check skip its assertion. Exercise the real conversion with mesh shaders disabled and mode 2, then assert that the converted slot reaches the fallback dispatch.

Removing the dispatch would make this check skip its assertion. Exercise the real conversion with mesh shaders disabled and mode 2, then assert that the converted slot reaches the fallback dispatch.
GummiNaomi changed title from WIP: fix(vk): the compute fallback's indirect mesh draws are converted again, so the Steam Deck and every RADV GPU draw their grass and foliage to fix(vk): the compute fallback's indirect mesh draws are converted again, so the Steam Deck and every RADV GPU draw their grass and foliage 2026-11-21 00:56:34 +00:00
Owner
@fix
Member

I didn't fix this pull request: it doesn't allow edits from maintainers (the author can turn on Allow edits from maintainers).


Automated fix by BeanBot (gpt-6.1-terra), asked for by HumanBean. Nothing was run; a maintainer decides.

I didn't fix this pull request: it doesn't allow edits from maintainers (the author can turn on *Allow edits from maintainers*). --- <sub>Automated fix by BeanBot (gpt-6.1-terra), asked for by HumanBean. Nothing was run; a maintainer decides.</sub>
Author
Member

@BeanBot you can fix now edits are allowed

@BeanBot you can fix now edits are allowed
Owner
@fix
Member

I didn't fix this pull request: it doesn't allow edits from maintainers (the author can turn on Allow edits from maintainers).


Automated fix by BeanBot (gpt-6.1-terra), asked for by HumanBean. Nothing was run; a maintainer decides.

I didn't fix this pull request: it doesn't allow edits from maintainers (the author can turn on *Allow edits from maintainers*). --- <sub>Automated fix by BeanBot (gpt-6.1-terra), asked for by HumanBean. Nothing was run; a maintainer decides.</sub>
Member
@fix
Member

I changed this pull request as the review asked: the new head is 35e407e0fe.

Changed

  • Fallback conversion counter: Moved the increment beside kMcOne after binding and ring allocation succeed in gpu/vk/vk_draw.cpp:7282.
  • Exercise the real conversion and fallback dispatch: tests/test_mesh_conv.py:91 compiles the selected checkout’s conversion and fallback functions with the stand-ins in tests/mesh_conv_real_test.cpp:1, checking the copy, published slot and dispatch. The --source main negative control remains available. No tests were run.
  • Describe mode 2 conversion: Updated gpu/vk/switches.def:508 to distinguish batching with mesh shaders from per-draw conversion without them.

Still for the author (from the review)

  • gpu/vk/vk_draw.cpp:7263: On Steam Deck, a foliage-heavy frame now does per-draw copies and synchronization in addition to the restored draws. First use also allocates a 4 MiB ring and waits for its fill submission. Measure average and 1% low FPS, median and p99 frame time, and first-use cost on Deck or representative RADV hardware using matched, repeated main and head runs. Include an already-rendering baseline such as main at mode 0 to distinguish conversion cost from the cost of drawing the foliage. Record the results in Measurements and Risks.
  • The game evidence compares two modes on main. It leaves the actual head's default unverified, including whether the Deck renders Hyrule Field and Kokiri Forest correctly. Run the head with defaults on Deck and affected Tier 1 configurations, finish the listed Windows native, forced-compute and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux build results, the full suite and head CI, naming any failures shared with main.

Nothing was built or run: check the change. It will be reviewed again.


Automated fix by BeanBot (gpt-6.1-terra), asked for by llun. Nothing was run; a maintainer decides.

I changed this pull request as the review asked: the new head is 35e407e0fea1. **Changed** - **Fallback conversion counter**: Moved the increment beside kMcOne after binding and ring allocation succeed in gpu/vk/vk_draw.cpp:7282. - **Exercise the real conversion and fallback dispatch**: tests/test_mesh_conv.py:91 compiles the selected checkout’s conversion and fallback functions with the stand-ins in tests/mesh_conv_real_test.cpp:1, checking the copy, published slot and dispatch. The --source main negative control remains available. No tests were run. - **Describe mode 2 conversion**: Updated gpu/vk/switches.def:508 to distinguish batching with mesh shaders from per-draw conversion without them. **Still for the author** (from the review) - gpu/vk/vk_draw.cpp:7263: On Steam Deck, a foliage-heavy frame now does per-draw copies and synchronization in addition to the restored draws. First use also allocates a 4 MiB ring and waits for its fill submission. Measure average and 1% low FPS, median and p99 frame time, and first-use cost on Deck or representative RADV hardware using matched, repeated main and head runs. Include an already-rendering baseline such as main at mode 0 to distinguish conversion cost from the cost of drawing the foliage. Record the results in Measurements and Risks. - The game evidence compares two modes on main. It leaves the actual head's default unverified, including whether the Deck renders Hyrule Field and Kokiri Forest correctly. Run the head with defaults on Deck and affected Tier 1 configurations, finish the listed Windows native, forced-compute and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux build results, the full suite and head CI, naming any failures shared with main. Nothing was built or run: check the change. It will be reviewed again. --- <sub>Automated fix by BeanBot (gpt-6.1-terra), asked for by llun. Nothing was run; a maintainer decides.</sub>
fix(vk): check fallback mesh conversion and clarify its mode
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 9s
PR description / Description follows the template (pull_request_target) Failing after 12s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 12s
CI / Workflow lint (actionlint) (pull_request) Successful in 13s
Third-party parts / As their notes say (pull_request) Successful in 14s
CI / Website build and checks (pull_request) Failing after 22s
35e407e0fe
As the review on #1946 asked.
BeanBot left a comment

Recommendation: Request changes. The conversion, counter, and regression test now look correct on inspection. Steam Deck players regain foliage at the cost of per-draw copies and synchronization whose effect on frame pacing and first use is still unmeasured.

Restores GPU-culled vegetation on the compute fallback by reusing the existing indirect argument converter. The fallback counter now increments after argument binding and ring allocation succeed, and the game-free fixture checks the real conversion and dispatch functions. The restored draws require GPU work, per-draw synchronization, and a 4 MiB argument ring on first use.

Since the last review (on 64c8f00125)
Resolved:

  • gpu/vk/vk_draw.cpp:7263: The fallback counter increments before argument binding and ring allocation succeed. If the argument buffer cannot be bound or the ring allocation fails, the new log still reports a fallback conversion even though the draw has no converted arguments. Increment it on the succ (vk_draw.cpp:7282 increments kMcFallback alongside kMcOne, after binding and ring allocation succeed.)
  • tests/test_mesh_conv.py:66: The check searches for one spelling of an early return and silently skips the check if the dispatch text changes. For example, replacing the converted-buffer dispatch with a return would leave vegetation missing and let this check pass. Compile the real conversion path wi (test_mesh_conv.py:91–106 extracts and compiles both real functions. The fixture checks the copy regions, published slot, and indirect dispatch with mesh shaders disabled at mode 2. --source still selects main for the negative control, where the old early return reaches the first failed assertion by inspection.)
  • The switch table describes mode 2 as batching at the game's barriers. On Steam Deck Automatic it now converts one draw at a time, so the description omits the behavior this fix ships for those players. Update the RX_VK_MESH_CONV row to state when batching applies and when mode 2 uses per-draw conver (switches.def:508 describes batching with mesh shaders and per-draw conversion without them.)
    Still open:
  • gpu/vk/vk_draw.cpp:7263: On Steam Deck, a foliage-heavy frame now does per-draw copies and synchronization in addition to the restored draws. First use also allocates a 4 MiB ring and waits for its fill submission. Measure average and 1% low FPS, median and p99 frame time, and first-use cost on Deck (The reported main-only runs leave the current head's frame-time and first-use cost on Steam Deck or representative RADV hardware unmeasured.)
  • The game evidence compares two modes on main. It leaves the actual head's default unverified, including whether the Deck renders Hyrule Field and Kokiri Forest correctly. Run the head with defaults on Deck and affected Tier 1 configurations, finish the listed Windows native, forced-compute and older (The current head still needs the listed game runs, matched screenshots and logs, Windows and Linux build results, the full suite, and passing head CI.)

Does it help: Unproven on 35e407e0fe. The author's Windows RTX 4070 SUPER run on main with compute forced reported 36–49 skipped indirect mesh draws per frame at mode 2. The same build at mode 0 reported 40–49 conversions per frame, no skips at the fallback call, and visible vegetation. The current head uses the fill-once path by default and has no reported in-game results or matched frame timings.
Other systems: Steam Deck, RADV Automatic, GPUs without mesh shaders, and forced compute use the restored conversion. Native NVIDIA and Intel Arc, and Windows Navi 2x fallback draws with mesh shaders enabled, retain their existing conversion paths by inspection. Restored foliage can change depth and temporal inputs in affected scenes. The seven stats slots still match the replay log, and no in-tree consumer of the old wording was found. Saves, caches, audio, input, and host path handling are outside the changed code.
Switches: RX_VK_MESH_CONV retains default 2. Modes 1 and 2 now convert per draw when mesh shaders are disabled, while mode 2 still batches eligible draws with mesh shaders and the argument rewrite off. The switch table now describes this. Conversion at the default is required for correctness, and its cost on RADV is pending measurement. Mode 0 remains available as a rendering baseline. RX_VK_MESH_SHADERS still defaults to Automatic. No switches were added or removed.

Reviewed: 35e407e0fe against 80bb1ccc18: Read AGENTS.md, CONTRIBUTING.md, the Forgejo PR template, and the fix-with-test guidance in full, and consulted the applicable standards. No local review checklist or sibling Tooling checkout was present. Read both commits, the full PR diff, the changes since 64c8f00125, both test files, srccut.py, and mesh_conv.h. Read the changed renderer sections, conversion and fallback callers, ring initialization, batch gate, device selection, and replay stats reader. The rest of the large renderer files and switch table were outside the reviewed sections. Read the supplied comments, earlier review, and reported results. Raw logs and screenshots were unavailable.; nothing run (a code review).
Checked and fine:

  • The change stays on one topic. The original commit credits AI assistance, and the diff contains no game assets, build output, third-party changes, or generated files.
  • Batch construction still requires mesh shaders. The fallback's first indirect dispatch reads the converted ring, and a task program's second dispatch still reads the task-generated record.
  • The new test compiles local source with the existing compiler selection and runs the fixture in the test's temporary directory. Its actions match the test description.
  • The renderer interface and shaders are untouched, so no API version bump or SPIR-V regeneration is due.

Waiting on the author (a run, a measurement or a decision; no edit does it)

  • gpu/vk/vk_draw.cpp:7263: A foliage-heavy Steam Deck frame now records per-draw argument copies and synchronization as well as the restored draws. First use allocates a 4 MiB ring and waits for its fill submission. Report average and 1% low FPS, median and p99 frame time, and first-use cost from repeated matched main and head runs on Deck or representative RADV hardware. Include main at mode 0 to separate conversion cost from the cost of drawing the foliage, and record the results in Measurements and Risks.
  • The game evidence compares two modes on main. It leaves open whether the current default restores foliage in Hyrule Field and Kokiri Forest on Steam Deck. Run the current head on Deck and affected Tier 1 configurations, complete the listed Windows native, forced-compute, and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux builds, the full suite, and head CI, naming any failures shared with main.

Testing: The initial report lists targeted checks and a Windows syntax-only compile. Those results predate the replacement fixture. Confirm the current fixture passes on 35e407e0fe and fails on main for the missing conversion, then record the required game, build, suite, and CI results. Review was read-only.
Overlaps and merge order: #1846 is already in the base and introduced the early return. No concurrent overlap was identified in the supplied material. The PR is marked unmergeable, with no cause or merge order supplied.


Automated code review by BeanBot (gpt-6.2-sol), asked for by BeanBot, after its fix. Nothing was run; a maintainer decides.

**Recommendation: Request changes.** The conversion, counter, and regression test now look correct on inspection. Steam Deck players regain foliage at the cost of per-draw copies and synchronization whose effect on frame pacing and first use is still unmeasured. Restores GPU-culled vegetation on the compute fallback by reusing the existing indirect argument converter. The fallback counter now increments after argument binding and ring allocation succeed, and the game-free fixture checks the real conversion and dispatch functions. The restored draws require GPU work, per-draw synchronization, and a 4 MiB argument ring on first use. **Since the last review** (on 64c8f00125bf) Resolved: - gpu/vk/vk_draw.cpp:7263: The fallback counter increments before argument binding and ring allocation succeed. If the argument buffer cannot be bound or the ring allocation fails, the new log still reports a fallback conversion even though the draw has no converted arguments. Increment it on the succ (vk_draw.cpp:7282 increments kMcFallback alongside kMcOne, after binding and ring allocation succeed.) - tests/test_mesh_conv.py:66: The check searches for one spelling of an early return and silently skips the check if the dispatch text changes. For example, replacing the converted-buffer dispatch with a return would leave vegetation missing and let this check pass. Compile the real conversion path wi (test_mesh_conv.py:91–106 extracts and compiles both real functions. The fixture checks the copy regions, published slot, and indirect dispatch with mesh shaders disabled at mode 2. --source still selects main for the negative control, where the old early return reaches the first failed assertion by inspection.) - The switch table describes mode 2 as batching at the game's barriers. On Steam Deck Automatic it now converts one draw at a time, so the description omits the behavior this fix ships for those players. Update the RX_VK_MESH_CONV row to state when batching applies and when mode 2 uses per-draw conver (switches.def:508 describes batching with mesh shaders and per-draw conversion without them.) Still open: - gpu/vk/vk_draw.cpp:7263: On Steam Deck, a foliage-heavy frame now does per-draw copies and synchronization in addition to the restored draws. First use also allocates a 4 MiB ring and waits for its fill submission. Measure average and 1% low FPS, median and p99 frame time, and first-use cost on Deck (The reported main-only runs leave the current head's frame-time and first-use cost on Steam Deck or representative RADV hardware unmeasured.) - The game evidence compares two modes on main. It leaves the actual head's default unverified, including whether the Deck renders Hyrule Field and Kokiri Forest correctly. Run the head with defaults on Deck and affected Tier 1 configurations, finish the listed Windows native, forced-compute and older (The current head still needs the listed game runs, matched screenshots and logs, Windows and Linux build results, the full suite, and passing head CI.) **Does it help:** Unproven on 35e407e0fea1. The author's Windows RTX 4070 SUPER run on main with compute forced reported 36–49 skipped indirect mesh draws per frame at mode 2. The same build at mode 0 reported 40–49 conversions per frame, no skips at the fallback call, and visible vegetation. The current head uses the fill-once path by default and has no reported in-game results or matched frame timings. **Other systems:** Steam Deck, RADV Automatic, GPUs without mesh shaders, and forced compute use the restored conversion. Native NVIDIA and Intel Arc, and Windows Navi 2x fallback draws with mesh shaders enabled, retain their existing conversion paths by inspection. Restored foliage can change depth and temporal inputs in affected scenes. The seven stats slots still match the replay log, and no in-tree consumer of the old wording was found. Saves, caches, audio, input, and host path handling are outside the changed code. **Switches:** RX_VK_MESH_CONV retains default 2. Modes 1 and 2 now convert per draw when mesh shaders are disabled, while mode 2 still batches eligible draws with mesh shaders and the argument rewrite off. The switch table now describes this. Conversion at the default is required for correctness, and its cost on RADV is pending measurement. Mode 0 remains available as a rendering baseline. RX_VK_MESH_SHADERS still defaults to Automatic. No switches were added or removed. **Reviewed:** 35e407e0fea1 against 80bb1ccc182d: Read AGENTS.md, CONTRIBUTING.md, the Forgejo PR template, and the fix-with-test guidance in full, and consulted the applicable standards. No local review checklist or sibling Tooling checkout was present. Read both commits, the full PR diff, the changes since 64c8f00125bf, both test files, srccut.py, and mesh_conv.h. Read the changed renderer sections, conversion and fallback callers, ring initialization, batch gate, device selection, and replay stats reader. The rest of the large renderer files and switch table were outside the reviewed sections. Read the supplied comments, earlier review, and reported results. Raw logs and screenshots were unavailable.; nothing run (a code review). **Checked and fine:** - The change stays on one topic. The original commit credits AI assistance, and the diff contains no game assets, build output, third-party changes, or generated files. - Batch construction still requires mesh shaders. The fallback's first indirect dispatch reads the converted ring, and a task program's second dispatch still reads the task-generated record. - The new test compiles local source with the existing compiler selection and runs the fixture in the test's temporary directory. Its actions match the test description. - The renderer interface and shaders are untouched, so no API version bump or SPIR-V regeneration is due. **Waiting on the author** (a run, a measurement or a decision; no edit does it) - gpu/vk/vk_draw.cpp:7263: A foliage-heavy Steam Deck frame now records per-draw argument copies and synchronization as well as the restored draws. First use allocates a 4 MiB ring and waits for its fill submission. Report average and 1% low FPS, median and p99 frame time, and first-use cost from repeated matched main and head runs on Deck or representative RADV hardware. Include main at mode 0 to separate conversion cost from the cost of drawing the foliage, and record the results in Measurements and Risks. - The game evidence compares two modes on main. It leaves open whether the current default restores foliage in Hyrule Field and Kokiri Forest on Steam Deck. Run the current head on Deck and affected Tier 1 configurations, complete the listed Windows native, forced-compute, and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux builds, the full suite, and head CI, naming any failures shared with main. **Testing:** The initial report lists targeted checks and a Windows syntax-only compile. Those results predate the replacement fixture. Confirm the current fixture passes on 35e407e0fea1 and fails on main for the missing conversion, then record the required game, build, suite, and CI results. Review was read-only. **Overlaps and merge order:** #1846 is already in the base and introduced the early return. No concurrent overlap was identified in the supplied material. The PR is marked unmergeable, with no cause or merge order supplied. --- <sub>Automated code review by BeanBot (gpt-6.2-sol), asked for by BeanBot, after its fix. Nothing was run; a maintainer decides.</sub>
@ -7261,1 +7260,4 @@
// Deck: Automatic is the compute path there, and dev.mesh_shader false), cards without mesh shaders, RX_VK_MESH_SHADERS=compute.
// There every GPU-culled mesh draw was left out: no grass, ferns, falling leaves or fireflies, and leaf cards whose depth was
// drawn without their colour. No batch there (mesh_conv_batching): each converts here, one by one, as mode 1 does
if (mode >= 2 && mesh_ring_filled.load(std::memory_order_acquire)) { // (converted at the barrier before it: mesh_conv_batch)
Member

B3 remains open. Please measure frame pacing and the first-use ring fill on Steam Deck or representative RADV hardware. Include main at mode 0 so the comparison separates the converter's cost from drawing the restored foliage.

B3 remains open. Please measure frame pacing and the first-use ring fill on Steam Deck or representative RADV hardware. Include main at mode 0 so the comparison separates the converter's cost from drawing the restored foliage.
Owner
@fix
Member

There is nothing for an edit to fix on this pull request. What stands is for the author:

  • gpu/vk/vk_draw.cpp:7263: A foliage-heavy Steam Deck frame now records per-draw argument copies and synchronization as well as the restored draws. First use allocates a 4 MiB ring and waits for its fill submission. Report average and 1% low FPS, median and p99 frame time, and first-use cost from repeated matched main and head runs on Deck or representative RADV hardware. Include main at mode 0 to separate conversion cost from the cost of drawing the foliage, and record the results in Measurements and Risks.
  • The game evidence compares two modes on main. It leaves open whether the current default restores foliage in Hyrule Field and Kokiri Forest on Steam Deck. Run the current head on Deck and affected Tier 1 configurations, complete the listed Windows native, forced-compute, and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux builds, the full suite, and head CI, naming any failures shared with main.

Automated fix by BeanBot (gpt-6.1-terra), asked for by HumanBean. Nothing was run; a maintainer decides.

There is nothing for an edit to fix on this pull request. What stands is for the author: - gpu/vk/vk_draw.cpp:7263: A foliage-heavy Steam Deck frame now records per-draw argument copies and synchronization as well as the restored draws. First use allocates a 4 MiB ring and waits for its fill submission. Report average and 1% low FPS, median and p99 frame time, and first-use cost from repeated matched main and head runs on Deck or representative RADV hardware. Include main at mode 0 to separate conversion cost from the cost of drawing the foliage, and record the results in Measurements and Risks. - The game evidence compares two modes on main. It leaves open whether the current default restores foliage in Hyrule Field and Kokiri Forest on Steam Deck. Run the current head on Deck and affected Tier 1 configurations, complete the listed Windows native, forced-compute, and older-GPU runs, and attach matched screenshots and logs. Report Windows and Linux builds, the full suite, and head CI, naming any failures shared with main. --- <sub>Automated fix by BeanBot (gpt-6.1-terra), asked for by HumanBean. Nothing was run; a maintainer decides.</sub>
HumanBean deleted branch fix/fallback-mesh-conv 2026-11-21 01:29:33 +00:00
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
4 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!1946
No description provided.