Struct AssetChanged 

pub struct AssetChanged<A>(/* private fields */)
where
    A: AsAssetId;

Filter that selects entities with an A for an asset that changed after the system last ran, where A is a component that implements AsAssetId.

Unlike Changed<A>, this is true whenever the asset for the A in ResMut<Assets<A>> changed. For example, when a mesh changed through the Assets<Mesh>::get_mut method, AssetChanged<Mesh> will iterate over all entities with the Handle<Mesh> for that mesh. Meanwhile, Changed<Handle<Mesh>> will iterate over no entities.

Swapping the actual A component is a common pattern. So you should check for both AssetChanged<A> and Changed<A> with Or<(Changed<A>, AssetChanged<A>)>.

Quirks

• Asset changes are registered in the AssetEventSystems system set.
• Removed assets are not detected.

The list of changed assets only gets updated in the AssetEventSystems system set, which runs in PostUpdate. Therefore, AssetChanged will only pick up asset changes in schedules following AssetEventSystems or the next frame. Consider adding the system in the Last schedule after AssetEventSystems if you need to react without frame delay to asset changes.

Performance

When at least one A is updated, this will read a hashmap once per entity with an A component. The runtime of the query is proportional to how many entities with an A it matches.

If no A asset updated since the last time the system ran, then no lookups occur.

Trait Implementations

impl<A> QueryFilter for AssetChanged<A>

where A: AsAssetId,

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( state: &<AssetChanged<A> as WorldQuery>::State, fetch: &mut <AssetChanged<A> 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<A> WorldQuery for AssetChanged<A>

where A: AsAssetId,

const IS_DENSE: bool = <&A>::IS_DENSE

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = AssetChangedFetch<'w, A>

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = AssetChangedState<A>

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_fetch<'wlong, 'wshort>( fetch: <AssetChanged<A> as WorldQuery>::Fetch<'wlong>, ) -> <AssetChanged<A> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( world: UnsafeWorldCell<'w>, state: &'s <AssetChanged<A> as WorldQuery>::State, last_run: Tick, this_run: Tick, ) -> <AssetChanged<A> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( fetch: &mut <AssetChanged<A> as WorldQuery>::Fetch<'w>, state: &'s <AssetChanged<A> as WorldQuery>::State, 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, 's>( fetch: &mut <AssetChanged<A> as WorldQuery>::Fetch<'w>, state: &<AssetChanged<A> as WorldQuery>::State, table: &'w Table, )

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

fn update_component_access( state: &<AssetChanged<A> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AssetChanged<A> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, _world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state(world: &mut World) -> AssetChangedState<A>

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AssetChanged<A> as WorldQuery>::State>

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

fn matches_component_set( state: &<AssetChanged<A> as WorldQuery>::State, set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

fn update_archetypes( _state: &mut <AssetChanged<A> as WorldQuery>::State, _world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.