Struct AsyncEventWriter 

pub struct AsyncEventWriter<'a, T: Send + 'static> { /* private fields */ }

System parameter for spawning async work whose result is delivered as a T event once it resolves. The friendly front door for combining BackgroundTasks::spawn_async with the Events system, instead of hand-rolling a pending-task resource and poll system per async data source the way GraphicsPlugin does for the GPU backend.

Register the event type with App::add_async_event::<T>() (instead of App::add_event) to make this usable as a system parameter. Reading the result is completely ordinary — just an EventReader<T>, same as any other event; nothing about consuming it differs from a synchronously-sent one. Requires BackgroundTasksPlugin to be registered, since spawn drives its future through BackgroundTasks::spawn_async.

app.add_async_event::<ReadbackDone>();

fn start_readback(events: AsyncEventWriter<ReadbackDone>, backend: Res<WGPUBackend>) {
    let future = backend.readback_buffer(&buf);
    events.spawn(async move { ReadbackDone(future.await) });
}

fn on_readback(mut reader: EventReader<ReadbackDone>) {
    for event in reader.iter() {
        // event.0
    }
}

Implementations

impl<'a, T: Send + 'static> AsyncEventWriter<'a, T>

pub fn spawn(&self, future: impl SpawnableFuture<T>)

Spawn future. Once it resolves, its output is delivered to every EventReader<T> — no matter how many ticks the future takes, and with no need to hold onto a handle or poll anything yourself.

Trait Implementations

impl<T> SystemParam for AsyncEventWriter<'static, T>

where T: Send + Sync + 'static,

type Item<'a> = AsyncEventWriter<'a, T>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

fn requires() -> Vec<RequiredResource>

Resource types this parameter unconditionally needs present to avoid panicking. Used by App to validate — before running a non-convergent stage’s systems — that every hard requirement is already satisfied, failing fast with a clear message instead of panicking deep inside whichever system happens to run first.