Struct bevy_defer::AsyncEntityMut

pub struct AsyncEntityMut<'t> { /* private fields */ }

Async version of EntityMut or EntityCommands.

Implementations

impl AsyncEntityMut<'_>

pub fn entity(&self) -> Entity

Obtain the underlying entity.

pub fn reborrow(&self) -> AsyncEntityMut<'_>

Reborrow an AsyncEntityMut to a new lifetime.

pub fn world(&self) -> &AsyncWorldMut

Obtain the underlying AsyncWorldMut

pub fn component<C: Component>(&self) -> AsyncComponent<'_, C>

Get an AsyncComponent on this entity.

Note

This does not mean the component or the entity exists in the world.

pub fn query<T: QueryData>(&self) -> AsyncEntityQuery<'_, T, ()>

Get an AsyncEntityQuery on this entity.

Note

This does not mean the component or the entity exists in the world.

pub fn query_filtered<T: QueryData, F: QueryFilter>( &self ) -> AsyncEntityQuery<'_, T, F>

Get an AsyncEntityQuery on this entity.

Note

This does not mean the component or the entity exists in the world.

impl AsyncEntityMut<'_>

pub fn insert( &self, bundle: impl Bundle ) -> impl Future<Output = Result<(), AsyncFailure>>

Adds a Bundle of components to the entity.

pub fn remove<T: Bundle>( &self ) -> impl Future<Output = Result<(), AsyncFailure>>

Removes any components in the Bundle from the entity.

pub fn retain<T: Bundle>( &self ) -> impl Future<Output = Result<(), AsyncFailure>>

Removes any components except those in the Bundle from the entity.

pub fn take<T: Bundle>( &self ) -> impl Future<Output = Result<Option<T>, AsyncFailure>>

Removes all components in the Bundle from the entity and returns their previous values.

Note: If the entity does not have every component in the bundle, this method will not remove any of them.

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

Spawns an entity with the given bundle and inserts it into the parent entity’s Children.

pub fn add_child(&self, child: Entity) -> impl Future<Output = AsyncResult<()>>

Adds a single child.

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

Despawns the given entity and all its children recursively.

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

Despawns the given entity’s children recursively.

pub fn send<S: SignalId>( &self, data: S::Data ) -> impl Future<Output = AsyncResult<()>>

Send data through a signal on this entity.

pub fn recv<S: SignalId>(&self) -> impl Future<Output = AsyncResult<S::Data>>

Receive data from a signal on this entity.

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<'t> AsyncEntityParam<'t> for AsyncEntityMut<'t>

type Signal = ()

fn fetch_signal(_: &Signals) -> Option<Self::Signal>

If not found, log what’s missing and return None.

fn from_async_context( entity: Entity, executor: &'t Arc<AsyncQueryQueue>, _: Self::Signal ) -> Self

Obtain Self from the async context.

impl Deref for AsyncEntityMut<'_>

type Target = AsyncWorldMut

The resulting type after dereferencing.

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

Dereferences the value.