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.
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.
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();
Lazily inserts a component for an entity.
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.
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.
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.
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.
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| {
world.delete_all();
});
}
}
}
Returns the "default value" for a type. Read more
Executes the destructor for this type. Read more