Struct bevy_defer::AsyncWorld

pub struct AsyncWorld<'w, 's> { /* private fields */ }

SystemParam for obtaining an AsyncWorldMut.

Methods from Deref<Target = AsyncWorldMut>

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 of the entity.

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 system<P: SystemParam>(&self) -> AsyncSystemParam<'_, P>

Obtain an AsyncSystemParam.

pub fn signal<T: SignalId>( &self, name: impl Into<String> ) -> impl Future<Output = Arc<SignalData<T::Data>>>

Obtain a named signal.

pub fn poll<T: SignalId>( &self, name: impl Into<String> ) -> impl Future<Output = T::Data>

Poll a named signal.

pub fn send<T: SignalId>( &self, name: impl Into<String>, value: T::Data ) -> impl Future<Output = ()>

Send data through a named signal.

pub fn send_event<E: Event>( &self, event: E ) -> impl Future<Output = AsyncResult<EventId<E>>>

Send an Event.

pub fn poll_event<E: Event + Clone>(&self) -> impl Future<Output = E>

Poll an Event.

Note

Only receives events sent after this call.

pub fn poll_events<E: Event + Clone>(&self) -> impl Future<Output = Vec<E>>

Poll Events until done, result must have at least one value.

Note

Only receives events sent after this call.

pub fn apply_command(&self, command: impl Command) -> impl Future<Output = ()>

Applies a command, causing it to mutate the world.

pub fn run<T: Send + 'static>( &self, f: impl FnOnce(&mut World) -> T + Send + 'static ) -> impl Future<Output = T>

Apply a function on the world and obtain the result.

pub fn run_schedule( &self, schedule: impl ScheduleLabel ) -> impl Future<Output = AsyncResult>

Runs the schedule a single time.

pub fn spawn_empty(&self) -> impl Future<Output = Entity>

Spawns a new Entity with no components.

pub fn spawn_bundle(&self, bundle: impl Bundle) -> impl Future<Output = Entity>

Spawn a new Entity with a given Bundle of components.

pub fn set_state<S: States>( &self, state: S ) -> impl Future<Output = AsyncResult<()>>

Transition to a new States.

pub fn get_state<S: States>(&self) -> impl Future<Output = Option<S>>

Obtain a States.

pub fn in_state<S: States>(&self, state: S) -> impl Future<Output = ()>

Wait until a States is entered.

pub fn sleep(&self, duration: Duration) -> impl Future<Output = ()>

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

pub fn quit(&self) -> impl Future<Output = ()>

Shutdown the bevy app.

pub fn asset<A: Asset, T: Send + 'static>( &self, handle: Handle<A>, f: impl FnMut(&A) -> T + Send + 'static ) -> impl Future<Output = AsyncResult<T>>

Run a function on an Asset and obtain the result.

Repeat until the asset is loaded.

pub fn asset_loaded<A: Asset, T: Send + 'static>( &self, handle: Handle<A> ) -> impl Future<Output = AsyncResult<()>>

Wait until an asset is loaded.

Repeat until the asset is loaded.

pub fn load_asset<A: Asset>( &self, path: impl Into<AssetPath<'static>> + Send + 'static ) -> impl Future<Output = AsyncResult<Handle<A>>>

Run a function on an Asset and obtain the result.

pub async fn load_direct<A: Asset, T: Send + 'static>( &self, path: impl Into<AssetPath<'static>> + Send + 'static, f: impl FnMut(&A) -> T + Send + 'static ) -> AsyncResult<T>

Load asset from a AssetPath, then run a function on the loaded Asset to obtain the result.

Trait Implementations

impl Deref for AsyncWorld<'_, '_>

type Target = AsyncWorldMut

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl SystemParam for AsyncWorld<'_, '_>

type State = FetchState

Used to store data which persists across invocations of a system.

type Item<'w, 's> = AsyncWorld<'w, 's>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.

fn new_archetype( state: &mut Self::State, archetype: &Archetype, system_meta: &mut SystemMeta )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during apply_deferred.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

impl<'w, 's> ReadOnlySystemParam for AsyncWorld<'w, 's>

where Res<'w, QueryQueue>: ReadOnlySystemParam, PhantomData<&'s ()>: ReadOnlySystemParam,