Struct bevy_ecs::schedule::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: Stage>(self, label: impl StageLabel, stage: S) -> Self

Similar to add_stage, but it also returns itself.

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

Similar to add_stage_after, but it also returns itself.

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

Similar to add_stage_before, but it also returns itself.

pub fn with_run_criteria<S: IntoSystem<(), ShouldRun, P>, P>(
    self,
    system: S
) -> Self

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

Similar to add_system_to_stage, but it also returns itself.

pub fn set_run_criteria<S: IntoSystem<(), ShouldRun, P>, P>(
    &mut self,
    system: S
) -> &mut Self

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

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

Example

// Define a new label for the stage.
#[derive(StageLabel)]
struct MyStage;
// Add a stage with that label to the schedule.
schedule.add_stage(MyStage, SystemStage::parallel());

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

Adds the given stage immediately after the target stage.

Example

// Define a new label for the stage.
#[derive(StageLabel)]
struct NewStage;
// Add a stage with that label to the schedule.
schedule.add_stage_after(TargetStage, NewStage, SystemStage::parallel());

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

Adds the given stage immediately before the target stage.

Example

// Define a new, private label for the stage.
#[derive(StageLabel)]
struct NewStage;
// Add a stage with that label to the schedule.
schedule.add_stage_before(TargetStage, NewStage, SystemStage::parallel());

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

Adds the given system to the stage identified by stage_label.

Example

schedule.add_system_to_stage(MyStage, my_system);

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

Adds the given system_set to the stage identified by stage_label.

Example

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

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

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(MyStage, |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: Stage>(&self, stage_label: impl StageLabel) -> Option<&T>

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>(MyStage).unwrap();

pub fn get_stage_mut<T: Stage>(
    &mut self,
    stage_label: impl StageLabel
) -> Option<&mut T>

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>(MyStage).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 = (StageLabelId, &dyn Stage)>

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

Trait Implementations

impl Debug for Schedule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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.