c6204279eb
# Objective - Contributes to #15460 - Supersedes #8520 - Fixes #4906 ## Solution - Added a new `web` feature to `bevy`, and several of its crates. - Enabled new `web` feature automatically within crates without `no_std` support. ## Testing - `cargo build --no-default-features --target wasm32v1-none` --- ## Migration Guide When using Bevy crates which _don't_ automatically enable the `web` feature, please enable it when building for the browser. ## Notes - I added [`cfg_if`](https://crates.io/crates/cfg-if) to help manage some of the feature gate gore that this extra feature introduces. It's still pretty ugly, but I think much easier to read. - Certain `wasm` targets (e.g., [wasm32-wasip1](https://doc.rust-lang.org/nightly/rustc/platform-support/wasm32-wasip1.html#wasm32-wasip1)) provide an incomplete implementation for `std`. I have not tested these platforms, but I suspect Bevy's liberal use of usually unsupported features (e.g., threading) will cause these targets to fail. As such, consider `wasm32-unknown-unknown` as the only `wasm` platform with support from Bevy for `std`. All others likely will need to be treated as `no_std` platforms.
84 lines
3.0 KiB
Rust
84 lines
3.0 KiB
Rust
//! Provides a fundamental executor primitive appropriate for the target platform
|
|
//! and feature set selected.
|
|
//! By default, the `async_executor` feature will be enabled, which will rely on
|
|
//! [`async-executor`] for the underlying implementation. This requires `std`,
|
|
//! so is not suitable for `no_std` contexts. Instead, you must use `edge_executor`,
|
|
//! which relies on the alternate [`edge-executor`] backend.
|
|
//!
|
|
//! [`async-executor`]: https://crates.io/crates/async-executor
|
|
//! [`edge-executor`]: https://crates.io/crates/edge-executor
|
|
|
|
use core::{
|
|
fmt,
|
|
panic::{RefUnwindSafe, UnwindSafe},
|
|
};
|
|
use derive_more::{Deref, DerefMut};
|
|
|
|
cfg_if::cfg_if! {
|
|
if #[cfg(feature = "async_executor")] {
|
|
type ExecutorInner<'a> = async_executor::Executor<'a>;
|
|
type LocalExecutorInner<'a> = async_executor::LocalExecutor<'a>;
|
|
} else {
|
|
type ExecutorInner<'a> = crate::edge_executor::Executor<'a, 64>;
|
|
type LocalExecutorInner<'a> = crate::edge_executor::LocalExecutor<'a, 64>;
|
|
}
|
|
}
|
|
|
|
#[cfg(all(feature = "multi_threaded", not(target_arch = "wasm32")))]
|
|
pub use async_task::FallibleTask;
|
|
|
|
/// Wrapper around a multi-threading-aware async executor.
|
|
/// Spawning will generally require tasks to be `Send` and `Sync` to allow multiple
|
|
/// threads to send/receive/advance tasks.
|
|
///
|
|
/// If you require an executor _without_ the `Send` and `Sync` requirements, consider
|
|
/// using [`LocalExecutor`] instead.
|
|
#[derive(Deref, DerefMut, Default)]
|
|
pub struct Executor<'a>(ExecutorInner<'a>);
|
|
|
|
/// Wrapper around a single-threaded async executor.
|
|
/// Spawning wont generally require tasks to be `Send` and `Sync`, at the cost of
|
|
/// this executor itself not being `Send` or `Sync`. This makes it unsuitable for
|
|
/// global statics.
|
|
///
|
|
/// If need to store an executor in a global static, or send across threads,
|
|
/// consider using [`Executor`] instead.
|
|
#[derive(Deref, DerefMut, Default)]
|
|
pub struct LocalExecutor<'a>(LocalExecutorInner<'a>);
|
|
|
|
impl Executor<'_> {
|
|
/// Construct a new [`Executor`]
|
|
#[expect(clippy::allow_attributes, reason = "This lint may not always trigger.")]
|
|
#[allow(dead_code, reason = "not all feature flags require this function")]
|
|
pub const fn new() -> Self {
|
|
Self(ExecutorInner::new())
|
|
}
|
|
}
|
|
|
|
impl LocalExecutor<'_> {
|
|
/// Construct a new [`LocalExecutor`]
|
|
#[expect(clippy::allow_attributes, reason = "This lint may not always trigger.")]
|
|
#[allow(dead_code, reason = "not all feature flags require this function")]
|
|
pub const fn new() -> Self {
|
|
Self(LocalExecutorInner::new())
|
|
}
|
|
}
|
|
|
|
impl UnwindSafe for Executor<'_> {}
|
|
impl RefUnwindSafe for Executor<'_> {}
|
|
|
|
impl UnwindSafe for LocalExecutor<'_> {}
|
|
impl RefUnwindSafe for LocalExecutor<'_> {}
|
|
|
|
impl fmt::Debug for Executor<'_> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("Executor").finish()
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for LocalExecutor<'_> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("LocalExecutor").finish()
|
|
}
|
|
}
|