Minimal compute shader example

[jim-ec]

I am trying to use a compute shader in my Bevy project but I find it very hard to understand how exactly to accomplish that. There is a compute shader example implementing Conway's Game of Life, but it uses textures instead of buffers which does not match my use case.

Bevy seems to have types related to this task such as the StorageBuffer, the problem is that I am not able to find any documentation or code which shows how to use it.

I prepared a minimal example which demonstrates a compute shader doubling a single input integer using just WGPU. It reads and writes the integer from a storage buffer.

It would be great if someone could help me translate that program to use Bevy.

[shaneleonard]

@jim-ec I ran into this same challenge over the weekend. Your minimal wgpu example is insightful -- thank you for preparing that!

I think that the 'proper' way to integrate with Bevy would be to derive the AsBindGroup trait, but that requires adding support for a #[storage_buffer] annotation, which currently doesn't exist. It still leaves an open question around how to properly extract/bind/prepare/queue the buffer in the rendering pipeline. I spent several hours bouncing around in the bevy_render and bevy_pbr crates but didn't come up with anything I'm happy with.

[NiklasEi]

I never used it before, but the AsBindGroup derive macro does support a storage attribute (#6129) which sounds like what you are looking for.

[dennisorlando]

I have also been stuck for like a week on this, an example would be lovely

[Andrewp2]

@dennisorlando @shaneleonard @jim-ec I wrote up an example here: https://github.com/Andrewp2/bevy_compute_example . I'm not 100% this works or is the "bevy way" of handling it but I can see it does successfully get to the dispatch.

[dennisorlando]

Looks good to me, tho I think that half the problem is how to read back the values to CPU. From what I get is that you have to create two buffers, one (A) used by the kernel to write the values and another one (B) that is able to be mapped, thus copying A to B, mapping B and reading the values. I tried doing it in the "run" function of "Node" but it is kind of awkward due to "begin_compute_pass" that takes ownership of RenderContext, which you need in order to perform the buffer copy. You also lose ownership of the RenderDevice which is needed for it's "poll" function, without whom you can't wait for the buffer to be mapped.
I thought about copying A to B and reading B before dispatching the compute workgroups, hoping that the data obtained from previous dispatches would remain in the buffer, but that didn't work for some reason: it is as the compute shader never modified the buffer in the first place. I'll write a snippet:

EDIT: nevermind, I'm not familiar with the as_bind_group () function which bypasses the buffer creation; I'll look at tomorrow 🥲

[dennisorlando]

It's worth mentioning #6550 which does exactly that, only it kind of doesn't work because of the required WgpuFeatures::MAPPABLE_PRIMARY_BUFFERS flag and the fact that it was never merged, thus it's outdated and it doesn't work anymore

[lenlaw]

I'm also interested in 'how to read back the values to CPU' if a solution (or example code) finds it's way here.

[dennisorlando]

Found this nice plugin: https://github.com/kjolnyr/bevy_app_compute
Not sure if I find the time, but looking into it might be useful.

[omninonsense]

#12877 adds an example for this use case now! 🎉

[68317fa2]

There is also this tutorial, which gives a detailed walk-trough over the compute game of life example in bevy. It is especially good, if you have to get a little bit into shaders and bevy render in general. Combined with the gpu readback example, it has a lot of potential.