[−][src]Struct async_ecs::world::Lazy
Lazy updates can be used for world updates that need to borrow a lot of resources
and as such should better be done at the end. They work lazily in the sense that
they are dispatched when calling world.maintain()
.
Lazy updates are dispatched in the order that they are requested. Multiple updates sent from one system may be overridden by updates sent from other systems.
Please note that the provided methods take &self
so there's no need to get
Lazy
mutably. This resource is added to the world by default.
Implementations
impl Lazy
[src]
pub fn exec<F>(&self, f: F) where
F: FnOnce(&mut World) + Send + Sync + 'static,
[src]
F: FnOnce(&mut World) + Send + Sync + 'static,
Lazily executes a closure with world access.
Examples
struct Pos; impl Component for Pos { type Storage = VecStorage<Self>; } struct Execution; impl<'a> System<'a> for Execution { type SystemData = (Entities<'a>, Read<'a, Lazy>); fn run(&mut self, (ent, lazy): Self::SystemData) { for entity in ent.join() { lazy.exec(move |world| { if world.is_alive(entity) { println!("Entity {:?} is alive.", entity); } }); } } }
pub fn exec_async<F>(&self, f: F) where
F: FnOnce(&mut World) -> BoxFuture<'static, ()> + Send + Sync + 'static,
[src]
F: FnOnce(&mut World) -> BoxFuture<'static, ()> + Send + Sync + 'static,
Same as Lazy::exec
but with async response.
pub fn insert<C>(&self, e: Entity, c: C) where
C: Component + Send + Sync,
[src]
C: Component + Send + Sync,
Lazily inserts a component for an entity.
Examples
struct Pos(f32, f32); impl Component for Pos { type Storage = VecStorage<Self>; } struct InsertPos; impl<'a> System<'a> for InsertPos { type SystemData = (Entities<'a>, Read<'a, Lazy>); fn run(&mut self, (ent, lazy): Self::SystemData) { let a = ent.create(); lazy.insert(a, Pos(1.0, 1.0)); } }
pub fn insert_many<C, I>(&self, iter: I) where
C: Component + Send + Sync,
I: IntoIterator<Item = (Entity, C)> + Send + Sync + 'static,
[src]
C: Component + Send + Sync,
I: IntoIterator<Item = (Entity, C)> + Send + Sync + 'static,
Lazily inserts components for entities.
Examples
struct Pos(f32, f32); impl Component for Pos { type Storage = VecStorage<Self>; } struct InsertPos; impl<'a> System<'a> for InsertPos { type SystemData = (Entities<'a>, Read<'a, Lazy>); fn run(&mut self, (ent, lazy): Self::SystemData) { let a = ent.create(); let b = ent.create(); lazy.insert_many(vec![(a, Pos(3.0, 1.0)), (b, Pos(0.0, 4.0))]); } }
pub fn remove<C>(&self, e: Entity) where
C: Component,
[src]
C: Component,
Lazily removes a component.
Examples
struct Pos; impl Component for Pos { type Storage = VecStorage<Self>; } struct RemovePos; impl<'a> System<'a> for RemovePos { type SystemData = (Entities<'a>, Read<'a, Lazy>); fn run(&mut self, (ent, lazy): Self::SystemData) { for entity in ent.join() { lazy.remove::<Pos>(entity); } } }
pub fn remove_many<C, I>(&self, iter: I) where
C: Component,
I: IntoIterator<Item = Entity> + Send + Sync + 'static,
[src]
C: Component,
I: IntoIterator<Item = Entity> + Send + Sync + 'static,
Lazily removes a component.
Examples
struct Pos; impl Component for Pos { type Storage = VecStorage<Self>; } struct RemovePos; impl<'a> System<'a> for RemovePos { type SystemData = (Entities<'a>, Read<'a, Lazy>); fn run(&mut self, (ent, lazy): Self::SystemData) { for entity in ent.join() { lazy.remove::<Pos>(entity); } } }
pub fn create_entity(&self, world: &World) -> LazyBuilder<'_>
[src]
Creates a new LazyBuilder
which inserts components
using Lazy
. This means that the components won't
be available immediately, but only after a maintain
on World
is performed.
Examples
struct Pos(f32, f32); impl Component for Pos { type Storage = VecStorage<Self>; } let my_entity = lazy.create_entity(&world).with(Pos(1.0, 3.0)).build();
pub async fn maintain<'_, '_>(&'_ self, world: &'_ mut World)
[src]
Executes all stored lazy updates
Trait Implementations
impl Clone for Lazy
[src]
pub fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Default for Lazy
[src]
Auto Trait Implementations
impl !RefUnwindSafe for Lazy
impl Send for Lazy
impl Sync for Lazy
impl Unpin for Lazy
impl !UnwindSafe for Lazy
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Any for T where
T: Any,
[src]
T: Any,
pub fn get_type_id(&self) -> TypeId
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Resource for T where
T: Any + Send + Sync,
[src]
T: Any + Send + Sync,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> TryDefault for T where
T: Default,
[src]
T: Default,
pub fn try_default() -> Result<T, String>
[src]
pub fn unwrap_default() -> Self
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,