Struct ContiguousComponentTicksRef 

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

Data type storing contiguously lying ticks.

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

• ContiguousComponentTicksRef::is_changed_iter,
• ContiguousComponentTicksRef::is_added_iter

Implementations

impl<'w> ContiguousComponentTicksRef<'w>

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

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

This is an advanced feature, ContiguousComponentTicksRefs 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) -> &'w [Tick]

Returns added ticks’ slice.

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

Returns changed ticks’ slice.

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

Returns 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<Ref<A>>) {
    for a in query.contiguous_iter().unwrap() {
        let (a_values, a_ticks) = ContiguousRef::split(a);
        for (value, is_changed) in a_values.iter().zip(a_ticks.is_changed_iter()) {
            if is_changed {
                // do something
            }
        }
    }
}

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<Ref<A>>) {
    for a in query.contiguous_iter().unwrap() {
        let (a_values, a_ticks) = ContiguousRef::split(a);
        for (value, is_added) in a_values.iter().zip(a_ticks.is_added_iter()) {
            if is_added {
                // do something
            }
        }
    }
}

Trait Implementations

impl<'w> Clone for ContiguousComponentTicksRef<'w>

fn clone(&self) -> ContiguousComponentTicksRef<'w>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Converts to this type from the input type.