WIP: fix(vk): a texture the GPU wrote, or whose upload failed, is uploaded again instead of kept stale #1162

Draft
TrashPanda wants to merge 4 commits from TrashPanda/Longshot:fix/texture-upload-fixes into main
Contributor

Type: fix · Risk: medium · Tested on: Linux, RTX 4070 Ti (game-free checks) · Needs: any

Why

Two ways a texture kept old or empty texels: a GPU write into its storage was missed when a later, smaller write landed inside an earlier one, and a texture whose upload failed was left as it was instead of tried again.

Restored from Hookshot 3002, Hookshot 3003, by Joey Magnus, jarynclouatre, and split out of #287 so it can be reviewed and merged on its own.

What changed

texture_gpu_wrote keeps its write records apart, so gpu_wrote_into finds every write under a texture, and a failed upload marks the texture to be uploaded again.

Commits, each with its original author and message:

611955e5 fix(vk): a GPU buffer write into a texture's storage is found under a later, smaller write (jarynclouatre)

texture_gpu_wrote in gpu/vk/vk_texture.cpp notes each GPU buffer
write into guest memory as a record, start to end plus the submission
that wrote it. gpu_wrote_into finds the finished ones a texture was
not uploaded after. It starts at the one record before the texture's
address and walks forward, which is right only when records do not
overlap. The writer erased only the records a new write covered whole,
so a later, smaller write inside an older one left two records that
overlap.

For example, take [0x100000, 0x140000) at submission 10, then
[0x110000, 0x120000) at 11. For a texture at 0x130000, the record
before it is the second one, which ends before the texture, and the
first is never looked at. The texture kept its old texels after the GPU
wrote them.

Change

The writer keeps the records apart:

  • A record the new write lands in keeps its parts before and after it,
    each with its own submission. This applies to the one record that starts
    before the write, and to one that starts inside it and runs past its
    end.
  • Then the new record is added.
  • The "same start, covers it" shortcut stays.
  • The cap of 65536 records is now enforced with a loop, because a write
    inside a record adds two records.

gpu_wrote_into is unchanged.

Testing

  • New tests/test_gpu_write_intervals.py: both functions and the map
    are cut from the source and run on such writes:
  • The texture past the inner write finds 10, one inside it 11, one
    before it 10.
  • With only 10 finished, the outer ones are found and the inner one
    waits.
  • A write that runs past a record's end leaves the record's first part
    with the old submission.
    • A write seen once is not found again, and a later one is.
    • After each write no two records overlap.
    • 100 interior writes into a full map keep it at 65536 records.
  • On main the overlap cases fail. The fixture also compiles with
    llvm-mingw for Windows.
  • Linux renderer built (hookshot_vk.so).
  • Full suite on Linux: 474 passed, 53 skipped, 2 failed, both the same
    on main on this machine (test_bake_portability: zstandard is not
    installed; nx2/test_texture_init_barrier.py: clang++ is not
    installed).
  • No game ran.

Restored-from: https://github.com/NotRexed/Hookshot/pull/3002

cadff79e fix(vk): a texture whose upload failed is tried again, not left empty or stale (jarynclouatre)

When upload() fails in texture_touch (gpu/vk/vk_texture.cpp), for
example for want of staging memory with the VRAM or RAM full, a BC3
texture is tried again 30 frames on (https://github.com/NotRexed/Hookshot/pull/1505). Every other kind was marked
uploaded with upload_gen moved on ("not retried every draw; a write to
its memory tries again"):

  • A first upload that failed left an empty image, drawn as it was until
    the game wrote that memory again, which for most textures is never.
  • A re-upload that failed dropped what the CPU had written since the
    last upload. It also dropped the GPU buffer write gpu_wrote_into had
    just marked as seen.

This is the "textures degrade until a restart" kind of report on cards
with little memory (https://github.com/NotRexed/Hookshot/pull/993's family).

Change

  • One rule for every kind. Texture::bc_retry_frame becomes
    retry_frame.
  • On a failed upload:
    • uploaded and upload_gen stay as they were.
    • gpu_wrote_seen goes back to its value from before this touch.
    • retry_frame is set 30 frames on.
  • A line is logged (40 at most). The BC3 line keeps its text, and the
    other kinds get one like it.
  • The wait moves up, right after the epoch check and before
    gpu_wrote_into and the dirty scan. A waiting texture costs a compare
    and loses nothing.
  • A successful upload clears retry_frame.
  • A texture evicted and made again over storage render targets took has
    its evicted_from_memory entry taken before the upload. If the upload
    fails, the entry is put back. Otherwise the retry would take the texture
    for rendered storage and mark it uploaded, empty.
  • An image no upload takes (no GPU address, multisampled, empty or too
    big, packed depth-stencil) still fails at once, every time. It is still
    marked uploaded, so it is not tried forever. Those checks move from the
    top of upload_inner into upload_never, used by both.
  • Nothing changes while uploads succeed.

Testing

  • New tests/test_upload_retry.py checks the source, because
    texture_touch cannot run outside the renderer:
  • The failed branch marks nothing done, sets the retry, puts
    gpu_wrote_seen back and logs.
  • The wait stands before gpu_wrote_into and the dirty scan, and
    gpu_wrote_seen's old value is taken before it.
    • A success clears the retry.
  • upload_never is shared with upload_inner and still marks those
    images uploaded.
    • A taken evicted_from_memory entry is put back on a failure.
  • It fails on main.
  • tests/test_bc_upload_retry.py follows the rename.
  • Linux renderer built (hookshot_vk.so).
  • Full suite on Linux: 474 passed, 53 skipped, 2 failed, both the same
    on main on this machine (test_bake_portability: zstandard is not
    installed; nx2/test_texture_init_barrier.py: clang++ is not
    installed).
  • Not tested: a failed upload in the game. No card here runs out of
    memory on demand, and no game ran.
  • Not covered: for a texture in a virtual pool (GPU address at or above
    1 << 40), the dirty scan has already taken a remap (page_map,
    map_sig) when the upload fails. The retry uploads what the CPU wrote,
    but not pages that were only remapped. That is the same as before;
    replaying it would mean a whole re-upload of a sparse array while memory
    is short.

Restored-from: https://github.com/NotRexed/Hookshot/pull/3003

c51e9d95 test: the GPU write intervals check builds with main's wrote_regions.h, which the reader asks first (Joey Magnus)

Measurements

Verdict: not measured yet: the writer splits records where it erased them before, and a failed upload is tried again, both on the frame path; a before/after in a texture-heavy area is needed before this is marked ready.

Flags and settings

None.

Testing

Tested: On Linux (kernel 7.0), RTX 4070 Ti, main @ 71b1edd8, this PR @ c51e9d95: the checks that read the changed files (tests/run_all.py --changed origin/main) pass. The full suite (tests/run_all.py) has not been run on this branch yet; a comment will follow when it has.

Not tested: The game. Opened as work in progress until it runs in the game.

Must be tested:

  • Any GPU (by hand): Kokiri Forest, Hyrule Field and a dungeon, 10 minutes, expecting no stale or black textures and no change in fps

Risks

What could break: texture uploads (an extra upload costs time).

Turning it off: revert the commit.

Compatibility: Nothing changes.

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).
  • Measurements has a verdict, or one line saying why there is nothing to measure.
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
  • No game files, dumps, build output or generated files.
  • 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.
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named).

When it applies

  • A game-free test added for the fix, failing on main and passing here.
**Type:** fix · **Risk:** medium · **Tested on:** Linux, RTX 4070 Ti (game-free checks) · **Needs:** any ## Why Two ways a texture kept old or empty texels: a GPU write into its storage was missed when a later, smaller write landed inside an earlier one, and a texture whose upload failed was left as it was instead of tried again. Restored from [Hookshot 3002](https://github.com/NotRexed/Hookshot/pull/3002), [Hookshot 3003](https://github.com/NotRexed/Hookshot/pull/3003), by Joey Magnus, jarynclouatre, and split out of [#287](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/287) so it can be reviewed and merged on its own. ## What changed `texture_gpu_wrote` keeps its write records apart, so `gpu_wrote_into` finds every write under a texture, and a failed upload marks the texture to be uploaded again. Commits, each with its original author and message: <details><summary><code>611955e5</code> fix(vk): a GPU buffer write into a texture's storage is found under a later, smaller write (jarynclouatre)</summary> `texture_gpu_wrote` in `gpu/vk/vk_texture.cpp` notes each GPU buffer write into guest memory as a record, start to end plus the submission that wrote it. `gpu_wrote_into` finds the finished ones a texture was not uploaded after. It starts at the one record before the texture's address and walks forward, which is right only when records do not overlap. The writer erased only the records a new write covered whole, so a later, smaller write inside an older one left two records that overlap. For example, take `[0x100000, 0x140000)` at submission 10, then `[0x110000, 0x120000)` at 11. For a texture at `0x130000`, the record before it is the second one, which ends before the texture, and the first is never looked at. The texture kept its old texels after the GPU wrote them. #### Change The writer keeps the records apart: - A record the new write lands in keeps its parts before and after it, each with its own submission. This applies to the one record that starts before the write, and to one that starts inside it and runs past its end. - Then the new record is added. - The "same start, covers it" shortcut stays. - The cap of 65536 records is now enforced with a loop, because a write inside a record adds two records. `gpu_wrote_into` is unchanged. #### Testing - New `tests/test_gpu_write_intervals.py`: both functions and the map are cut from the source and run on such writes: - The texture past the inner write finds 10, one inside it 11, one before it 10. - With only 10 finished, the outer ones are found and the inner one waits. - A write that runs past a record's end leaves the record's first part with the old submission. - A write seen once is not found again, and a later one is. - After each write no two records overlap. - 100 interior writes into a full map keep it at 65536 records. - On main the overlap cases fail. The fixture also compiles with llvm-mingw for Windows. - Linux renderer built (`hookshot_vk.so`). - Full suite on Linux: 474 passed, 53 skipped, 2 failed, both the same on main on this machine (`test_bake_portability`: `zstandard` is not installed; `nx2/test_texture_init_barrier.py`: `clang++` is not installed). - No game ran. Restored-from: https://github.com/NotRexed/Hookshot/pull/3002 </details> <details><summary><code>cadff79e</code> fix(vk): a texture whose upload failed is tried again, not left empty or stale (jarynclouatre)</summary> When `upload()` fails in `texture_touch` (`gpu/vk/vk_texture.cpp`), for example for want of staging memory with the VRAM or RAM full, a BC3 texture is tried again 30 frames on (https://github.com/NotRexed/Hookshot/pull/1505). Every other kind was marked uploaded with `upload_gen` moved on ("not retried every draw; a write to its memory tries again"): - A first upload that failed left an empty image, drawn as it was until the game wrote that memory again, which for most textures is never. - A re-upload that failed dropped what the CPU had written since the last upload. It also dropped the GPU buffer write `gpu_wrote_into` had just marked as seen. This is the "textures degrade until a restart" kind of report on cards with little memory (https://github.com/NotRexed/Hookshot/pull/993's family). #### Change - One rule for every kind. `Texture::bc_retry_frame` becomes `retry_frame`. - On a failed upload: - `uploaded` and `upload_gen` stay as they were. - `gpu_wrote_seen` goes back to its value from before this touch. - `retry_frame` is set 30 frames on. - A line is logged (40 at most). The BC3 line keeps its text, and the other kinds get one like it. - The wait moves up, right after the epoch check and before `gpu_wrote_into` and the dirty scan. A waiting texture costs a compare and loses nothing. - A successful upload clears `retry_frame`. - A texture evicted and made again over storage render targets took has its `evicted_from_memory` entry taken before the upload. If the upload fails, the entry is put back. Otherwise the retry would take the texture for rendered storage and mark it uploaded, empty. - An image no upload takes (no GPU address, multisampled, empty or too big, packed depth-stencil) still fails at once, every time. It is still marked uploaded, so it is not tried forever. Those checks move from the top of `upload_inner` into `upload_never`, used by both. - Nothing changes while uploads succeed. #### Testing - New `tests/test_upload_retry.py` checks the source, because `texture_touch` cannot run outside the renderer: - The failed branch marks nothing done, sets the retry, puts `gpu_wrote_seen` back and logs. - The wait stands before `gpu_wrote_into` and the dirty scan, and `gpu_wrote_seen`'s old value is taken before it. - A success clears the retry. - `upload_never` is shared with `upload_inner` and still marks those images uploaded. - A taken `evicted_from_memory` entry is put back on a failure. - It fails on main. - `tests/test_bc_upload_retry.py` follows the rename. - Linux renderer built (`hookshot_vk.so`). - Full suite on Linux: 474 passed, 53 skipped, 2 failed, both the same on main on this machine (`test_bake_portability`: `zstandard` is not installed; `nx2/test_texture_init_barrier.py`: `clang++` is not installed). - Not tested: a failed upload in the game. No card here runs out of memory on demand, and no game ran. - Not covered: for a texture in a virtual pool (GPU address at or above 1 << 40), the dirty scan has already taken a remap (`page_map`, `map_sig`) when the upload fails. The retry uploads what the CPU wrote, but not pages that were only remapped. That is the same as before; replaying it would mean a whole re-upload of a sparse array while memory is short. Restored-from: https://github.com/NotRexed/Hookshot/pull/3003 </details> <details><summary><code>c51e9d95</code> test: the GPU write intervals check builds with main's wrote_regions.h, which the reader asks first (Joey Magnus)</summary> </details> ## Measurements **Verdict:** not measured yet: the writer splits records where it erased them before, and a failed upload is tried again, both on the frame path; a before/after in a texture-heavy area is needed before this is marked ready. ### Flags and settings None. ## Testing **Tested:** On Linux (kernel 7.0), RTX 4070 Ti, `main` @ 71b1edd8, this PR @ c51e9d95: `the checks that read the changed files (`tests/run_all.py --changed origin/main`)` pass. The full suite (`tests/run_all.py`) has not been run on this branch yet; a comment will follow when it has. **Not tested:** The game. Opened as work in progress until it runs in the game. **Must be tested:** - Any GPU (by hand): Kokiri Forest, Hyrule Field and a dungeon, 10 minutes, expecting no stale or black textures and no change in fps ## Risks **What could break:** texture uploads (an extra upload costs time). **Turning it off:** revert the commit. **Compatibility:** Nothing changes. ## 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] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [x] No game files, dumps, build output or generated files. - [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. - [ ] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). ### When it applies - [x] A game-free test added for the fix, failing on `main` and passing here.
`texture_gpu_wrote` in `gpu/vk/vk_texture.cpp` notes each GPU buffer
write into guest memory as a record, start to end plus the submission
that wrote it. `gpu_wrote_into` finds the finished ones a texture was
not uploaded after. It starts at the one record before the texture's
address and walks forward, which is right only when records do not
overlap. The writer erased only the records a new write covered whole,
so a later, smaller write inside an older one left two records that
overlap.

For example, take `[0x100000, 0x140000)` at submission 10, then
`[0x110000, 0x120000)` at 11. For a texture at `0x130000`, the record
before it is the second one, which ends before the texture, and the
first is never looked at. The texture kept its old texels after the GPU
wrote them.

## Change

The writer keeps the records apart:
- A record the new write lands in keeps its parts before and after it,
each with its own submission. This applies to the one record that starts
before the write, and to one that starts inside it and runs past its
end.
- Then the new record is added.
- The "same start, covers it" shortcut stays.
- The cap of 65536 records is now enforced with a loop, because a write
inside a record adds two records.

`gpu_wrote_into` is unchanged.

## Testing

- New `tests/test_gpu_write_intervals.py`: both functions and the map
are cut from the source and run on such writes:
- The texture past the inner write finds 10, one inside it 11, one
before it 10.
- With only 10 finished, the outer ones are found and the inner one
waits.
- A write that runs past a record's end leaves the record's first part
with the old submission.
  - A write seen once is not found again, and a later one is.
  - After each write no two records overlap.
  - 100 interior writes into a full map keep it at 65536 records.
- On main the overlap cases fail. The fixture also compiles with
llvm-mingw for Windows.
- Linux renderer built (`hookshot_vk.so`).
- Full suite on Linux: 474 passed, 53 skipped, 2 failed, both the same
on main on this machine (`test_bake_portability`: `zstandard` is not
installed; `nx2/test_texture_init_barrier.py`: `clang++` is not
installed).
- No game ran.

Restored-from: https://github.com/NotRexed/Hookshot/pull/3002
When `upload()` fails in `texture_touch` (`gpu/vk/vk_texture.cpp`), for
example for want of staging memory with the VRAM or RAM full, a BC3
texture is tried again 30 frames on (https://github.com/NotRexed/Hookshot/pull/1505). Every other kind was marked
uploaded with `upload_gen` moved on ("not retried every draw; a write to
its memory tries again"):
- A first upload that failed left an empty image, drawn as it was until
the game wrote that memory again, which for most textures is never.
- A re-upload that failed dropped what the CPU had written since the
last upload. It also dropped the GPU buffer write `gpu_wrote_into` had
just marked as seen.

This is the "textures degrade until a restart" kind of report on cards
with little memory (https://github.com/NotRexed/Hookshot/pull/993's family).

## Change

- One rule for every kind. `Texture::bc_retry_frame` becomes
`retry_frame`.
- On a failed upload:
  - `uploaded` and `upload_gen` stay as they were.
  - `gpu_wrote_seen` goes back to its value from before this touch.
  - `retry_frame` is set 30 frames on.
- A line is logged (40 at most). The BC3 line keeps its text, and the
other kinds get one like it.
- The wait moves up, right after the epoch check and before
`gpu_wrote_into` and the dirty scan. A waiting texture costs a compare
and loses nothing.
- A successful upload clears `retry_frame`.
- A texture evicted and made again over storage render targets took has
its `evicted_from_memory` entry taken before the upload. If the upload
fails, the entry is put back. Otherwise the retry would take the texture
for rendered storage and mark it uploaded, empty.
- An image no upload takes (no GPU address, multisampled, empty or too
big, packed depth-stencil) still fails at once, every time. It is still
marked uploaded, so it is not tried forever. Those checks move from the
top of `upload_inner` into `upload_never`, used by both.
- Nothing changes while uploads succeed.

## Testing

- New `tests/test_upload_retry.py` checks the source, because
`texture_touch` cannot run outside the renderer:
- The failed branch marks nothing done, sets the retry, puts
`gpu_wrote_seen` back and logs.
- The wait stands before `gpu_wrote_into` and the dirty scan, and
`gpu_wrote_seen`'s old value is taken before it.
  - A success clears the retry.
- `upload_never` is shared with `upload_inner` and still marks those
images uploaded.
  - A taken `evicted_from_memory` entry is put back on a failure.
- It fails on main.
- `tests/test_bc_upload_retry.py` follows the rename.
- Linux renderer built (`hookshot_vk.so`).
- Full suite on Linux: 474 passed, 53 skipped, 2 failed, both the same
on main on this machine (`test_bake_portability`: `zstandard` is not
installed; `nx2/test_texture_init_barrier.py`: `clang++` is not
installed).
- Not tested: a failed upload in the game. No card here runs out of
memory on demand, and no game ran.
- Not covered: for a texture in a virtual pool (GPU address at or above
1 << 40), the dirty scan has already taken a remap (`page_map`,
`map_sig`) when the upload fails. The retry uploads what the CPU wrote,
but not pages that were only remapped. That is the same as before;
replaying it would mean a whole re-upload of a sparse array while memory
is short.

Restored-from: https://github.com/NotRexed/Hookshot/pull/3003
test: the GPU write intervals check builds with main's wrote_regions.h, which the reader asks first
Some checks failed
PR description / Description follows the template (pull_request_target) Successful in 6s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
Guide screenshots / Guide images and local UI source review (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
c51e9d9558
Author
Contributor

Tested in game: Linux (Ubuntu 26.04.1, kernel 7.0.0-43), RTX 4070 Ti 12 GB, NVIDIA 595.99.02, Ryzen 7 9800X3D: this branch built together with the other 18 split from #218 and #284-#288, merged onto main @ 71b1edd8 (make_game.py --update, build v3.0.0-rc.5-82-g5952bb3d), then played by a scripted tour through the control bridge (scripts/memtour.py: a save loaded, Zora's Domain, the Market, Hyrule Field and Death Mountain Trail, 40 s each with walking and camera swings). All 4 stops reached, a clean quit, and no device loss or Vulkan error in the log. Textures uploaded and drew through the tour. A failed upload or a later, smaller GPU write into a texture's storage did not come up; the checks cover them.

Tested in game: Linux (Ubuntu 26.04.1, kernel 7.0.0-43), RTX 4070 Ti 12 GB, NVIDIA 595.99.02, Ryzen 7 9800X3D: this branch built together with the other 18 split from #218 and #284-#288, merged onto main @ 71b1edd8 (make_game.py --update, build v3.0.0-rc.5-82-g5952bb3d), then played by a scripted tour through the control bridge (scripts/memtour.py: a save loaded, Zora's Domain, the Market, Hyrule Field and Death Mountain Trail, 40 s each with walking and camera swings). All 4 stops reached, a clean quit, and no device loss or Vulkan error in the log. Textures uploaded and drew through the tour. A failed upload or a later, smaller GPU write into a texture's storage did not come up; the checks cover them.
Collaborator

Possibly related, for context:

  • PR #944 WIP: fix(vk): a texture whose upload failed is tried again, not left empty or stale — Open overlapping PR: failed-upload retry portion
  • PR #797 WIP: perf(vk): a written storage buffer bound again in the same recording is not noted again — Touches same texture GPU-write tracking code
Possibly related, for context: - PR #944 WIP: fix(vk): a texture whose upload failed is tried again, not left empty or stale — Open overlapping PR: failed-upload retry portion - PR #797 WIP: perf(vk): a written storage buffer bound again in the same recording is not noted again — Touches same texture GPU-write tracking code
TrashPanda force-pushed fix/texture-upload-fixes from c51e9d9558
Some checks failed
PR description / Description follows the template (pull_request_target) Successful in 6s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
Guide screenshots / Guide images and local UI source review (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
to 856036459c
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 3s
2026-11-16 19:45:32 +00:00
Compare
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 3s
This pull request has changes conflicting with the target branch.
  • gpu/vk/vk_texture.cpp
Some workflows are waiting to be reviewed.
View command line instructions

Manual merge helper

Use this merge commit message when completing the merge manually.

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u 'fix/texture-upload-fixes:TrashPanda-fix/texture-upload-fixes'
git switch 'TrashPanda-fix/texture-upload-fixes'
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!1162
No description provided.