Struct SystemStages 

pub struct SystemStages { /* private fields */ }

An ordered collection of SystemStages.

Implementations

impl SystemStages

pub fn with_core_stages() -> Self

Create a SystemStages collection, initialized with a stage for each CoreStage.

pub fn add_system_to_stage<Args, S>( &mut self, label: impl StageLabel, system: S, ) -> &mut Self

where S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,

Add a System to the stage with the given label.

pub fn insert_stage_before<L: StageLabel, S: SystemStage + 'static>( &mut self, label: L, stage: S, ) -> &mut Self

Insert a new stage, before another existing stage

pub fn insert_stage_after<L: StageLabel, S: SystemStage + 'static>( &mut self, label: L, stage: S, ) -> &mut Self

Insert a new stage, after another existing stage

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

Execute the systems on the given world.

pub fn add_startup_system<Args, S>(&mut self, system: S) -> &mut Self

where S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,

👎Deprecated: use .add_system_to_stage(CoreStage::Startup, your_system) instead

Add a system to the CoreStage::Startup stage which specially runs only once, before all other core stages. Inserting CoreStageStartupSystemsRan into the world prevents systems in the startup stage from running.

pub fn add_single_success_system<Args, S>(&mut self, system: S) -> &mut Self

where S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,

👎Deprecated: use `.add_system_to_stage(First, single_success_system(your_system)

Convenience method. Adds a system that will run each frame until it succeeds (returns Some). Uses Option to allow for easy usage of ?. System is added to CoreStage::First.

See also the wrapper function used inside single_success_system.

pub fn init_startup_resource<R: HasSchema + FromWorld>(&mut self) -> &mut Self

Adds a system to CoreStage::Startup that inserts the default value of a resource into the World if it doesn’t already exist.

pub fn add_startup_resource<R: HasSchema>(&mut self, resource: R) -> &mut Self

Adds a system to CoreStage::StartupResource that inserts the given resource into the World if it doesn’t already exist. The resource type is required to have a HasSchema clone implementation to re-insert the resource into the world after the first startup.

Clone Requirement Details

If the type being added implements HasSchema with the derive like so:

#[derive(HasSchema, Default)]
#[schema(no_clone)] // This bypasses HasSchema clone requirements.
struct ResourceBeingInserted;

Then the system being added to the StartupResource system stage will panic when inserting a second time. The startup resource stage only runs once so it is therefore safe to use a type like the example above as long as you don’t plan on removing from the World the StartupSystemStage tag which in this case is CoreStageStartupResourceSystemsRan.

Trait Implementations

impl Debug for SystemStages

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

Formats the value using the given formatter.

impl Default for SystemStages

fn default() -> Self

Returns the “default value” for a type.