Struct specs::world::LazyUpdate
[−]
[src]
pub struct LazyUpdate { /* fields omitted */ }
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 LazyUpdate
mutably.
This resource is added to the world by default.
Methods
impl LazyUpdate
[src]
pub fn create_entity(&self, ent: &EntitiesRes) -> LazyBuilder
[src]
Creates a new LazyBuilder
which inserts components
using LazyUpdate
. 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(&entities) .with(Pos(1.0, 3.0)) .build();
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, LazyUpdate>); fn run(&mut self, (ent, lazy): Self::SystemData) { let a = ent.create(); lazy.insert(a, Pos(1.0, 1.0)); } }
pub fn insert_all<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, LazyUpdate>); fn run(&mut self, (ent, lazy): Self::SystemData) { let a = ent.create(); let b = ent.create(); lazy.insert_all(vec![(a, Pos(3.0, 1.0)), (b, Pos(0.0, 4.0))]); } }
pub fn remove<C>(&self, e: Entity) where
C: Component + Send + Sync,
[src]
C: Component + Send + Sync,
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, LazyUpdate>); fn run(&mut self, (ent, lazy): Self::SystemData) { for entity in ent.join() { lazy.remove::<Pos>(entity); } } }
pub fn exec<F>(&self, f: F) where
F: FnOnce(&World) + 'static + Send + Sync,
[src]
F: FnOnce(&World) + 'static + Send + Sync,
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, LazyUpdate>); 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); } }); } } }
Trait Implementations
impl Default for LazyUpdate
[src]
fn default() -> LazyUpdate
[src]
Returns the "default value" for a type. Read more