Struct valence::prelude::Added

pub struct Added<T>(/* private fields */);

A filter on a component that only retains results the first time after they have been added.

A common use for this filter is one-time initialization.

To retain all results without filtering but still check whether they were added after the system last ran, use Ref<T>.

Note that this includes changes that happened before the first time this Query was run.

Deferred

Note, that entity modifications issued with Commands are visible only after deferred operations are applied, typically at the end of the schedule iteration.

Time complexity

Added is not ArchetypeFilter, which practically means that if the query (with T component filter) matches a million entities, Added<T> filter will iterate over all of them even if none of them were just added.

For example, these two systems are roughly equivalent in terms of performance:

fn system1(q: Query<&MyComponent, Added<Transform>>) {
    for item in &q { /* component added */ }
}

fn system2(q: Query<(&MyComponent, Ref<Transform>)>) {
    for item in &q {
        if item.1.is_added() { /* component added */ }
    }
}

Examples

fn print_add_name_component(query: Query<&Name, Added<Name>>) {
    for name in &query {
        println!("Named entity created: {:?}", name)
    }
}

Trait Implementations

impl<T> QueryFilter for Added<T>

where T: Component,

const IS_ARCHETYPAL: bool = false

Returns true if (and only if) this Filter relies strictly on archetypes to limit which components are accessed by the Query.

unsafe fn filter_fetch( fetch: &mut <Added<T> as WorldQuery>::Fetch<'_>, entity: Entity, table_row: TableRow, ) -> bool

Returns true if the provided Entity and TableRow should be included in the query results. If false, the entity will be skipped.

impl<T> WorldQuery for Added<T>

where T: Component,

SAFETY: fetch accesses a single component in a readonly way. This is sound because update_component_access adds read access for that component and panics when appropriate. update_component_access adds a With filter for a component. This is sound because matches_component_set returns whether the set contains that component.

type Item<'w> = bool

The item returned by this WorldQuery For QueryData this will be the item returned by the query. For QueryFilter this will be either (), or a bool indicating whether the entity should be included or a tuple of such things.

type Fetch<'w> = AddedFetch<'w>

Per archetype/table state used by this WorldQuery to fetch Self::Item

type State = ComponentId

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink<'wlong, 'wshort>( item: <Added<T> as WorldQuery>::Item<'wlong>, ) -> <Added<T> as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, _: &ComponentId, last_run: Tick, this_run: Tick, ) -> <Added<T> as WorldQuery>::Fetch<'w>

Creates a new instance of this fetch.

const IS_DENSE: bool = _

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, WorldQuery::set_table must be used before WorldQuery::fetch can be called for iterators. If this returns false, WorldQuery::set_archetype must be used before WorldQuery::fetch can be called for iterators.

unsafe fn set_archetype<'w>( fetch: &mut <Added<T> as WorldQuery>::Fetch<'w>, component_id: &ComponentId, _archetype: &'w Archetype, table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w>( fetch: &mut <Added<T> as WorldQuery>::Fetch<'w>, _: &ComponentId, table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

unsafe fn fetch<'w>( fetch: &mut <Added<T> as WorldQuery>::Fetch<'w>, entity: Entity, table_row: TableRow, ) -> <Added<T> as WorldQuery>::Item<'w>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with a entity in the current archetype.

fn update_component_access( _: &ComponentId, access: &mut FilteredAccess<ComponentId>, )

Adds any component accesses used by this WorldQuery to access.

fn init_state(world: &mut World) -> ComponentId

Creates and initializes a State for this WorldQuery type.

fn get_state(components: &Components) -> Option<ComponentId>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _: &ComponentId, set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn set_access(_state: &mut Self::State, _access: &FilteredAccess<ComponentId>)

Sets available accesses for implementors with dynamic access such as FilteredEntityRef or FilteredEntityMut.