Struct specs::LazyUpdate [−][src]
pub struct LazyUpdate { /* fields omitted */ }
Expand description
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.
Implementations
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)); } }
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))]); } }
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); } } }
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); } }); } } }
Lazily executes a closure with mutable world access.
This can be used to add a resource to the World
from a system.
Examples
struct Sys; impl<'a> System<'a> for Sys { type SystemData = (Entities<'a>, Read<'a, LazyUpdate>); fn run(&mut self, (ent, lazy): Self::SystemData) { for entity in ent.join() { lazy.exec_mut(move |world| { // complete extermination! world.delete_all(); }); } } }
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();
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for LazyUpdate
impl Send for LazyUpdate
impl Sync for LazyUpdate
impl Unpin for LazyUpdate
impl !UnwindSafe for LazyUpdate
Blanket Implementations
impl<T> Any for T where
T: Any,
impl<T> Any for T where
T: Any,
pub fn get_type_id(&self) -> TypeId
Mutably borrows from an owned value. Read more
Tries to create the default.
Calls try_default
and panics on an error case.