Struct bevy_internal::ecs::query::Changed

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

A filter on a component that only retains results added or mutably dereferenced after the system last ran.

A common use for this filter is avoiding redundant work when values have not changed.

Note that simply mutably dereferencing a component is considered a change (DerefMut). Bevy does not compare components to their previous values.

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

Deferred

Note, that entity modifications issued with Commands (like entity creation or entity component addition or removal) are visible only after deferred operations are applied, typically at the end of the schedule iteration.

Time complexity

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

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

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

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

Examples

fn print_moving_objects_system(query: Query<&Name, Changed<Transform>>) {
    for name in &query {
        println!("Entity Moved: {:?}", name);
    }
}

Trait Implementations

impl<T> QueryFilter for Changed<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 <Changed<T> as WorldQuery>::Fetch<'_>, entity: Entity, table_row: TableRow ) -> bool

Safety

impl<T> WorldQuery for Changed<T>

where T: Component,

SAFETY: fetch accesses a single component in a readonly way. This is sound because update_component_access and update_archetype_component_access add read access for that component and panic 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> = ChangedFetch<'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: <Changed<T> as WorldQuery>::Item<'wlong> ) -> <Changed<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 ) -> <Changed<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 <Changed<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 <Changed<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 <Changed<T> as WorldQuery>::Fetch<'w>, entity: Entity, table_row: TableRow ) -> <Changed<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(world: &World) -> Option<ComponentId>

Attempts to initializes a State for this WorldQuery type.

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.