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 MessageWriter) 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, Changed and Spawned query filters
• Local variables that hold state
• MessageReader system parameters, which rely on a Local to track which messages 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::<Messages<MyMessage>>();

// Construct a `SystemState` struct, passing in a tuple of `SystemParam`
// as if you were writing an ordinary system.
let mut system_state: SystemState<(
    MessageWriter<MyMessage>,
    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 (message_writer, maybe_resource, query) = system_state.get_mut(&mut world).unwrap();

// 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 {
    message_state: SystemState<MessageReader<'static, 'static, MyMessage>>,
}

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

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

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

    for message in message_reader.read() {
        println!("Hello World!");
    }
});

Exclusive System:

fn exclusive_system(world: &mut World, system_state: &mut SystemState<MessageReader<MyMessage>>) {
    let mut message_reader = system_state.get_mut(world).unwrap();

    for message in message_reader.read() {
        println!("Hello World!");
    }
}

Implementations

impl SystemState<()>

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

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

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<InnerIn, In, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, In, Out, F>

where InnerIn: SystemInput + FromInput<In>, In: SystemInput, InnerOut: IntoResult<Out>, F: FnMut(InnerIn) -> InnerOut + SystemParamFunction<Marker, In = InnerIn, Out = InnerOut, Param = ()>,

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 16 items long.

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

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

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<InnerIn, In, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, In, Out, F>

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

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.

Examples found in repository

examples/async_tasks/async_compute.rs (lines 89-92)

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::rng().random_range(0.05..5.0));

                    // Pretend this is a time-intensive function. :)
                    Delay::new(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).unwrap();

                            (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,
                            ));
                    });

                    command_queue
                });

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

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

where In: SystemInput, F: SystemParamFunction<Marker, Param = Param>, <F as SystemParamFunction<Marker>>::In: FromInput<In>, <F as SystemParamFunction<Marker>>::Out: IntoResult<Out>,

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 124)

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
                        false, // has no summary tick
                        ComponentCloneBehavior::Default,
                        None,
                    )
                },
            )
        })
        .collect();

    // fill the schedule with systems
    let mut schedule = Schedule::new(Update);
    for _ in 1..=num_systems {
        let num_access_components = rng.random_range(1..10);
        let access_components: Vec<ComponentId> = component_ids
            .sample(&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.random_range(1..10);
        let components: Vec<ComponentId> = component_ids
            .sample(&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.random_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());
        }
    }

    // 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(HashSet::from_iter([
            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, ) -> Result<<Param as SystemParam>::Item<'w, 's>, SystemParamValidationError>

where Param: ReadOnlySystemParam,

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

Returns an error if system parameter validation fails.

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

Retrieve the mutable SystemParam values.

Returns an error if system parameter validation fails.

Examples found in repository

examples/async_tasks/async_compute.rs (line 94)

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::rng().random_range(0.05..5.0));

                    // Pretend this is a time-intensive function. :)
                    Delay::new(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).unwrap();

                            (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,
                            ));
                    });

                    command_queue
                });

                // 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 unsafe fn get_unchecked<'w, 's>( &'s mut self, world: UnsafeWorldCell<'w>, ) -> Result<<Param as SystemParam>::Item<'w, 's>, SystemParamValidationError>

Retrieve the SystemParam values.

Returns an error if system parameter validation fails.

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 will obviously create issues.

Trait Implementations

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.

impl<P> ReadOnlySystemParam for &mut SystemState<P>

where P: SystemParam + 'static,

impl<P> SystemParam for &mut SystemState<P>

where P: SystemParam + 'static,

type State = SystemState<P>

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

type Item<'world, 'state> = &'state mut SystemState<P>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World) -> <&mut SystemState<P> as SystemParam>::State

Creates a new instance of this param’s State.

fn init_access( _state: &<&mut SystemState<P> as SystemParam>::State, _system_meta: &mut SystemMeta, _system_access: &mut SystemAccess, _world: &mut World, )

Registers any World access used by this SystemParam.

unsafe fn get_param<'world, 'state>( state: &'state mut <&mut SystemState<P> as SystemParam>::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'world>, _change_tick: Tick, ) -> Result<<&mut SystemState<P> as SystemParam>::Item<'world, 'state>, SystemParamValidationError>

Creates a parameter to be passed into a SystemParamFunction.

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during ApplyDeferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next ApplyDeferred.