bevy_ecs::query

Trait WorldQuery

Source
pub unsafe trait WorldQuery {
    type Item<'a>;
    type Fetch<'a>: Clone;
    type State: Send + Sync + Sized;

    const IS_DENSE: bool;

    // Required methods
    fn shrink<'wlong: 'wshort, 'wshort>(
        item: Self::Item<'wlong>,
    ) -> Self::Item<'wshort>;
    unsafe fn init_fetch<'w>(
        world: UnsafeWorldCell<'w>,
        state: &Self::State,
        last_run: Tick,
        this_run: Tick,
    ) -> Self::Fetch<'w>;
    unsafe fn set_archetype<'w>(
        fetch: &mut Self::Fetch<'w>,
        state: &Self::State,
        archetype: &'w Archetype,
        table: &'w Table,
    );
    unsafe fn set_table<'w>(
        fetch: &mut Self::Fetch<'w>,
        state: &Self::State,
        table: &'w Table,
    );
    unsafe fn fetch<'w>(
        fetch: &mut Self::Fetch<'w>,
        entity: Entity,
        table_row: TableRow,
    ) -> Self::Item<'w>;
    fn update_component_access(
        state: &Self::State,
        access: &mut FilteredAccess<ComponentId>,
    );
    fn init_state(world: &mut World) -> Self::State;
    fn get_state(components: &Components) -> Option<Self::State>;
    fn matches_component_set(
        state: &Self::State,
        set_contains_id: &impl Fn(ComponentId) -> bool,
    ) -> bool;

    // Provided method
    fn set_access(
        _state: &mut Self::State,
        _access: &FilteredAccess<ComponentId>,
    ) { ... }
}
Expand description

Types that can be used as parameters in a Query. Types that implement this should also implement either QueryData or QueryFilter

§Safety

Implementor must ensure that update_component_access, matches_component_set, and fetch obey the following:

  • For each component mutably accessed by fetch, update_component_access should add write access unless read or write access has already been added, in which case it should panic.
  • For each component readonly accessed by fetch, update_component_access should add read access unless write access has already been added, in which case it should panic.
  • If fetch mutably accesses the same component twice, update_component_access should panic.
  • update_component_access may not add a Without filter for a component unless matches_component_set always returns false when the component set contains that component.
  • update_component_access may not add a With filter for a component unless matches_component_set always returns false when the component set doesn’t contain that component.
  • In cases where the query represents a disjunction (such as an Or filter) where each element is a valid WorldQuery, the following rules must be obeyed:
    • matches_component_set must be a disjunction of the element’s implementations
    • update_component_access must replace the filters with a disjunction of filters
    • Each filter in that disjunction must be a conjunction of the corresponding element’s filter with the previous access

When implementing update_component_access, note that add_read and add_write both also add a With filter, whereas extend_access does not change the filters.

Required Associated Constants§

Source

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.

Required Associated Types§

Source

type Item<'a>

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.

Source

type Fetch<'a>: Clone

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

Source

type State: Send + Sync + Sized

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.

Required Methods§

Source

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

This function manually implements subtyping for the query items.

Source

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, state: &Self::State, last_run: Tick, this_run: Tick, ) -> Self::Fetch<'w>

Creates a new instance of this fetch.

§Safety
  • state must have been initialized (via WorldQuery::init_state) using the same world passed in to this function.
Source

unsafe fn set_archetype<'w>( fetch: &mut Self::Fetch<'w>, state: &Self::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.

§Safety
  • archetype and tables must be from the same World that WorldQuery::init_state was called on.
  • table must correspond to archetype.
  • state must be the State that fetch was initialized with.
Source

unsafe fn set_table<'w>( fetch: &mut Self::Fetch<'w>, state: &Self::State, table: &'w Table, )

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

§Safety
Source

unsafe fn fetch<'w>( fetch: &mut Self::Fetch<'w>, entity: Entity, table_row: TableRow, ) -> Self::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.

§Safety

Must always be called after WorldQuery::set_table or WorldQuery::set_archetype. entity and table_row must be in the range of the current table and archetype.

Source

fn update_component_access( state: &Self::State, access: &mut FilteredAccess<ComponentId>, )

Adds any component accesses used by this WorldQuery to access.

Used to check which queries are disjoint and can run in parallel

Source

fn init_state(world: &mut World) -> Self::State

Creates and initializes a State for this WorldQuery type.

Source

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

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

Source

fn matches_component_set( state: &Self::State, set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

Used to check which Archetypes can be skipped by the query (if none of the Components match)

Provided Methods§

Source

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

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

Called when constructing a QueryLens or calling QueryState::from_builder

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl WorldQuery for ()

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = true

Source§

type Fetch<'w> = ()

Source§

type Item<'w> = ()

Source§

type State = ()

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<'__w, T: Component> WorldQuery for &'__w mut T

SAFETY: fetch accesses a single component mutably. This is sound because update_component_access and update_archetype_component_access add write 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.

Source§

const IS_DENSE: bool = _

Source§

type Item<'w> = Mut<'w, T>

Source§

type Fetch<'w> = WriteFetch<'w, T>

Source§

type State = ComponentId

Source§

fn shrink<'wlong: 'wshort, 'wshort>(item: Mut<'wlong, T>) -> Mut<'wshort, T>

Source§

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, component_id: &ComponentId, last_run: Tick, this_run: Tick, ) -> WriteFetch<'w, T>

Source§

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

Source§

unsafe fn set_table<'w>( fetch: &mut WriteFetch<'w, T>, component_id: &ComponentId, table: &'w Table, )

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<F0: WorldQuery> WorldQuery for (F0,)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>,)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>,)

Source§

type State = (<F0 as WorldQuery>::State,)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery> WorldQuery for (F0, F1)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery> WorldQuery for (F0, F1, F2)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery> WorldQuery for (F0, F1, F2, F3)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>, <F12 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>, <F12 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>, <F12 as WorldQuery>::Fetch<'w>, <F13 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>, <F12 as WorldQuery>::Item<'w>, <F13 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery, F14: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>, <F12 as WorldQuery>::Fetch<'w>, <F13 as WorldQuery>::Fetch<'w>, <F14 as WorldQuery>::Fetch<'w>)

Source§

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>, <F12 as WorldQuery>::Item<'w>, <F13 as WorldQuery>::Item<'w>, <F14 as WorldQuery>::Item<'w>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State, <F14 as WorldQuery>::State)

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> Self::State

Source§

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

Source§

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<T: Component> WorldQuery for &T

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.

Source§

const IS_DENSE: bool = _

Source§

type Item<'w> = &'w T

Source§

type Fetch<'w> = ReadFetch<'w, T>

Source§

type State = ComponentId

Source§

fn shrink<'wlong: 'wshort, 'wshort>(item: &'wlong T) -> &'wshort T

Source§

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, component_id: &ComponentId, _last_run: Tick, _this_run: Tick, ) -> ReadFetch<'w, T>

Source§

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

Source§

unsafe fn set_table<'w>( fetch: &mut ReadFetch<'w, T>, component_id: &ComponentId, table: &'w Table, )

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T: WorldQuery> WorldQuery for Option<T>

SAFETY: fetch might access any components that T accesses. This is sound because update_component_access and update_archetype_component_access add the same accesses as T. Filters are unchanged.

Source§

const IS_DENSE: bool = T::IS_DENSE

Source§

type Item<'w> = Option<<T as WorldQuery>::Item<'w>>

Source§

type Fetch<'w> = OptionFetch<'w, T>

Source§

type State = <T as WorldQuery>::State

Source§

fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, state: &T::State, last_run: Tick, this_run: Tick, ) -> OptionFetch<'w, T>

Source§

unsafe fn set_archetype<'w>( fetch: &mut OptionFetch<'w, T>, state: &T::State, archetype: &'w Archetype, table: &'w Table, )

Source§

unsafe fn set_table<'w>( fetch: &mut OptionFetch<'w, T>, state: &T::State, table: &'w Table, )

Source§

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

Source§

fn update_component_access( state: &T::State, access: &mut FilteredAccess<ComponentId>, )

Source§

fn init_state(world: &mut World) -> T::State

Source§

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

Source§

fn matches_component_set( _state: &T::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Source§

impl<T: ?Sized> WorldQuery for PhantomData<T>

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

Source§

const IS_DENSE: bool = true

Source§

type Item<'a> = ()

Source§

type Fetch<'a> = ()

Source§

type State = ()

Source§

fn shrink<'wlong: 'wshort, 'wshort>( _item: Self::Item<'wlong>, ) -> Self::Item<'wshort>

Source§

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, _state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>

Source§

unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &'w Table, )

Source§

unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )

Source§

unsafe fn fetch<'w>( _fetch: &mut Self::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>

Source§

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

Source§

fn init_state(_world: &mut World) -> Self::State

Source§

fn get_state(_components: &Components) -> Option<Self::State>

Source§

fn matches_component_set( _state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Implementors§

Source§

impl WorldQuery for &Archetype

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

Source§

const IS_DENSE: bool = true

Source§

type Item<'w> = &'w Archetype

Source§

type Fetch<'w> = (&'w Entities, &'w Archetypes)

Source§

type State = ()

Source§

impl WorldQuery for Entity

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

Source§

const IS_DENSE: bool = true

Source§

type Item<'w> = Entity

Source§

type Fetch<'w> = ()

Source§

type State = ()

Source§

impl WorldQuery for EntityLocation

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

Source§

impl WorldQuery for AnyOf<()>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = true

Source§

type Fetch<'w> = ()

Source§

type Item<'w> = ()

Source§

type State = ()

Source§

impl WorldQuery for Or<()>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = true

Source§

type Fetch<'w> = ()

Source§

type Item<'w> = bool

Source§

type State = ()

Source§

impl<'__w, T: Component> WorldQuery for Mut<'__w, T>

When Mut<T> is used in a query, it will be converted to Ref<T> when transformed into its read-only form, providing access to change detection methods.

By contrast &mut T will result in a Mut<T> item in mutable form to record mutations, but result in a bare &T in read-only form.

SAFETY: fetch accesses a single component mutably. This is sound because update_component_access and update_archetype_component_access add write 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.

Source§

const IS_DENSE: bool = <&mut T as WorldQuery>::IS_DENSE

Source§

type Item<'w> = Mut<'w, T>

Source§

type Fetch<'w> = WriteFetch<'w, T>

Source§

type State = ComponentId

Source§

impl<'__w, T: Component> WorldQuery for Ref<'__w, T>

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.

Source§

const IS_DENSE: bool = _

Source§

type Item<'w> = Ref<'w, T>

Source§

type Fetch<'w> = RefFetch<'w, T>

Source§

type State = ComponentId

Source§

impl<'a> WorldQuery for EntityMut<'a>

SAFETY: The accesses of Self::ReadOnly are a subset of the accesses of Self

Source§

impl<'a> WorldQuery for EntityRef<'a>

SAFETY: fetch accesses all components in a readonly way. This is sound because update_component_access and update_archetype_component_access set read access for all components and panic when appropriate. Filters are unchanged.

Source§

impl<'a> WorldQuery for FilteredEntityMut<'a>

SAFETY: The accesses of Self::ReadOnly are a subset of the accesses of Self

Source§

impl<'a> WorldQuery for FilteredEntityRef<'a>

SAFETY: The accesses of Self::ReadOnly are a subset of the accesses of Self

Source§

impl<F0: QueryFilter> WorldQuery for Or<(F0,)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>,)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State,)

Source§

impl<F0: QueryFilter, F1: QueryFilter> WorldQuery for Or<(F0, F1)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter> WorldQuery for Or<(F0, F1, F2)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter, F12: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter, F12: QueryFilter, F13: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State)

Source§

impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter, F12: QueryFilter, F13: QueryFilter, F14: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)

Source§

type Item<'w> = bool

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State, <F14 as WorldQuery>::State)

Source§

impl<F0: WorldQuery> WorldQuery for AnyOf<(F0,)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool),)

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>,)

Source§

type State = (<F0 as WorldQuery>::State,)

Source§

impl<F0: WorldQuery, F1: WorldQuery> WorldQuery for AnyOf<(F0, F1)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>, Option<<F12 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool), (<F13 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>, Option<<F12 as WorldQuery>::Item<'w>>, Option<<F13 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State)

Source§

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery, F14: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

Source§

const IS_DENSE: bool = _

Source§

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool), (<F13 as WorldQuery>::Fetch<'w>, bool), (<F14 as WorldQuery>::Fetch<'w>, bool))

Source§

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>, Option<<F12 as WorldQuery>::Item<'w>>, Option<<F13 as WorldQuery>::Item<'w>>, Option<<F14 as WorldQuery>::Item<'w>>)

Source§

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State, <F14 as WorldQuery>::State)

Source§

impl<T: Component> WorldQuery for Added<T>

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.

Source§

const IS_DENSE: bool = _

Source§

type Item<'w> = bool

Source§

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

Source§

type State = ComponentId

Source§

impl<T: Component> WorldQuery for Changed<T>

SAFETY: fetch accesses a single component in a readonly way. This is sound because update_component_access add 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.

Source§

const IS_DENSE: bool = _

Source§

type Item<'w> = bool

Source§

type Fetch<'w> = ChangedFetch<'w>

Source§

type State = ComponentId

Source§

impl<T: Component> WorldQuery for Has<T>

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

Source§

impl<T: Component> WorldQuery for With<T>

SAFETY: update_component_access does not add any accesses. This is sound because fetch does not access any components. update_component_access adds a With filter for T. This is sound because matches_component_set returns whether the set contains the component.

Source§

impl<T: Component> WorldQuery for Without<T>

SAFETY: update_component_access does not add any accesses. This is sound because fetch does not access any components. update_component_access adds a Without filter for T. This is sound because matches_component_set returns whether the set does not contain the component.