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 AssetEvents schedule.
• Removed assets are not detected.

The list of changed assets only gets updated in the AssetEvents schedule which runs in Last. Therefore, AssetChanged will only pick up asset changes in schedules following AssetEvents or the next frame. Consider adding the system in the Last schedule after AssetEvents 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,

SAFETY: read-only access

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 <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,

SAFETY: ROQueryFetch<Self> is the same as QueryFetch<Self>

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>( world: UnsafeWorldCell<'w>, state: &<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>( fetch: &mut <AssetChanged<A> as WorldQuery>::Fetch<'w>, state: &<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>( 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<ComponentId>, )

Adds any component accesses used by this WorldQuery to access.

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 set_access(_state: &mut Self::State, _access: &FilteredAccess<ComponentId>)

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