Struct SystemState

pub struct SystemState<Param>
where
    Param: SystemParam + 'static,
{ /* private fields */ }

Holds on to persistent state required to drive SystemParam for a System.

This is a powerful and convenient tool for working with exclusive world access, allowing you to fetch data from the World as if you were running a System. However, simply calling world::run_system(my_system) using a World::run_system can be significantly simpler and ensures that change detection and command flushing work as expected.

Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once, and arbitrary system parameters (like EventWriter) can be conveniently fetched.

For an alternative approach to split mutable access to the world, see World::resource_scope.

Warning

SystemState values created can be cached to improve performance, and must be cached and reused in order for system parameters that rely on local state to work correctly. These include:

• Added and Changed query filters
• Local variables that hold state
• EventReader system parameters, which rely on a Local to track which events have been seen

Note that this is automatically handled for you when using a World::run_system.

Example

Basic usage:

// Work directly on the `World`
let mut world = World::new();
world.init_resource::<Events<MyEvent>>();

// Construct a `SystemState` struct, passing in a tuple of `SystemParam`
// as if you were writing an ordinary system.
let mut system_state: SystemState<(
    EventWriter<MyEvent>,
    Option<ResMut<MyResource>>,
    Query<&MyComponent>,
)> = SystemState::new(&mut world);

// Use system_state.get_mut(&mut world) and unpack your system parameters into variables!
// system_state.get(&world) provides read-only versions of your system parameters instead.
let (event_writer, maybe_resource, query) = system_state.get_mut(&mut world);

// If you are using `Commands`, you can choose when you want to apply them to the world.
// You need to manually call `.apply(world)` on the `SystemState` to apply them.

Caching:

#[derive(Resource)]
struct CachedSystemState {
    event_state: SystemState<EventReader<'static, 'static, MyEvent>>,
}

// Create and store a system state once
let mut world = World::new();
world.init_resource::<Events<MyEvent>>();
let initial_state: SystemState<EventReader<MyEvent>> = SystemState::new(&mut world);

// The system state is cached in a resource
world.insert_resource(CachedSystemState {
    event_state: initial_state,
});

// Later, fetch the cached system state, saving on overhead
world.resource_scope(|world, mut cached_state: Mut<CachedSystemState>| {
    let mut event_reader = cached_state.event_state.get_mut(world);

    for events in event_reader.read() {
        println!("Hello World!");
    }
});

Implementations

impl SystemState<()>

pub fn build_system<Out, Marker, F>(self, func: F) -> FunctionSystem<Marker, F>

where Out: 'static, F: FnMut() -> Out + SystemParamFunction<Marker, Param = (), In = (), Out = Out>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, F>

where Input: SystemInput, Out: 'static, F: FnMut(Input) -> Out + SystemParamFunction<Marker, Param = (), In = Input, Out = Out>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P> SystemState<(P₁, P₂, …, Pₙ)>

where P: SystemParam,

This trait is implemented for tuples up to 17 items long.

pub fn build_system<Out, Marker, F>(self, func: F) -> FunctionSystem<Marker, F>

where Out: 'static, F: FnMut(<P as SystemParam>::Item<'_, '_>) -> Out + SystemParamFunction<Marker, Param = (P,), In = (), Out = Out>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, F>

where Input: SystemInput, Out: 'static, F: FnMut(Input, <P as SystemParam>::Item<'_, '_>) -> Out + SystemParamFunction<Marker, Param = (P,), In = Input, Out = Out>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<Param> SystemState<Param>

where Param: SystemParam,

pub fn new(world: &mut World) -> SystemState<Param>

Creates a new SystemState with default state.

Note

For users of SystemState::get_manual or get_manual_mut:

new does not cache any of the world’s archetypes, so you must call SystemState::update_archetypes manually before calling get_manual{_mut}.

Examples found in repository

examples/async_tasks/async_compute.rs (lines 75-78)

fn spawn_tasks(mut commands: Commands) {
    let thread_pool = AsyncComputeTaskPool::get();
    for x in 0..NUM_CUBES {
        for y in 0..NUM_CUBES {
            for z in 0..NUM_CUBES {
                // Spawn new task on the AsyncComputeTaskPool; the task will be
                // executed in the background, and the Task future returned by
                // spawn() can be used to poll for the result
                let entity = commands.spawn_empty().id();
                let task = thread_pool.spawn(async move {
                    let duration = Duration::from_secs_f32(rand::thread_rng().gen_range(0.05..5.0));

                    // Pretend this is a time-intensive function. :)
                    async_std::task::sleep(duration).await;

                    // Such hard work, all done!
                    let transform = Transform::from_xyz(x as f32, y as f32, z as f32);
                    let mut command_queue = CommandQueue::default();

                    // we use a raw command queue to pass a FnOnce(&mut World) back to be
                    // applied in a deferred manner.
                    command_queue.push(move |world: &mut World| {
                        let (box_mesh_handle, box_material_handle) = {
                            let mut system_state = SystemState::<(
                                Res<BoxMeshHandle>,
                                Res<BoxMaterialHandle>,
                            )>::new(world);
                            let (box_mesh_handle, box_material_handle) =
                                system_state.get_mut(world);

                            (box_mesh_handle.clone(), box_material_handle.clone())
                        };

                        world
                            .entity_mut(entity)
                            // Add our new `Mesh3d` and `MeshMaterial3d` to our tagged entity
                            .insert((
                                Mesh3d(box_mesh_handle),
                                MeshMaterial3d(box_material_handle),
                                transform,
                            ))
                            // Task is complete, so remove task component from entity
                            .remove::<ComputeTransform>();
                    });

                    command_queue
                });

                // Spawn new entity and add our new task as a component
                commands.entity(entity).insert(ComputeTransform(task));
            }
        }
    }
}

pub fn build_any_system<Marker, F>(self, func: F) -> FunctionSystem<Marker, F>

where F: SystemParamFunction<Marker, Param = Param>,

Create a FunctionSystem from a SystemState. This method signature allows any system function, but the compiler will not perform type inference on closure parameters. You can use SystemState::build_system() or SystemState::build_system_with_input() to get type inference on parameters.

Examples found in repository

examples/stress_tests/many_components.rs (line 123)

fn stress_test(num_entities: u32, num_components: u32, num_systems: u32) {
    let mut rng = ChaCha8Rng::seed_from_u64(42);
    let mut app = App::default();
    let world = app.world_mut();

    // register a bunch of components
    let component_ids: Vec<ComponentId> = (1..=num_components)
        .map(|i| {
            world.register_component_with_descriptor(
                // SAFETY:
                // * We don't implement a drop function
                // * u8 is Sync and Send
                unsafe {
                    ComponentDescriptor::new_with_layout(
                        format!("Component{}", i).to_string(),
                        StorageType::Table,
                        Layout::new::<u8>(),
                        None,
                        true, // is mutable
                        ComponentCloneBehavior::Default,
                    )
                },
            )
        })
        .collect();

    // fill the schedule with systems
    let mut schedule = Schedule::new(Update);
    for _ in 1..=num_systems {
        let num_access_components = rng.gen_range(1..10);
        let access_components: Vec<ComponentId> = component_ids
            .choose_multiple(&mut rng, num_access_components)
            .copied()
            .collect();
        let system = (QueryParamBuilder::new(|builder| {
            for &access_component in &access_components {
                if rand::random::<bool>() {
                    builder.mut_id(access_component);
                } else {
                    builder.ref_id(access_component);
                }
            }
        }),)
            .build_state(world)
            .build_any_system(base_system);
        schedule.add_systems((move || access_components.clone()).pipe(system));
    }

    // spawn a bunch of entities
    for _ in 1..=num_entities {
        let num_components = rng.gen_range(1..10);
        let components: Vec<ComponentId> = component_ids
            .choose_multiple(&mut rng, num_components)
            .copied()
            .collect();

        let mut entity = world.spawn_empty();
        // We use `ManuallyDrop` here as we need to avoid dropping the u8's when `values` is dropped
        // since ownership of the values is passed to the world in `insert_by_ids`.
        // But we do want to deallocate the memory when values is dropped.
        let mut values: Vec<ManuallyDrop<u8>> = components
            .iter()
            .map(|_id| ManuallyDrop::new(rng.gen_range(0..255)))
            .collect();
        let ptrs: Vec<OwningPtr> = values
            .iter_mut()
            .map(|value| {
                // SAFETY:
                // * We don't read/write `values` binding after this and values are `ManuallyDrop`,
                // so we have the right to drop/move the values
                unsafe { PtrMut::from(value).promote() }
            })
            .collect();
        // SAFETY:
        // * component_id's are from the same world
        // * `values` was initialized above, so references are valid
        unsafe {
            entity.insert_by_ids(&components, ptrs.into_iter());
        }
    }

    println!(
        "Number of Archetype-Components: {}",
        world.archetypes().archetype_components_len()
    );

    // overwrite Update schedule in the app
    app.add_schedule(schedule);
    app.add_plugins(MinimalPlugins)
        .add_plugins(DiagnosticsPlugin)
        .add_plugins(LogPlugin::default())
        .add_plugins(FrameTimeDiagnosticsPlugin::default())
        .add_plugins(LogDiagnosticsPlugin::filtered(vec![DiagnosticPath::new(
            "fps",
        )]));
    app.run();
}

pub fn meta(&self) -> &SystemMeta

Gets the metadata for this instance.

pub fn meta_mut(&mut self) -> &mut SystemMeta

Gets the metadata for this instance.

pub fn get<'w, 's>( &'s mut self, world: &'w World, ) -> <Param as SystemParam>::Item<'w, 's>

where Param: ReadOnlySystemParam,

Retrieve the SystemParam values. This can only be called when all parameters are read-only.

pub fn get_mut<'w, 's>( &'s mut self, world: &'w mut World, ) -> <Param as SystemParam>::Item<'w, 's>

Retrieve the mutable SystemParam values.

Examples found in repository

examples/async_tasks/async_compute.rs (line 80)

fn spawn_tasks(mut commands: Commands) {
    let thread_pool = AsyncComputeTaskPool::get();
    for x in 0..NUM_CUBES {
        for y in 0..NUM_CUBES {
            for z in 0..NUM_CUBES {
                // Spawn new task on the AsyncComputeTaskPool; the task will be
                // executed in the background, and the Task future returned by
                // spawn() can be used to poll for the result
                let entity = commands.spawn_empty().id();
                let task = thread_pool.spawn(async move {
                    let duration = Duration::from_secs_f32(rand::thread_rng().gen_range(0.05..5.0));

                    // Pretend this is a time-intensive function. :)
                    async_std::task::sleep(duration).await;

                    // Such hard work, all done!
                    let transform = Transform::from_xyz(x as f32, y as f32, z as f32);
                    let mut command_queue = CommandQueue::default();

                    // we use a raw command queue to pass a FnOnce(&mut World) back to be
                    // applied in a deferred manner.
                    command_queue.push(move |world: &mut World| {
                        let (box_mesh_handle, box_material_handle) = {
                            let mut system_state = SystemState::<(
                                Res<BoxMeshHandle>,
                                Res<BoxMaterialHandle>,
                            )>::new(world);
                            let (box_mesh_handle, box_material_handle) =
                                system_state.get_mut(world);

                            (box_mesh_handle.clone(), box_material_handle.clone())
                        };

                        world
                            .entity_mut(entity)
                            // Add our new `Mesh3d` and `MeshMaterial3d` to our tagged entity
                            .insert((
                                Mesh3d(box_mesh_handle),
                                MeshMaterial3d(box_material_handle),
                                transform,
                            ))
                            // Task is complete, so remove task component from entity
                            .remove::<ComputeTransform>();
                    });

                    command_queue
                });

                // Spawn new entity and add our new task as a component
                commands.entity(entity).insert(ComputeTransform(task));
            }
        }
    }
}

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

Applies all state queued up for SystemParam values. For example, this will apply commands queued up by a Commands parameter to the given World. This function should be called manually after the values returned by SystemState::get and SystemState::get_mut are finished being used.

pub unsafe fn validate_param( state: &SystemState<Param>, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>

Wrapper over SystemParam::validate_param.

Safety

• The passed UnsafeWorldCell must have read-only access to world data in archetype_component_access.
• world must be the same World that was used to initialize state.

pub fn matches_world(&self, world_id: WorldId) -> bool

Returns true if world_id matches the World that was used to call SystemState::new. Otherwise, this returns false.

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

Updates the state’s internal view of the World’s archetypes. If this is not called before fetching the parameters, the results may not accurately reflect what is in the world.

This is only required if SystemState::get_manual or SystemState::get_manual_mut is being called, and it only needs to be called if the world has been structurally mutated (i.e. added/removed a component or resource). Users using SystemState::get or SystemState::get_mut do not need to call this as it will be automatically called for them.

pub fn update_archetypes_unsafe_world_cell( &mut self, world: UnsafeWorldCell<'_>, )

Updates the state’s internal view of the world’s archetypes. If this is not called before fetching the parameters, the results may not accurately reflect what is in the world.

This is only required if SystemState::get_manual or SystemState::get_manual_mut is being called, and it only needs to be called if the world has been structurally mutated (i.e. added/removed a component or resource). Users using SystemState::get or SystemState::get_mut do not need to call this as it will be automatically called for them.

Note

This method only accesses world metadata.

pub fn get_manual<'w, 's>( &'s mut self, world: &'w World, ) -> <Param as SystemParam>::Item<'w, 's>

where Param: ReadOnlySystemParam,

Retrieve the SystemParam values. This can only be called when all parameters are read-only. This will not update the state’s view of the world’s archetypes automatically nor increment the world’s change tick.

For this to return accurate results, ensure SystemState::update_archetypes is called before this function.

Users should strongly prefer to use SystemState::get over this function.

pub fn get_manual_mut<'w, 's>( &'s mut self, world: &'w mut World, ) -> <Param as SystemParam>::Item<'w, 's>

Retrieve the mutable SystemParam values. This will not update the state’s view of the world’s archetypes automatically nor increment the world’s change tick.

For this to return accurate results, ensure SystemState::update_archetypes is called before this function.

Users should strongly prefer to use SystemState::get_mut over this function.

pub unsafe fn get_unchecked_manual<'w, 's>( &'s mut self, world: UnsafeWorldCell<'w>, ) -> <Param as SystemParam>::Item<'w, 's>

Retrieve the SystemParam values. This will not update archetypes automatically.

Safety

This call might access any of the input parameters in a way that violates Rust’s mutability rules. Make sure the data access is safe in the context of global World access. The passed-in World must be the World the SystemState was created with.

pub fn param_state(&self) -> &<Param as SystemParam>::State

Returns a reference to the current system param states.

pub unsafe fn param_state_mut(&mut self) -> &mut <Param as SystemParam>::State

Returns a mutable reference to the current system param states. Marked as unsafe because modifying the system states may result in violation to certain assumptions made by the SystemParam. Use with care.

Safety

Modifying the system param states may have unintended consequences. The param state is generally considered to be owned by the SystemParam. Modifications should respect any invariants as required by the SystemParam. For example, modifying the system state of ResMut without also updating SystemMeta::component_access_set will obviously create issues.

Trait Implementations

impl<'a, P> ExclusiveSystemParam for &'a mut SystemState<P>

where P: SystemParam + 'static,

type State = SystemState<P>

Used to store data which persists across invocations of a system.

type Item<'s> = &'s mut SystemState<P>

The item type returned when constructing this system param. See SystemParam::Item.

fn init( world: &mut World, _system_meta: &mut SystemMeta, ) -> <&'a mut SystemState<P> as ExclusiveSystemParam>::State

Creates a new instance of this param’s State.

fn get_param<'s>( state: &'s mut <&'a mut SystemState<P> as ExclusiveSystemParam>::State, _system_meta: &SystemMeta, ) -> <&'a mut SystemState<P> as ExclusiveSystemParam>::Item<'s>

Creates a parameter to be passed into an ExclusiveSystemParamFunction.

impl<Param> FromWorld for SystemState<Param>

where Param: SystemParam,

fn from_world(world: &mut World) -> SystemState<Param>

Creates Self using data from the given World.