Struct bevy::ecs::prelude::Schedule

pub struct Schedule { /* fields omitted */ }

Implementations

impl Schedule

pub fn with_stage<S>(self, name: &str, stage: S) -> Schedule where
    S: Stage, 

pub fn with_stage_after<S>(self, target: &str, name: &str, stage: S) -> Schedule where
    S: Stage, 

pub fn with_stage_before<S>(
    self,
    target: &str,
    name: &str,
    stage: S
) -> Schedule where
    S: Stage, 

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

pub fn with_system_in_stage<S>(
    self,
    stage_name: &'static str,
    system: S
) -> Schedule where
    S: System<In = (), Out = ()>, 

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, name: &str, stage: S) -> &mut Schedule where
    S: Stage, 

pub fn add_stage_after<S>(
    &mut self,
    target: &str,
    name: &str,
    stage: S
) -> &mut Schedule where
    S: Stage, 

pub fn add_stage_before<S>(
    &mut self,
    target: &str,
    name: &str,
    stage: S
) -> &mut Schedule where
    S: Stage, 

pub fn add_system_to_stage<S>(
    &mut self,
    stage_name: &'static str,
    system: S
) -> &mut Schedule where
    S: System<In = (), Out = ()>, 

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

pub fn get_stage<T>(&self, name: &str) -> Option<&T> where
    T: Stage, 

pub fn get_stage_mut<T>(&mut self, name: &str) -> Option<&mut T> where
    T: Stage, 

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

pub fn initialize_and_run(
    &mut self,
    world: &mut World,
    resources: &mut Resources
)

Shorthand for Schedule::initialize and Schedule::run

Trait Implementations

impl Default for Schedule

pub fn default() -> Schedule

Returns the "default value" for a type.

impl Stage for Schedule

pub fn initialize(&mut self, world: &mut World, resources: &mut Resources)

Stages can perform setup here. Initialize should be called for every stage before calling Stage::run. Initialize will be called once per update, so internally this should avoid re-doing work where possible.

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

Runs the stage. This happens once per update (after Stage::initialize is called).