Struct specs::LazyUpdate

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.

Implementations

impl LazyUpdate

pub fn insert<C>(&self, e: Entity, c: C) where
    C: Send + Sync + Component, 

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: Send + Sync + Component,
    I: Send + Sync + IntoIterator<Item = (Entity, C)> + '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: Send + Sync + 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, 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: Send + Sync + FnOnce(&mut World) + '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, 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);
                }
            });
        }
    }
}

pub fn exec_mut<F>(&self, f: F) where
    F: Send + Sync + FnOnce(&mut World) + 'static, 

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();
            });
        }
    }
}

pub fn create_entity(&self, ent: &EntitiesRes) -> LazyBuilder<'_>

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

impl Default for LazyUpdate

fn default() -> Self

Returns the “default value” for a type.

impl Drop for LazyUpdate

fn drop(&mut self)

Executes the destructor for this type.