Type Alias de_index::precise::MovedQuery
source · type MovedQuery<'w, 's> = Query<'w, 's, (Entity, &'static Transform), (With<Indexed>, Changed<Transform>)>;
Aliased Type§
struct MovedQuery<'w, 's> {
world: UnsafeWorldCell<'w>,
state: &'s QueryState<(Entity, &'static Transform), (With<Indexed>, Changed<Transform>)>,
last_run: Tick,
this_run: Tick,
force_read_only_component_access: bool,
}
Fields§
§world: UnsafeWorldCell<'w>
§state: &'s QueryState<(Entity, &'static Transform), (With<Indexed>, Changed<Transform>)>
§last_run: Tick
§this_run: Tick
§force_read_only_component_access: bool
Implementations
§impl<'w, 's, D, F> Query<'w, 's, D, F>where
D: QueryData,
F: QueryFilter,
impl<'w, 's, D, F> Query<'w, 's, D, F>where
D: QueryData,
F: QueryFilter,
pub fn to_readonly(&self) -> Query<'_, 's, <D as QueryData>::ReadOnly, F>
pub fn to_readonly(&self) -> Query<'_, 's, <D as QueryData>::ReadOnly, F>
Returns another Query
from this that fetches the read-only version of the query items.
For example, Query<(&mut D1, &D2, &mut D3), With<F>>
will become Query<(&D1, &D2, &D3), With<F>>
.
This can be useful when working around the borrow checker,
or reusing functionality between systems via functions that accept query types.
pub fn iter(&self) -> QueryIter<'_, 's, <D as QueryData>::ReadOnly, F>
pub fn iter(&self) -> QueryIter<'_, 's, <D as QueryData>::ReadOnly, F>
pub fn iter_mut(&mut self) -> QueryIter<'_, 's, D, F>
pub fn iter_mut(&mut self) -> QueryIter<'_, 's, D, F>
Returns an Iterator
over the query items.
§Example
Here, the gravity_system
updates the Velocity
component of every entity that contains it:
fn gravity_system(mut query: Query<&mut Velocity>) {
const DELTA: f32 = 1.0 / 60.0;
for mut velocity in &mut query {
velocity.y -= 9.8 * DELTA;
}
}
§See also
iter
for read-only query items.for_each_mut
for the closure based alternative.
pub fn iter_combinations<const K: usize>(
&self
) -> QueryCombinationIter<'_, 's, <D as QueryData>::ReadOnly, F, K>
pub fn iter_combinations<const K: usize>( &self ) -> QueryCombinationIter<'_, 's, <D as QueryData>::ReadOnly, F, K>
Returns a [QueryCombinationIter
] over all combinations of K
read-only query items without repetition.
§Example
fn some_system(query: Query<&ComponentA>) {
for [a1, a2] in query.iter_combinations() {
// ...
}
}
§See also
iter_combinations_mut
for mutable query item combinations.
pub fn iter_combinations_mut<const K: usize>(
&mut self
) -> QueryCombinationIter<'_, 's, D, F, K>
pub fn iter_combinations_mut<const K: usize>( &mut self ) -> QueryCombinationIter<'_, 's, D, F, K>
Returns a [QueryCombinationIter
] over all combinations of K
query items without repetition.
§Example
fn some_system(mut query: Query<&mut ComponentA>) {
let mut combinations = query.iter_combinations_mut();
while let Some([mut a1, mut a2]) = combinations.fetch_next() {
// mutably access components data
}
}
§See also
iter_combinations
for read-only query item combinations.
pub fn iter_many<EntityList>(
&self,
entities: EntityList
) -> QueryManyIter<'_, 's, <D as QueryData>::ReadOnly, F, <EntityList as IntoIterator>::IntoIter>
pub fn iter_many<EntityList>( &self, entities: EntityList ) -> QueryManyIter<'_, 's, <D as QueryData>::ReadOnly, F, <EntityList as IntoIterator>::IntoIter>
Returns an Iterator
over the read-only query items generated from an [Entity
] list.
Items are returned in the order of the list of entities. Entities that don’t match the query are skipped.
§Example
// A component containing an entity list.
#[derive(Component)]
struct Friends {
list: Vec<Entity>,
}
fn system(
friends_query: Query<&Friends>,
counter_query: Query<&Counter>,
) {
for friends in &friends_query {
for counter in counter_query.iter_many(&friends.list) {
println!("Friend's counter: {:?}", counter.value);
}
}
}
§See also
iter_many_mut
to get mutable query items.
pub fn iter_many_mut<EntityList>(
&mut self,
entities: EntityList
) -> QueryManyIter<'_, 's, D, F, <EntityList as IntoIterator>::IntoIter>
pub fn iter_many_mut<EntityList>( &mut self, entities: EntityList ) -> QueryManyIter<'_, 's, D, F, <EntityList as IntoIterator>::IntoIter>
Returns an iterator over the query items generated from an [Entity
] list.
Items are returned in the order of the list of entities. Entities that don’t match the query are skipped.
§Examples
#[derive(Component)]
struct Counter {
value: i32
}
#[derive(Component)]
struct Friends {
list: Vec<Entity>,
}
fn system(
friends_query: Query<&Friends>,
mut counter_query: Query<&mut Counter>,
) {
for friends in &friends_query {
let mut iter = counter_query.iter_many_mut(&friends.list);
while let Some(mut counter) = iter.fetch_next() {
println!("Friend's counter: {:?}", counter.value);
counter.value += 1;
}
}
}
pub unsafe fn iter_unsafe(&self) -> QueryIter<'_, 's, D, F>
pub unsafe fn iter_unsafe(&self) -> QueryIter<'_, 's, D, F>
pub unsafe fn iter_combinations_unsafe<const K: usize>(
&self
) -> QueryCombinationIter<'_, 's, D, F, K>
pub unsafe fn iter_combinations_unsafe<const K: usize>( &self ) -> QueryCombinationIter<'_, 's, D, F, K>
Iterates over all possible combinations of K
query items without repetition.
§Safety
This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component.
§See also
iter_combinations
anditer_combinations_mut
for the safe versions.
pub unsafe fn iter_many_unsafe<EntityList>(
&self,
entities: EntityList
) -> QueryManyIter<'_, 's, D, F, <EntityList as IntoIterator>::IntoIter>
pub unsafe fn iter_many_unsafe<EntityList>( &self, entities: EntityList ) -> QueryManyIter<'_, 's, D, F, <EntityList as IntoIterator>::IntoIter>
Returns an Iterator
over the query items generated from an [Entity
] list.
§Safety
This allows aliased mutability and does not check for entity uniqueness.
You must make sure this call does not result in multiple mutable references to the same component.
Particular care must be taken when collecting the data (rather than iterating over it one item at a time) such as via Iterator::collect
.
§See also
iter_many_mut
to safely access the query items.
pub fn for_each<'this>(
&'this self,
f: impl FnMut(<<D as QueryData>::ReadOnly as WorldQuery>::Item<'this>)
)
👎Deprecated since 0.13.0: Query::for_each was not idiomatic Rust and has been moved to query.iter().for_each()
pub fn for_each<'this>( &'this self, f: impl FnMut(<<D as QueryData>::ReadOnly as WorldQuery>::Item<'this>) )
Runs f
on each read-only query item.
Shorthand for query.iter().for_each(..)
.
§Example
Here, the report_names_system
iterates over the Player
component of every entity that contains it:
fn report_names_system(query: Query<&Player>) {
query.for_each(|player| {
println!("Say hello to {}!", player.name);
});
}
§See also
for_each_mut
to operate on mutable query items.iter
for the iterator based alternative.
pub fn for_each_mut<'a>(
&'a mut self,
f: impl FnMut(<D as WorldQuery>::Item<'a>)
)
👎Deprecated since 0.13.0: Query::for_each_mut was not idiomatic Rust and has been moved to query.iter_mut().for_each()
pub fn for_each_mut<'a>( &'a mut self, f: impl FnMut(<D as WorldQuery>::Item<'a>) )
Runs f
on each query item.
Shorthand for query.iter_mut().for_each(..)
.
§Example
Here, the gravity_system
updates the Velocity
component of every entity that contains it:
fn gravity_system(mut query: Query<&mut Velocity>) {
const DELTA: f32 = 1.0 / 60.0;
query.for_each_mut(|mut velocity| {
velocity.y -= 9.8 * DELTA;
});
}
§See also
pub fn par_iter(&self) -> QueryParIter<'_, '_, <D as QueryData>::ReadOnly, F>
pub fn par_iter(&self) -> QueryParIter<'_, '_, <D as QueryData>::ReadOnly, F>
Returns a parallel iterator over the query results for the given World
.
This can only be called for read-only queries, see par_iter_mut
for write-queries.
Note that you must use the for_each
method to iterate over the
results, see par_iter_mut
for an example.
pub fn par_iter_mut(&mut self) -> QueryParIter<'_, '_, D, F>
pub fn par_iter_mut(&mut self) -> QueryParIter<'_, '_, D, F>
Returns a parallel iterator over the query results for the given World
.
This can only be called for mutable queries, see par_iter
for read-only-queries.
§Example
Here, the gravity_system
updates the Velocity
component of every entity that contains it:
fn gravity_system(mut query: Query<&mut Velocity>) {
const DELTA: f32 = 1.0 / 60.0;
query.par_iter_mut().for_each(|mut velocity| {
velocity.y -= 9.8 * DELTA;
});
}
pub fn get(
&self,
entity: Entity
) -> Result<<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>, QueryEntityError>
pub fn get( &self, entity: Entity ) -> Result<<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>, QueryEntityError>
Returns the read-only query item for the given [Entity
].
In case of a nonexisting entity or mismatched component, a [QueryEntityError
] is returned instead.
§Example
Here, get
is used to retrieve the exact query item of the entity specified by the SelectedCharacter
resource.
fn print_selected_character_name_system(
query: Query<&Character>,
selection: Res<SelectedCharacter>
)
{
if let Ok(selected_character) = query.get(selection.entity) {
println!("{}", selected_character.name);
}
}
§See also
get_mut
to get a mutable query item.
pub fn get_many<const N: usize>(
&self,
entities: [Entity; N]
) -> Result<[<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>; N], QueryEntityError>
pub fn get_many<const N: usize>( &self, entities: [Entity; N] ) -> Result<[<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>; N], QueryEntityError>
Returns the read-only query items for the given array of [Entity
].
The returned query items are in the same order as the input.
In case of a nonexisting entity or mismatched component, a [QueryEntityError
] is returned instead.
The elements of the array do not need to be unique, unlike get_many_mut
.
§See also
get_many_mut
to get mutable query items.many
for the panicking version.
pub fn many<const N: usize>(
&self,
entities: [Entity; N]
) -> [<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>; N]
pub fn many<const N: usize>( &self, entities: [Entity; N] ) -> [<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>; N]
Returns the read-only query items for the given array of [Entity
].
§Panics
This method panics if there is a query mismatch or a non-existing entity.
§Examples
use bevy_ecs::prelude::*;
#[derive(Component)]
struct Targets([Entity; 3]);
#[derive(Component)]
struct Position{
x: i8,
y: i8
};
impl Position {
fn distance(&self, other: &Position) -> i8 {
// Manhattan distance is way easier to compute!
(self.x - other.x).abs() + (self.y - other.y).abs()
}
}
fn check_all_targets_in_range(targeting_query: Query<(Entity, &Targets, &Position)>, targets_query: Query<&Position>){
for (targeting_entity, targets, origin) in &targeting_query {
// We can use "destructuring" to unpack the results nicely
let [target_1, target_2, target_3] = targets_query.many(targets.0);
assert!(target_1.distance(origin) <= 5);
assert!(target_2.distance(origin) <= 5);
assert!(target_3.distance(origin) <= 5);
}
}
§See also
get_many
for the non-panicking version.
pub fn get_mut(
&mut self,
entity: Entity
) -> Result<<D as WorldQuery>::Item<'_>, QueryEntityError>
pub fn get_mut( &mut self, entity: Entity ) -> Result<<D as WorldQuery>::Item<'_>, QueryEntityError>
Returns the query item for the given [Entity
].
In case of a nonexisting entity or mismatched component, a [QueryEntityError
] is returned instead.
§Example
Here, get_mut
is used to retrieve the exact query item of the entity specified by the PoisonedCharacter
resource.
fn poison_system(mut query: Query<&mut Health>, poisoned: Res<PoisonedCharacter>) {
if let Ok(mut health) = query.get_mut(poisoned.character_id) {
health.0 -= 1;
}
}
§See also
get
to get a read-only query item.
pub fn get_many_mut<const N: usize>(
&mut self,
entities: [Entity; N]
) -> Result<[<D as WorldQuery>::Item<'_>; N], QueryEntityError>
pub fn get_many_mut<const N: usize>( &mut self, entities: [Entity; N] ) -> Result<[<D as WorldQuery>::Item<'_>; N], QueryEntityError>
Returns the query items for the given array of [Entity
].
The returned query items are in the same order as the input.
In case of a nonexisting entity, duplicate entities or mismatched component, a [QueryEntityError
] is returned instead.
§See also
pub fn many_mut<const N: usize>(
&mut self,
entities: [Entity; N]
) -> [<D as WorldQuery>::Item<'_>; N]
pub fn many_mut<const N: usize>( &mut self, entities: [Entity; N] ) -> [<D as WorldQuery>::Item<'_>; N]
Returns the query items for the given array of [Entity
].
§Panics
This method panics if there is a query mismatch, a non-existing entity, or the same Entity
is included more than once in the array.
§Examples
use bevy_ecs::prelude::*;
#[derive(Component)]
struct Spring{
connected_entities: [Entity; 2],
strength: f32,
}
#[derive(Component)]
struct Position {
x: f32,
y: f32,
}
#[derive(Component)]
struct Force {
x: f32,
y: f32,
}
fn spring_forces(spring_query: Query<&Spring>, mut mass_query: Query<(&Position, &mut Force)>){
for spring in &spring_query {
// We can use "destructuring" to unpack our query items nicely
let [(position_1, mut force_1), (position_2, mut force_2)] = mass_query.many_mut(spring.connected_entities);
force_1.x += spring.strength * (position_1.x - position_2.x);
force_1.y += spring.strength * (position_1.y - position_2.y);
// Silence borrow-checker: I have split your mutable borrow!
force_2.x += spring.strength * (position_2.x - position_1.x);
force_2.y += spring.strength * (position_2.y - position_1.y);
}
}
§See also
get_many_mut
for the non panicking version.many
to get read-only query items.
pub unsafe fn get_unchecked(
&self,
entity: Entity
) -> Result<<D as WorldQuery>::Item<'_>, QueryEntityError>
pub unsafe fn get_unchecked( &self, entity: Entity ) -> Result<<D as WorldQuery>::Item<'_>, QueryEntityError>
Returns the query item for the given [Entity
].
In case of a nonexisting entity or mismatched component, a [QueryEntityError
] is returned instead.
§Safety
This function makes it possible to violate Rust’s aliasing guarantees. You must make sure this call does not result in multiple mutable references to the same component.
§See also
get_mut
for the safe version.
pub fn get_component<T>(
&self,
entity: Entity
) -> Result<&T, QueryComponentError>where
T: Component,
👎Deprecated since 0.13.0: Please use get
and select for the exact component based on the structure of the exact query as required.
pub fn get_component<T>(
&self,
entity: Entity
) -> Result<&T, QueryComponentError>where
T: Component,
get
and select for the exact component based on the structure of the exact query as required.Returns a shared reference to the component T
of the given [Entity
].
In case of a nonexisting entity or mismatched component, a [QueryEntityError
] is returned instead.
§Example
Here, get_component
is used to retrieve the Character
component of the entity specified by the SelectedCharacter
resource.
fn print_selected_character_name_system(
query: Query<&Character>,
selection: Res<SelectedCharacter>
)
{
if let Ok(selected_character) = query.get_component::<Character>(selection.entity) {
println!("{}", selected_character.name);
}
}
§See also
component
a panicking version of this function.get_component_mut
to get a mutable reference of a component.
pub fn get_component_mut<T>(
&mut self,
entity: Entity
) -> Result<Mut<'_, T>, QueryComponentError>where
T: Component,
👎Deprecated since 0.13.0: Please use get_mut
and select for the exact component based on the structure of the exact query as required.
pub fn get_component_mut<T>(
&mut self,
entity: Entity
) -> Result<Mut<'_, T>, QueryComponentError>where
T: Component,
get_mut
and select for the exact component based on the structure of the exact query as required.Returns a mutable reference to the component T
of the given entity.
In case of a nonexisting entity, mismatched component or missing write access, a QueryComponentError
is returned instead.
§Example
Here, get_component_mut
is used to retrieve the Health
component of the entity specified by the PoisonedCharacter
resource.
fn poison_system(mut query: Query<&mut Health>, poisoned: Res<PoisonedCharacter>) {
if let Ok(mut health) = query.get_component_mut::<Health>(poisoned.character_id) {
health.0 -= 1;
}
}
§See also
component_mut
a panicking version of this function.get_component
to get a shared reference of a component.
pub fn component<T>(&self, entity: Entity) -> &Twhere
T: Component,
👎Deprecated since 0.13.0: Please use get
and select for the exact component based on the structure of the exact query as required.
pub fn component<T>(&self, entity: Entity) -> &Twhere
T: Component,
get
and select for the exact component based on the structure of the exact query as required.Returns a shared reference to the component T
of the given [Entity
].
§Panics
Panics in case of a nonexisting entity or mismatched component.
§See also
get_component
a non-panicking version of this function.component_mut
to get a mutable reference of a component.
pub fn component_mut<T>(&mut self, entity: Entity) -> Mut<'_, T>where
T: Component,
👎Deprecated since 0.13.0: Please use get_mut
and select for the exact component based on the structure of the exact query as required.
pub fn component_mut<T>(&mut self, entity: Entity) -> Mut<'_, T>where
T: Component,
get_mut
and select for the exact component based on the structure of the exact query as required.Returns a mutable reference to the component T
of the given entity.
§Panics
Panics in case of a nonexisting entity, mismatched component or missing write access.
§See also
get_component_mut
a non-panicking version of this function.component
to get a shared reference of a component.
pub unsafe fn get_component_unchecked_mut<T>(
&self,
entity: Entity
) -> Result<Mut<'_, T>, QueryComponentError>where
T: Component,
👎Deprecated since 0.13.0: Please use get_unchecked
and select for the exact component based on the structure of the exact query as required.
pub unsafe fn get_component_unchecked_mut<T>(
&self,
entity: Entity
) -> Result<Mut<'_, T>, QueryComponentError>where
T: Component,
get_unchecked
and select for the exact component based on the structure of the exact query as required.Returns a mutable reference to the component T
of the given entity.
In case of a nonexisting entity or mismatched component, a QueryComponentError
is returned instead.
§Safety
This function makes it possible to violate Rust’s aliasing guarantees. You must make sure this call does not result in multiple mutable references to the same component.
§See also
get_component_mut
for the safe version.
pub fn single(&self) -> <<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>
pub fn single(&self) -> <<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>
Returns a single read-only query item when there is exactly one entity matching the query.
§Panics
This method panics if the number of query items is not exactly one.
§Example
fn player_system(query: Query<&Position, With<Player>>) {
let player_position = query.single();
// do something with player_position
}
§See also
get_single
for the non-panicking version.single_mut
to get the mutable query item.
pub fn get_single(
&self
) -> Result<<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>, QuerySingleError>
pub fn get_single( &self ) -> Result<<<D as QueryData>::ReadOnly as WorldQuery>::Item<'_>, QuerySingleError>
Returns a single read-only query item when there is exactly one entity matching the query.
If the number of query items is not exactly one, a [QuerySingleError
] is returned instead.
§Example
fn player_scoring_system(query: Query<&PlayerScore>) {
match query.get_single() {
Ok(PlayerScore(score)) => {
println!("Score: {}", score);
}
Err(QuerySingleError::NoEntities(_)) => {
println!("Error: There is no player!");
}
Err(QuerySingleError::MultipleEntities(_)) => {
println!("Error: There is more than one player!");
}
}
}
§See also
get_single_mut
to get the mutable query item.single
for the panicking version.
pub fn single_mut(&mut self) -> <D as WorldQuery>::Item<'_>
pub fn single_mut(&mut self) -> <D as WorldQuery>::Item<'_>
Returns a single query item when there is exactly one entity matching the query.
§Panics
This method panics if the number of query item is not exactly one.
§Example
fn regenerate_player_health_system(mut query: Query<&mut Health, With<Player>>) {
let mut health = query.single_mut();
health.0 += 1;
}
§See also
get_single_mut
for the non-panicking version.single
to get the read-only query item.
pub fn get_single_mut(
&mut self
) -> Result<<D as WorldQuery>::Item<'_>, QuerySingleError>
pub fn get_single_mut( &mut self ) -> Result<<D as WorldQuery>::Item<'_>, QuerySingleError>
Returns a single query item when there is exactly one entity matching the query.
If the number of query items is not exactly one, a [QuerySingleError
] is returned instead.
§Example
fn regenerate_player_health_system(mut query: Query<&mut Health, With<Player>>) {
let mut health = query.get_single_mut().expect("Error: Could not find a single player.");
health.0 += 1;
}
§See also
get_single
to get the read-only query item.single_mut
for the panicking version.
pub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if there are no query items.
§Example
Here, the score is increased only if an entity with a Player
component is present in the world:
fn update_score_system(query: Query<(), With<Player>>, mut score: ResMut<Score>) {
if !query.is_empty() {
score.0 += 1;
}
}
pub fn contains(&self, entity: Entity) -> bool
pub fn contains(&self, entity: Entity) -> bool
Returns true
if the given [Entity
] matches the query.
§Example
fn targeting_system(in_range_query: Query<&InRange>, target: Res<Target>) {
if in_range_query.contains(target.entity) {
println!("Bam!")
}
}
pub fn transmute_lens<NewD>(&mut self) -> QueryLens<'_, NewD>where
NewD: QueryData,
pub fn transmute_lens<NewD>(&mut self) -> QueryLens<'_, NewD>where
NewD: QueryData,
Returns a [QueryLens
] that can be used to get a query with a more general fetch.
For example, this can transform a Query<(&A, &mut B)>
to a Query<&B>
.
This can be useful for passing the query to another function. Note that since
filter terms are dropped, non-archetypal filters like Added
and
Changed
will not be respected. To maintain or change filter
terms see [Self::transmute_lens_filtered
]
§Panics
This will panic if NewD
is not a subset of the original fetch Q
§Example
fn reusable_function(lens: &mut QueryLens<&A>) {
assert_eq!(lens.query().single().0, 10);
}
// We can use the function in a system that takes the exact query.
fn system_1(mut query: Query<&A>) {
reusable_function(&mut query.as_query_lens());
}
// We can also use it with a query that does not match exactly
// by transmuting it.
fn system_2(mut query: Query<(&mut A, &B)>) {
let mut lens = query.transmute_lens::<&A>();
reusable_function(&mut lens);
}
§Allowed Transmutes
Besides removing parameters from the query, you can also make limited changes to the types of paramters.
pub fn transmute_lens_filtered<NewD, NewF>(
&mut self
) -> QueryLens<'_, NewD, NewF>where
NewD: QueryData,
NewF: QueryFilter,
pub fn transmute_lens_filtered<NewD, NewF>(
&mut self
) -> QueryLens<'_, NewD, NewF>where
NewD: QueryData,
NewF: QueryFilter,
Equivalent to [Self::transmute_lens
] but also includes a [QueryFilter
] type.
Note that the lens will iterate the same tables and archetypes as the original query. This means that
additional archetypal query terms like With
and Without
will not necessarily be respected and non-archetypal terms like Added
and
Changed
will only be respected if they are in the type signature.
pub fn as_query_lens(&mut self) -> QueryLens<'_, D>
pub fn as_query_lens(&mut self) -> QueryLens<'_, D>
Gets a [QueryLens
] with the same accesses as the existing query
§impl<'w, 's, D, F> Query<'w, 's, D, F>where
D: ReadOnlyQueryData,
F: QueryFilter,
impl<'w, 's, D, F> Query<'w, 's, D, F>where
D: ReadOnlyQueryData,
F: QueryFilter,
pub fn get_inner(
&self,
entity: Entity
) -> Result<<<D as QueryData>::ReadOnly as WorldQuery>::Item<'w>, QueryEntityError>
pub fn get_inner( &self, entity: Entity ) -> Result<<<D as QueryData>::ReadOnly as WorldQuery>::Item<'w>, QueryEntityError>
Returns the query item for the given [Entity
], with the actual “inner” world lifetime.
In case of a nonexisting entity or mismatched component, a [QueryEntityError
] is
returned instead.
This can only return immutable data (mutable data will be cast to an immutable form).
See get_mut
for queries that contain at least one mutable component.
§Example
Here, get
is used to retrieve the exact query item of the entity specified by the
SelectedCharacter
resource.
fn print_selected_character_name_system(
query: Query<&Character>,
selection: Res<SelectedCharacter>
)
{
if let Ok(selected_character) = query.get(selection.entity) {
println!("{}", selected_character.name);
}
}
pub fn iter_inner(&self) -> QueryIter<'w, 's, <D as QueryData>::ReadOnly, F>
pub fn iter_inner(&self) -> QueryIter<'w, 's, <D as QueryData>::ReadOnly, F>
Returns an Iterator
over the query items, with the actual “inner” world lifetime.
This can only return immutable data (mutable data will be cast to an immutable form).
See [Self::iter_mut
] for queries that contain at least one mutable component.
§Example
Here, the report_names_system
iterates over the Player
component of every entity
that contains it:
fn report_names_system(query: Query<&Player>) {
for player in &query {
println!("Say hello to {}!", player.name);
}
}
Trait Implementations
§impl<'w, 's, Q, F> From<&'s mut QueryLens<'w, Q, F>> for Query<'w, 's, Q, F>where
Q: QueryData,
F: QueryFilter,
impl<'w, 's, Q, F> From<&'s mut QueryLens<'w, Q, F>> for Query<'w, 's, Q, F>where
Q: QueryData,
F: QueryFilter,
§impl<'w, 's, D, F> HierarchyQueryExt<'w, 's, D, F> for Query<'w, 's, D, F>where
D: QueryData,
F: QueryFilter,
impl<'w, 's, D, F> HierarchyQueryExt<'w, 's, D, F> for Query<'w, 's, D, F>where
D: QueryData,
F: QueryFilter,
§fn iter_descendants(&'w self, entity: Entity) -> DescendantIter<'w, 's, D, F>where
<D as QueryData>::ReadOnly: WorldQuery<Item<'w> = &'w Children>,
fn iter_descendants(&'w self, entity: Entity) -> DescendantIter<'w, 's, D, F>where
<D as QueryData>::ReadOnly: WorldQuery<Item<'w> = &'w Children>,
§fn iter_ancestors(&'w self, entity: Entity) -> AncestorIter<'w, 's, D, F>where
<D as QueryData>::ReadOnly: WorldQuery<Item<'w> = &'w Parent>,
fn iter_ancestors(&'w self, entity: Entity) -> AncestorIter<'w, 's, D, F>where
<D as QueryData>::ReadOnly: WorldQuery<Item<'w> = &'w Parent>,
§impl<D, F> SystemParam for Query<'_, '_, D, F>where
D: QueryData + 'static,
F: QueryFilter + 'static,
impl<D, F> SystemParam for Query<'_, '_, D, F>where
D: QueryData + 'static,
F: QueryFilter + 'static,
§type Item<'w, 's> = Query<'w, 's, D, F>
type Item<'w, 's> = Query<'w, 's, D, F>
Self
, instantiated with new lifetimes. Read more§fn init_state(
world: &mut World,
system_meta: &mut SystemMeta
) -> <Query<'_, '_, D, F> as SystemParam>::State
fn init_state( world: &mut World, system_meta: &mut SystemMeta ) -> <Query<'_, '_, D, F> as SystemParam>::State
World
] access used by this [SystemParam
]
and creates a new instance of this param’s State
.§fn new_archetype(
state: &mut <Query<'_, '_, D, F> as SystemParam>::State,
archetype: &Archetype,
system_meta: &mut SystemMeta
)
fn new_archetype( state: &mut <Query<'_, '_, D, F> as SystemParam>::State, archetype: &Archetype, system_meta: &mut SystemMeta )
Archetype
], registers the components accessed by this [SystemParam
] (if applicable).§unsafe fn get_param<'w, 's>(
state: &'s mut <Query<'_, '_, D, F> as SystemParam>::State,
system_meta: &SystemMeta,
world: UnsafeWorldCell<'w>,
change_tick: Tick
) -> <Query<'_, '_, D, F> as SystemParam>::Item<'w, 's>
unsafe fn get_param<'w, 's>( state: &'s mut <Query<'_, '_, D, F> as SystemParam>::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick ) -> <Query<'_, '_, D, F> as SystemParam>::Item<'w, 's>
SystemParamFunction
. Read more§fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)
fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)
SystemParam
]’s state.
This is used to apply Commands
during apply_deferred
.