djeedai / bevy_hanabi / 27885589619

59%

push

github

Grow the sort indirect-dispatch buffer with correct size (#538)

## Problem

With many ribbon effects alive (~260 trailed projectiles), the render
thread crashes:

```
dispatch indirect: buffer uses bytes 3072..3084 which overruns indirect buffer of size 3072
```

(The crash reported in #493.)

## Cause

The sort indirect-dispatch buffer is a growable `GpuBuffer` whose
capacity is tracked in **elements**: `allocate()` may hand out an index
past the current capacity, and `prepare_buffers()` then grows the GPU
buffer to fit.

`GpuBuffer::new_allocated` took the element capacity as a separate
argument, and `SortBindGroups::new` passed the buffer's **byte** size
(3072) there instead of its element count. With 12-byte
`GpuDispatchIndirectArgs` the physical buffer holds 256 elements, while
`GpuBuffer` believed it had 3072 elements of headroom — so
`prepare_buffers()` never grew it. The 257th sort dispatch then read
past the end of the physical buffer (byte 3072 in a 3072-byte buffer),
exactly the reported numbers.

## Fix

Remove the separate capacity argument from `new_allocated` and derive
the element capacity from the physical buffer (`buffer.size() /
item_size`), so the recorded and physical capacities can't disagree.
`new_allocated` has a single caller, which now just sizes the buffer; a
`debug_assert` guards a non-multiple size.

## Testing

Verified in a ribbon-heavy app (every projectile carries a ribbon
trail): pre-fix it crashes reliably once ~256 ribbon sort dispatches are
concurrently active; post-fix it runs well past that as the buffer
grows. `cargo build` passes.

Independent of #537 (stale-buffer overruns in the sort bind-group
*cache*); this is the buffer *growth* bug, #493.

Closes #493

8 of 12 new or added lines in 2 files covered. (66.67%)

5221 of 8918 relevant lines covered (58.54%)

187.85 hits per line