Struct bevy_ecs::schedule::Schedule

pub struct Schedule { /* private fields */ }

A collection of systems, and the metadata and executor needed to run them in a certain order under certain conditions.

Example

Here is an example of a Schedule running a “Hello world” system:

fn hello_world() { println!("Hello world!") }

fn main() {
    let mut world = World::new();
    let mut schedule = Schedule::default();
    schedule.add_systems(hello_world);

    schedule.run(&mut world);
}

A schedule can also run several systems in an ordered way:

fn system_one() { println!("System 1 works!") }
fn system_two() { println!("System 2 works!") }
fn system_three() { println!("System 3 works!") }
    
fn main() {
    let mut world = World::new();
    let mut schedule = Schedule::default();
    schedule.add_systems((
        system_two,
        system_one.before(system_two),
        system_three.after(system_two),
    ));

    schedule.run(&mut world);
}

Implementations

impl Schedule

pub fn new(label: impl ScheduleLabel) -> Self

Constructs an empty Schedule.

pub fn label(&self) -> InternedScheduleLabel

Get the InternedScheduleLabel for this Schedule.

pub fn add_systems<M>( &mut self, systems: impl IntoSystemConfigs<M> ) -> &mut Self

Add a collection of systems to the schedule.

pub fn ignore_ambiguity<M1, M2, S1, S2>(&mut self, a: S1, b: S2) -> &mut Self

where S1: IntoSystemSet<M1>, S2: IntoSystemSet<M2>,

Suppress warnings and errors that would result from systems in these sets having ambiguities (conflicting access but indeterminate order) with systems in set.

pub fn configure_sets(&mut self, sets: impl IntoSystemSetConfigs) -> &mut Self

Configures a collection of system sets in this schedule, adding them if they does not exist.

pub fn set_build_settings( &mut self, settings: ScheduleBuildSettings ) -> &mut Self

Changes miscellaneous build settings.

pub fn get_build_settings(&self) -> ScheduleBuildSettings

Returns the schedule’s current ScheduleBuildSettings.

pub fn get_executor_kind(&self) -> ExecutorKind

Returns the schedule’s current execution strategy.

pub fn set_executor_kind(&mut self, executor: ExecutorKind) -> &mut Self

Sets the schedule’s execution strategy.

pub fn set_apply_final_deferred( &mut self, apply_final_deferred: bool ) -> &mut Self

Set whether the schedule applies deferred system buffers on final time or not. This is a catch-all in case a system uses commands but was not explicitly ordered before an instance of apply_deferred. By default this setting is true, but may be disabled if needed.

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

Runs all systems in this schedule on the world, using its current execution strategy.

pub fn initialize( &mut self, world: &mut World ) -> Result<(), ScheduleBuildError>

Initializes any newly-added systems and conditions, rebuilds the executable schedule, and re-initializes the executor.

Moves all systems and run conditions out of the ScheduleGraph.

pub fn graph(&self) -> &ScheduleGraph

Returns the ScheduleGraph.

pub fn graph_mut(&mut self) -> &mut ScheduleGraph

Returns a mutable reference to the ScheduleGraph.

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

Directly applies any accumulated Deferred system parameters (like Commands) to the world.

Like always, deferred system parameters are applied in the “topological sort order” of the schedule graph. As a result, buffers from one system are only guaranteed to be applied before those of other systems if there is an explicit system ordering between the two systems.

This is used in rendering to extract data from the main world, storing the data in system buffers, before applying their buffers in a different world.

pub fn systems( &self ) -> Result<impl Iterator<Item = (NodeId, &BoxedSystem)> + Sized, ScheduleNotInitialized>

Returns an iterator over all systems in this schedule.

Note: this method will return ScheduleNotInitialized if the schedule has never been initialized or run.

pub fn systems_len(&self) -> usize

Returns the number of systems in this schedule.

Trait Implementations

impl Default for Schedule

fn default() -> Self

Creates a schedule with a default label. Only use in situations where you don’t care about the ScheduleLabel. Inserting a default schedule into the world risks overwriting another schedule. For most situations you should use Schedule::new.