Struct bevy::ecs::schedule::SystemStage

pub struct SystemStage { /* private fields */ }

Stores and executes systems. Execution order is not defined unless explicitly specified; see SystemDescriptor documentation.

Implementations

impl SystemStage

pub fn report_ambiguities(&self, world: &World)

Logs execution order ambiguities between systems.

The output may be incorrect if this stage has not been initialized with world.

impl SystemStage

pub fn new(
    executor: Box<dyn ParallelSystemExecutor + 'static, Global>
) -> SystemStage

pub fn single<Params>(system: impl IntoSystemDescriptor<Params>) -> SystemStage

pub fn single_threaded() -> SystemStage

pub fn parallel() -> SystemStage

pub fn get_executor<T>(&self) -> Option<&T>where
    T: ParallelSystemExecutor,

pub fn get_executor_mut<T>(&mut self) -> Option<&mut T>where
    T: ParallelSystemExecutor,

pub fn set_executor(
    &mut self,
    executor: Box<dyn ParallelSystemExecutor + 'static, Global>
)

pub fn set_must_read_resource(&mut self, resource_id: ComponentId)

pub fn with_system<Params>(
    self,
    system: impl IntoSystemDescriptor<Params>
) -> SystemStage

pub fn add_system<Params>(
    &mut self,
    system: impl IntoSystemDescriptor<Params>
) -> &mut SystemStage

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

pub fn set_apply_buffers(&mut self, apply_buffers: bool)

pub fn parallel_systems(&self) -> &[SystemContainer]

Topologically sorted parallel systems.

Note that systems won’t be fully-formed until the stage has been run at least once.

pub fn exclusive_at_start_systems(&self) -> &[SystemContainer]

Topologically sorted exclusive systems that want to be run at the start of the stage.

Note that systems won’t be fully-formed until the stage has been run at least once.

pub fn exclusive_at_end_systems(&self) -> &[SystemContainer]

Topologically sorted exclusive systems that want to be run at the end of the stage.

Note that systems won’t be fully-formed until the stage has been run at least once.

pub fn exclusive_before_commands_systems(&self) -> &[SystemContainer]

Topologically sorted exclusive systems that want to be run after parallel systems but before the application of their command buffers.

Note that systems won’t be fully-formed until the stage has been run at least once.

pub fn with_system_set(self, system_set: SystemSet) -> SystemStage

pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut SystemStage

pub fn with_run_criteria<Param, S>(self, system: S) -> SystemStagewhere
    S: IntoSystem<(), ShouldRun, Param>,

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

pub fn with_system_run_criteria(
    self,
    run_criteria: RunCriteriaDescriptor
) -> SystemStage

pub fn add_system_run_criteria(
    &mut self,
    run_criteria: RunCriteriaDescriptor
) -> &mut SystemStage

pub fn vec_system_container_debug(
    &self,
    name: &str,
    v: &Vec<SystemContainer, Global>,
    f: &mut Formatter<'_>
) -> Result<(), Error>

Trait Implementations

impl Debug for SystemStage

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

Formats the value using the given formatter.

impl Stage for SystemStage

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.