Struct bvy::Schedule

pub struct Schedule { /* private fields */ }

A container of Stages set to be run in a linear order.

Since Schedule implements the Stage trait, it can be inserted into another schedule. In this way, the properties of the child schedule can be set differently from the parent. For example, it can be set to run only once during app execution, while the parent schedule runs indefinitely.

Implementations

impl Schedule

pub fn with_stage<S>(self, label: impl StageLabel, stage: S) -> Schedule where
    S: Stage, 

Similar to add_stage, but it also returns itself.

pub fn with_stage_after<S>(
    self,
    target: impl StageLabel,
    label: impl StageLabel,
    stage: S
) -> Schedule where
    S: Stage, 

Similar to add_stage_after, but it also returns itself.

pub fn with_stage_before<S>(
    self,
    target: impl StageLabel,
    label: impl StageLabel,
    stage: S
) -> Schedule where
    S: Stage, 

Similar to add_stage_before, but it also returns itself.

pub fn with_run_criteria<S>(self, system: S) -> Schedule where
    S: System<In = (), Out = ShouldRun>, 

pub fn with_system_in_stage<Params>(
    self,
    stage_label: impl StageLabel,
    system: impl IntoSystemDescriptor<Params>
) -> Schedule

Similar to add_system_to_stage, but it also returns itself.

pub fn set_run_criteria<S>(&mut self, system: S) -> &mut Schedule where
    S: System<In = (), Out = ShouldRun>, 

pub fn add_stage<S>(
    &mut self,
    label: impl StageLabel,
    stage: S
) -> &mut Schedule where
    S: Stage, 

Adds the given stage at the last position of the schedule.

Example

schedule.add_stage("my_stage", SystemStage::parallel());

pub fn add_stage_after<S>(
    &mut self,
    target: impl StageLabel,
    label: impl StageLabel,
    stage: S
) -> &mut Schedule where
    S: Stage, 

Adds the given stage immediately after the target stage.

Example

schedule.add_stage_after("target_stage", "my_stage", SystemStage::parallel());

pub fn add_stage_before<S>(
    &mut self,
    target: impl StageLabel,
    label: impl StageLabel,
    stage: S
) -> &mut Schedule where
    S: Stage, 

Adds the given stage immediately before the target stage.

Example

schedule.add_stage_before("target_stage", "my_stage", SystemStage::parallel());

pub fn add_system_to_stage<Params>(
    &mut self,
    stage_label: impl StageLabel,
    system: impl IntoSystemDescriptor<Params>
) -> &mut Schedule

Adds the given system to the stage identified by stage_label.

Example

schedule.add_system_to_stage("my_stage", my_system);

pub fn add_system_set_to_stage(
    &mut self,
    stage_label: impl StageLabel,
    system_set: SystemSet
) -> &mut Schedule

Adds the given system_set to the stage identified by stage_label.

Example

schedule.add_system_set_to_stage(
    "my_stage",
    SystemSet::new()
        .with_system(system_a)
        .with_system(system_b)
        .with_system(system_c)
);

pub fn stage<T, F>(&mut self, label: impl StageLabel, func: F) -> &mut Schedule where
    T: Stage,
    F: FnOnce(&mut T) -> &mut T, 

Fetches the Stage of type T marked with label, then executes the provided func passing the fetched stage to it as an argument.

The func argument should be a function or a closure that accepts a mutable reference to a struct implementing Stage and returns the same type. That means that it should also assume that the stage has already been fetched successfully.

Example

schedule.stage("my_stage", |stage: &mut SystemStage| {
    stage.add_system(my_system)
});

Panics

Panics if label refers to a non-existing stage, or if it’s not of type T.

pub fn get_stage<T>(&self, label: &(dyn StageLabel + 'static)) -> Option<&T> where
    T: Stage, 

Returns a shared reference to the stage identified by label, if it exists.

If the requested stage does not exist, None is returned instead.

Example

let stage = schedule.get_stage::<SystemStage>(&"my_stage").unwrap();

pub fn get_stage_mut<T>(
    &mut self,
    label: &(dyn StageLabel + 'static)
) -> Option<&mut T> where
    T: Stage, 

Returns a unique, mutable reference to the stage identified by label, if it exists.

If the requested stage does not exist, None is returned instead.

Example

let stage = schedule.get_stage_mut::<SystemStage>(&"my_stage").unwrap();

pub fn run_once(&mut self, world: &mut World)

Executes each Stage contained in the schedule, one at a time.

pub fn iter_stages(
    &self
) -> impl Iterator<Item = (&(dyn StageLabel + 'static), &(dyn Stage + 'static))>

Iterates over all of schedule’s stages and their labels, in execution order.

Trait Implementations

impl Default for Schedule

fn default() -> Schedule

Returns the “default value” for a type.

impl Stage for Schedule

fn run(&mut self, world: &mut World)

Runs the stage; this happens once per update. Implementors must initialize all of their state and systems before running the first time.