Bevy Async Task

A minmum crate for ergonomic abstractions to async programming in Bevy for all platforms. This crate helps to run async tasks in the background and retrieve results in the same system, and helps to block on futures within synchronous contexts.

There is full API support for wasm and native. Android and iOS are untested (Help needed).

Bevy version support

|bevy|bevy-async-task| |---|---| |0.11|1.0, main| |<= 0.10|Unsupported|

Usage

Please see examples for more.

Polling in systems

Poll one task at a time with AsyncTaskRunner<T>:

```rust async fn longtask() -> u32 { sleep(Duration::frommillis(1000)).await; 5 }

fn mysystem(mut taskexecutor: AsyncTaskRunner) { match taskexecutor.poll() { AsnycTaskStatus::Idle => { taskexecutor.begin(long_task()); println!("Started new task!"); } AsnycTaskStatus::Pending => { // } AsnycTaskStatus::Finished(v) => { println!("Received {v}"); } } } ```

Poll many similar tasks simultaneously with AsyncTaskPool<T>:

```rust fn mysystem(mut taskpool: AsyncTaskPool) { if taskpool.isidle() { println!("Queueing 5 tasks..."); for i in 1..=5 { taskpool.spawn(async move { // Closures work too! sleep(Duration::frommillis(i * 1000)).await; i }); } }

for status in task_pool.iter_poll() {
    if let AsyncTaskStatus::Finished(t) = status {
        println!("Received {t}");
    }
}

} ```

Or block on an AsyncTask<T>:

```rust async fn longtask() -> u32 { sleep(Duration::frommillis(1000)).await; 5 }

let task = AsyncTask::new(longtask()); asserteq!(5, task.blocking_recv()); ```

Need to steer manually? Break the task into parts.

rust let task = AsyncTask::new(async move { sleep(Duration::from_millis(1000)).await; 5 }); // Break the task into a runnable future and a receiver let (fut, mut rx) = task.into_parts(); // The receiver will always be `None` until it is polled by Bevy. assert_eq!(None, rx.try_recv()); // Run the future let task_pool = bevy::prelude::AsyncComputeTaskPool::get(); let task = task_pool.spawn(fut); task.detach(); // Forget and run in background // Spin-lock, waiting for the result let result = loop { if let Some(v) = rx.try_recv() { break v; } }; assert_eq!(5, result);

License

This project is dual-licensed under both Apache 2.0 and MIT licenses.