Struct ContiguousComponentTicksMut 

pub struct ContiguousComponentTicksMut<'w> { /* private fields */ }

Data type storing contiguously lying ticks, which may be accessed to mutate.

Retrievable via ContiguousMut::split and probably only useful if you want to use the following methods:

• ContiguousComponentTicksMut::is_changed_iter,
• ContiguousComponentTicksMut::is_added_iter

Implementations

impl<'w> ContiguousComponentTicksMut<'w>

pub fn new( added: &'w mut [Tick], changed: &'w mut [Tick], last_run: Tick, this_run: Tick, caller: MaybeLocation<&'w mut [&'static Location<'static>]>, ) -> Option<ContiguousComponentTicksMut<'w>>

Creates a new ContiguousComponentTicksMut using provided values or returns None if lengths of added, changed and changed_by do not match

This is an advanced feature, ContiguousComponentTicksMuts are designed to be created by engine-internal code and consumed by end-user code.

• added - Ticks that store the tick when the wrapped value was created.
• changed - Ticks that store the last time the wrapped value was changed.
• last_run - A Tick, occurring before this_run, which is used as a reference to determine whether the wrapped value is newly added or changed.
• this_run - A Tick corresponding to the current point in time – “now”.
• caller - Locations that store the location when the wrapper value was changed.

pub fn added(&self) -> &[Tick]

Returns added ticks’ slice.

pub fn changed(&self) -> &[Tick]

Returns changed ticks’ slice.

pub fn changed_by(&self) -> MaybeLocation<&[&'static Location<'static>]>

Returns changed by locations’ slice.

pub fn added_mut(&mut self) -> &mut [Tick]

Returns mutable added ticks’ slice.

pub fn changed_mut(&mut self) -> &mut [Tick]

Returns mutable changed ticks’ slice.

pub fn changed_by_mut( &mut self, ) -> MaybeLocation<&mut [&'static Location<'static>]>

Returns mutable changed by locations’ slice.

pub fn last_run(&self) -> Tick

Returns the tick the system last ran.

pub fn this_run(&self) -> Tick

Returns the tick of the current system’s run.

pub fn is_changed_iter(&self) -> impl Iterator<Item = bool>

Returns an iterator where the i-th item corresponds to whether the i-th component was marked as changed. If the value equals true, then the component was changed.

Example

fn some_system(mut query: Query<&mut A>) {
    for a in query.contiguous_iter_mut().unwrap() {
        let (a_values, a_ticks) = ContiguousMut::split(a);
        for (value, is_changed) in a_values.iter_mut().zip(a_ticks.is_changed_iter()) {
            if is_changed {
                value.0 *= 10;
            }
        }
    }
}

pub fn is_added_iter(&self) -> impl Iterator<Item = bool>

Returns an iterator where the i-th item corresponds to whether the i-th component was marked as added. If the value equals true, then the component was added.

Example

fn some_system(mut query: Query<&mut A>) {
    for a in query.contiguous_iter_mut().unwrap() {
        let (a_values, a_ticks) = ContiguousMut::split(a);
        for (value, is_added) in a_values.iter_mut().zip(a_ticks.is_added_iter()) {
            if is_added {
                value.0 = 10;
            }
        }
    }
}

pub fn mark_all_as_changed(&mut self)

Marks every tick as changed.

pub fn reborrow(&mut self) -> ContiguousComponentTicksMut<'_>

Returns a ContiguousComponentTicksMut with a smaller lifetime.

Trait Implementations

impl<'w> From<ContiguousComponentTicksMut<'w>> for ContiguousComponentTicksRef<'w>

fn from( value: ContiguousComponentTicksMut<'w>, ) -> ContiguousComponentTicksRef<'w>

Converts to this type from the input type.