Struct ComputeShaderPlugin 

pub struct ComputeShaderPlugin {
    pub shader_path: &'static str,
    /* private fields */
}

Bevy plugin that runs compute shader passes once per frame, before any camera renders.

Every buffer registered through ShaderAppExt is visible to both the compute passes and the FullscreenFragmentPlugin shader, at the same @group/@binding. Each binding must be declared with the same access mode (read or read_write) in every shader that uses it.

Only one ComputeShaderPlugin is supported per app. Add it after DefaultPlugins.

Example

struct Particles;

App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(
        ComputeShaderPlugin::new("shaders/particles.wgsl")
            .init_pass("init", Workgroups::over::<Particles>())
            .pass("update", Workgroups::over::<Particles>()),
    )
    .register_gpu_buffer::<Particles, Particle>(0, 0, 1024)
    .run();

Fields

shader_path: &'static str

Path to the compute shader asset (e.g. "shaders/simulation.wgsl").

Implementations

impl ComputeShaderPlugin

pub fn new(shader_path: &'static str) -> Self

Creates a plugin for the compute shader at the given asset path. Add passes with pass and init_pass.

pub fn pass(self, entry: &'static str, workgroups: Workgroups) -> Self

Run the @compute entry point entry every frame. Passes run in the order they are added, and each sees the writes of the passes before it. The same entry point may be added more than once (e.g. for simulation substeps).

pub fn init_pass(self, entry: &'static str, workgroups: Workgroups) -> Self

Run the @compute entry point entry once, on the first frame everything is ready. Every-frame passes don’t start until all init passes have run. Use ComputePasses::rerun to run it again later.

Trait Implementations

impl Plugin for ComputeShaderPlugin

fn build(&self, app: &mut App)

Configures the App to which this plugin is added.

fn ready(&self, _app: &App) -> bool

Has the plugin finished its setup? This can be useful for plugins that need something asynchronous to happen before they can finish their setup, like the initialization of a renderer. Once the plugin is ready, finish should be called.

fn finish(&self, _app: &mut App)

Finish adding this plugin to the App, once all plugins registered are ready. This can be useful for plugins that depends on another plugin asynchronous setup, like the renderer.

fn cleanup(&self, _app: &mut App)

Runs after all plugins are built and finished, but before the app schedule is executed. This can be useful if you have some resource that other plugins need during their build step, but after build you want to remove it and send it to another thread.

fn name(&self) -> &str

Configures a name for the Plugin which is primarily used for checking plugin uniqueness and debugging.

fn is_unique(&self) -> bool

If the plugin can be meaningfully instantiated several times in an App, override this method to return false.