Struct bevy::ecs::system::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<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 77-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 mut rng = rand::thread_rng();

                    let duration = Duration::from_secs_f32(rng.gen_range(0.05..0.2));

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

                    // 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 FnOne(&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 PbrBundle of components to our tagged entity
                            .insert(PbrBundle {
                                mesh: box_mesh_handle,
                                material: box_material_handle,
                                transform,
                                ..default()
                            })
                            // 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 meta(&self) -> &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 82)

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 mut rng = rand::thread_rng();

                    let duration = Duration::from_secs_f32(rng.gen_range(0.05..0.2));

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

                    // 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 FnOne(&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 PbrBundle of components to our tagged entity
                            .insert(PbrBundle {
                                mesh: box_mesh_handle,
                                material: box_material_handle,
                                transform,
                                ..default()
                            })
                            // 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 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.

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.