Struct bevy_defer::access::AsyncWorld

pub struct AsyncWorld;

Async version of World or Commands.

This type only works inside a bevy_defer future, calling any function outside of a bevy_defer future or inside a world access function (a closure with World as a parameter) will likely panic.

If you need the functionalities defined here in sync code, see non-send resources AsyncExecutor and QueryQueue.

Implementations

impl AsyncWorld

pub fn asset<A: Asset>(&self, handle: Handle<A>) -> AsyncAsset<A>

Obtain an AsyncAsset from a Handle.

Example

let square = AsyncWorld.load_asset::<Image>("square.png");
AsyncWorld.asset(square.into_handle());

pub fn load_asset<A: Asset>( &self, path: impl Into<AssetPath<'static>> + Send + 'static ) -> AsyncAsset<A>

Load an asset from an AssetPath, equivalent to AssetServer::load. Does not wait for Asset to be loaded.

Panics

If AssetServer does not exist in the world.

Example

let square = AsyncWorld.load_asset::<Image>("square.png");

pub fn load_asset_with_settings<A: Asset, S: Settings>( &self, path: impl Into<AssetPath<'static>> + Send + 'static, f: impl Fn(&mut S) + Send + Sync + 'static ) -> AsyncAsset<A>

Begins loading an Asset of type A stored at path. The given settings function will override the asset’s AssetLoader settings.

pub fn add_asset<A: Asset + 'static>(&self, item: A) -> AccessResult<Handle<A>>

Add an asset and obtain its handle.

impl AsyncWorld

pub fn send_event<E: Event>(&self, event: E) -> AccessResult<EventId<E>>

Send an Event.

pub fn event_stream<E: Event + Clone>(&self) -> EventStream<E>

Create a stream to an Event, requires the corresponding react_to_event system.

This requires Clone and duplicates all events sent in bevy.

impl AsyncWorld

pub fn new() -> Self

Acquire an AsyncWorld, checks if in a bevy_defer future.

Panics

When used outside a bevy_defer future.

Note

You can construct AsyncWorld directly without this error.

pub fn entity(&self, entity: Entity) -> AsyncEntityMut

Obtain an AsyncEntityMut of the entity.

Note

This does not mean the entity exists in the world.

pub fn resource<R: Resource>(&self) -> AsyncResource<R>

Obtain an AsyncResource.

Note

This does not mean the resource exists in the world.

pub fn non_send_resource<R: 'static>(&self) -> AsyncNonSend<R>

Obtain an AsyncNonSend.

Note

This does not mean the resource exists in the world.

pub fn query<Q: QueryData>(&self) -> AsyncQuery<Q>

Obtain an AsyncQuery.

pub fn query_filtered<Q: QueryData, F: QueryFilter>(&self) -> AsyncQuery<Q, F>

Obtain an AsyncQuery.

pub fn now(&self) -> Duration

Obtain duration from init, according to the executor.

pub fn frame_count(&self) -> u32

Obtain frame count since init, according to the executor.

impl AsyncWorld

pub fn apply_command(&self, command: impl Command)

Apply a command.

Use AsyncWorld::run to obtain a result instead.

Example

AsyncWorld.apply_command(|w: &mut World| println!("{:?}", w))

pub fn apply_command_queue(&self, commands: CommandQueue)

Apply a CommandQueue.

Example

let queue = CommandQueue::default();
AsyncWorld.apply_command_queue(queue);

pub fn run<T>(&self, f: impl FnOnce(&mut World) -> T) -> T

Apply a function on the World and obtain the result.

Example

AsyncWorld.run(|w: &mut World| w.resource::<Int>().0)

pub fn watch<T: 'static>( &self, f: impl FnMut(&mut World) -> Option<T> + 'static ) -> ChannelOut<T>

Apply a function on the World, repeat until it returns Some.

Note

Dropping the future will stop the task.

Example

AsyncWorld.watch(|w: &mut World| w.get_resource::<Int>().map(|r| r.0))

pub fn run_schedule(&self, schedule: impl ScheduleLabel) -> AccessResult

Runs a schedule a single time.

Example

AsyncWorld.run_schedule(Update)

pub fn register_system<I: 'static, O: 'static, M, S: IntoSystem<I, O, M> + 'static>( &self, system: S ) -> SystemId<I, O>

Register a system and return a SystemId so it can later be called by run_system.

Example

AsyncWorld.register_system(|time: Res<Time>| println!("{}", time.delta_seconds()))

pub fn run_system<O: 'static>(&self, system: SystemId<(), O>) -> AccessResult<O>

Run a stored system by their SystemId.

Example

let id = AsyncWorld.register_system(|time: Res<Time>| println!("{}", time.delta_seconds()));
AsyncWorld.run_system(id).unwrap();

pub fn run_system_with_input<I: 'static, O: 'static>( &self, system: SystemId<I, O>, input: I ) -> AccessResult<O>

Run a stored system by their SystemId with input.

Example

let id = AsyncWorld.register_system(|input: In<f32>, time: Res<Time>| time.delta_seconds() + *input);
AsyncWorld.run_system_with_input(id, 4.0).unwrap();

pub fn run_cached_system<O: 'static, M, S: IntoSystem<(), O, M> + 'static>( &self, system: S ) -> AccessResult<O>

Run a system that will be stored and reused upon repeated usage.

Note

The system is disambiguated by the type ID of the closure. Be careful not to pass in a fn.

Example

AsyncWorld.run_cached_system(|time: Res<Time>| println!("{}", time.delta_seconds())).unwrap();

pub fn run_cached_system_with_input<I: 'static, O: 'static, M, S: IntoSystem<I, O, M> + 'static>( &self, system: S, input: I ) -> AccessResult<O>

Run a system with input that will be stored and reused upon repeated usage.

Note

The system is disambiguated by the type ID of the closure. Be careful not to pass in a fn.

Example

AsyncWorld.run_cached_system_with_input(|input: In<f32>, time: Res<Time>| time.delta_seconds() + *input, 4.0).unwrap();

pub fn spawn_empty(&self) -> AsyncEntityMut

Spawns a new Entity with no components.

Example

AsyncWorld.spawn_empty()

pub fn spawn_bundle(&self, bundle: impl Bundle) -> AsyncEntityMut

Spawn a new Entity with a given Bundle of components.

Example

AsyncWorld.spawn_bundle(SpriteBundle::default())

pub fn set_state<S: States>(&self, state: S) -> AccessResult<()>

Transition to a new States.

Example

AsyncWorld.set_state(MyState::A)

pub fn get_state<S: States>(&self) -> AccessResult<S>

Obtain a States.

Example

AsyncWorld.get_state::<MyState>()

pub fn in_state<S: States>(&self, state: S) -> ChannelOut<()>

👎Deprecated: Use state_stream instead.

Wait until a States is entered.

Example

AsyncWorld.in_state(MyState::A)

pub fn state_stream<S: States + Clone + Default>(&self) -> SignalStream<S>

Obtain a SignalStream that reacts to changes of a States.

Requires system react_to_state.

pub fn sleep(&self, duration: impl AsSeconds) -> MaybeChannelOut<()>

Pause the future for the duration, according to the Time resource.

Example

AsyncWorld.sleep(5.4).await

pub fn sleep_frames(&self, frames: u32) -> MaybeChannelOut<()>

Pause the future for some frames, according to the FrameCount resource.

Example

AsyncWorld.sleep_frames(12).await

pub fn yield_now(&self) -> impl Future<Output = ()> + 'static

Yield control back to the bevy_defer executor.

Unlike yield_now from futures_lite, the future will be resumed on the next execution point.

pub fn quit(&self)

Shutdown the bevy app.

Example

AsyncWorld.quit()

pub fn typed_signal<T: SignalId>(&self) -> Signal<T::Data>

Obtain or init a signal by SignalId.

Panics

If used outside a bevy_defer future.

Example

let signal = AsyncWorld.typed_signal::<MySignal>();
signal.send(3.14);
signal.poll().await;

pub fn named_signal<T: SignalId>(&self, name: &str) -> Signal<T::Data>

Obtain or init a signal by name and SignalId.

Panics

If used outside a bevy_defer future.

Example

let signal = AsyncWorld.named_signal::<MySignal>("signal 1");
signal.send(3.14);
signal.poll().await;

pub fn spawn_scoped<T: 'static>( &self, fut: impl Future<Output = T> + 'static ) -> impl Future<Output = T>

Spawn a bevy_defer compatible future with a handle.

Handle

The handle can be used to obtain the result, if dropped, the associated future will be dropped by the executor.

Panics

If used outside a bevy_defer future.

pub fn spawn<T: 'static>(&self, fut: impl Future<Output = T> + 'static)

Spawn a bevy_defer compatible future.

The spawned future will not be dropped until finished.

Panics

If used outside a bevy_defer future.

pub fn spawn_log<T: 'static, E: Display + 'static>( &self, fut: impl Future<Output = Result<T, E>> + 'static )

Spawn a bevy_defer compatible future and logs errors.

The spawned future will not be dropped until finished.

Panics

If used outside a bevy_defer future.

impl AsyncWorld

pub async fn spawn_scene(&self, bun: impl Bundle) -> AsyncEntityMut

Spawn a scene and wait for spawning to complete.

Requires react_to_scene_load to function.

impl AsyncWorld

pub fn timed_routine<T: 'static>( &self, f: impl FnMut(&mut World, Duration) -> Option<T> + 'static, cancellation: impl Into<TaskCancellation> ) -> ChannelOutOrCancel<T>

Run a repeatable routine on Update, with access to delta time.

Trait Implementations

impl AsyncWorldParam for AsyncWorld

fn from_async_context(_: &Reactors) -> Option<Self>

Obtain Self from the async context.

fn build_in_async() -> Option<Self>

Construct inside a bevy_defer future.

impl Clone for AsyncWorld

fn clone(&self) -> AsyncWorld

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AsyncWorld

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for AsyncWorld