Struct bevy::ecs::system::ResMut

pub struct ResMut<'a, T>where
    T: Resource + ?Sized,{ /* private fields */ }

Unique mutable borrow of a Resource.

See the Resource documentation for usage.

If you need a shared borrow, use Res instead.

Panics

Panics when used as a SystemParam if the resource does not exist.

Use Option<ResMut<T>> instead if the resource might not always exist.

Implementations

impl<'a, T> ResMut<'a, T>where
    T: Resource + ?Sized,

pub fn into_inner(self) -> &'a mut T

Consume self and return a mutable reference to the contained value while marking self as “changed”.

pub fn map_unchanged<U>(self, f: impl FnOnce(&mut T) -> &mut U) -> Mut<'a, U>where
    U: ?Sized,

Maps to an inner value by applying a function to the contained reference, without flagging a change.

You should never modify the argument passed to the closure – if you want to modify the data without flagging a change, consider using DetectChanges::bypass_change_detection to make your intent explicit.

// When run, zeroes the translation of every entity.
fn reset_positions(mut transforms: Query<&mut Transform>) {
    for transform in &mut transforms {
        // We pinky promise not to modify `t` within the closure.
        // Breaking this promise will result in logic errors, but will never cause undefined behavior.
        let translation = transform.map_unchanged(|t| &mut t.translation);
        // Only reset the translation if it isn't already zero;
        my_utils::set_if_not_equal(translation, Vec2::ZERO);
    }
}

Trait Implementations

impl<'a, T> AsMut<T> for ResMut<'a, T>where
    T: Resource,

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'a, T> AsRef<T> for ResMut<'a, T>where
    T: Resource,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, T> Debug for ResMut<'a, T>where
    T: Resource + Debug + ?Sized,

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

Formats the value using the given formatter.

impl<'a, T> Deref for ResMut<'a, T>where
    T: Resource + ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<ResMut<'a, T> as Deref>::Target

Dereferences the value.

impl<'a, T> DerefMut for ResMut<'a, T>where
    T: Resource + ?Sized,

fn deref_mut(&mut self) -> &mut <ResMut<'a, T> as Deref>::Target

Mutably dereferences the value.

impl<'a, T> DetectChanges for ResMut<'a, T>where
    T: Resource + ?Sized,

type Inner = T

The type contained within this smart pointer

fn is_added(&self) -> bool

Returns true if this value was added after the system last ran.

fn is_changed(&self) -> bool

Returns true if this value was added or mutably dereferenced after the system last ran.

fn set_changed(&mut self)

Flags this value as having been changed.

fn last_changed(&self) -> u32

Returns the change tick recording the previous time this data was changed.

fn set_last_changed(&mut self, last_change_tick: u32)

Manually sets the change tick recording the previous time this data was mutated.

fn bypass_change_detection(
    &mut self
) -> &mut <ResMut<'a, T> as DetectChanges>::Inner

Manually bypasses change detection, allowing you to mutate the underlying value without updating the change tick.

impl<'a, T> From<ResMut<'a, T>> for Mut<'a, T>where
    T: Resource,

fn from(other: ResMut<'a, T>) -> Mut<'a, T>

Convert this ResMut into a Mut. This allows keeping the change-detection feature of Mut while losing the specificity of ResMut for resources.

impl<'w, T> From<ResMut<'w, T>> for Res<'w, T>where
    T: Resource,

fn from(res: ResMut<'w, T>) -> Res<'w, T>

Converts to this type from the input type.

impl<'w, 'a, T> IntoIterator for &'a ResMut<'w, T>where
    T: Resource,
    &'a T: IntoIterator,

type Item = <&'a T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a ResMut<'w, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'w, 'a, T> IntoIterator for &'a mut ResMut<'w, T>where
    T: Resource,
    &'a mut T: IntoIterator,

type Item = <&'a mut T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a mut T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut ResMut<'w, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> SystemParam for ResMut<'a, T>where
    T: Resource,

type Fetch = ResMutState<T>