Struct EntityRef

pub struct EntityRef<'w>(/* private fields */);

A read-only reference to a particular Entity and all of its components.

Examples

Read-only access disjoint with mutable access.

fn disjoint_system(
    query1: Query<&mut A>,
    query2: Query<EntityRef, Without<A>>,
) {
    // ...
}

Implementations

impl<'w> EntityRef<'w>

pub fn id(&self) -> Entity

Returns the ID of the current entity.

pub fn location(&self) -> EntityLocation

Gets metadata indicating the location where the current entity is stored.

pub fn archetype(&self) -> &Archetype

Returns the archetype that the current entity belongs to.

pub fn contains<T: Component>(&self) -> bool

Returns true if the current entity has a component of type T. Otherwise, this returns false.

Notes

If you do not know the concrete type of a component, consider using Self::contains_id or Self::contains_type_id.

pub fn contains_id(&self, component_id: ComponentId) -> bool

Returns true if the current entity has a component identified by component_id. Otherwise, this returns false.

Notes

• If you know the concrete type of the component, you should prefer Self::contains.
• If you know the component’s TypeId but not its ComponentId, consider using Self::contains_type_id.

pub fn contains_type_id(&self, type_id: TypeId) -> bool

Returns true if the current entity has a component with the type identified by type_id. Otherwise, this returns false.

Notes

• If you know the concrete type of the component, you should prefer Self::contains.
• If you have a ComponentId instead of a TypeId, consider using Self::contains_id.

pub fn get<T: Component>(&self) -> Option<&'w T>

Gets access to the component of type T for the current entity. Returns None if the entity does not have a component of type T.

pub fn get_ref<T: Component>(&self) -> Option<Ref<'w, T>>

Gets access to the component of type T for the current entity, including change detection information as a Ref.

Returns None if the entity does not have a component of type T.

pub fn get_change_ticks<T: Component>(&self) -> Option<ComponentTicks>

Retrieves the change ticks for the given component. This can be useful for implementing change detection in custom runtimes.

pub fn get_change_ticks_by_id( &self, component_id: ComponentId, ) -> Option<ComponentTicks>

Retrieves the change ticks for the given ComponentId. This can be useful for implementing change detection in custom runtimes.

You should prefer to use the typed API EntityRef::get_change_ticks where possible and only use this in cases where the actual component types are not known at compile time.

pub fn get_by_id<F: DynamicComponentFetch>( &self, component_ids: F, ) -> Result<F::Ref<'w>, EntityComponentError>

Returns untyped read-only reference(s) to component(s) for the current entity, based on the given ComponentIds.

You should prefer to use the typed API EntityRef::get where possible and only use this in cases where the actual component types are not known at compile time.

Unlike EntityRef::get, this returns untyped reference(s) to component(s), and it’s the job of the caller to ensure the correct type(s) are dereferenced (if necessary).

Errors

Returns EntityComponentError::MissingComponent if the entity does not have a component.

Examples

Single ComponentId

let entity = world.spawn(Foo(42)).id();

// Grab the component ID for `Foo` in whatever way you like.
let component_id = world.register_component::<Foo>();

// Then, get the component by ID.
let ptr = world.entity(entity).get_by_id(component_id);

Array of ComponentIds

let entity = world.spawn((X(42), Y(10))).id();

// Grab the component IDs for `X` and `Y` in whatever way you like.
let x_id = world.register_component::<X>();
let y_id = world.register_component::<Y>();

// Then, get the components by ID. You'll receive a same-sized array.
let Ok([x_ptr, y_ptr]) = world.entity(entity).get_by_id([x_id, y_id]) else {
    // Up to you to handle if a component is missing from the entity.
};

Slice of ComponentIds

let entity = world.spawn((X(42), Y(10))).id();

// Grab the component IDs for `X` and `Y` in whatever way you like.
let x_id = world.register_component::<X>();
let y_id = world.register_component::<Y>();

// Then, get the components by ID. You'll receive a vec of ptrs.
let ptrs = world.entity(entity).get_by_id(&[x_id, y_id] as &[ComponentId]);

HashSet of ComponentIds

let entity = world.spawn((X(42), Y(10))).id();

// Grab the component IDs for `X` and `Y` in whatever way you like.
let x_id = world.register_component::<X>();
let y_id = world.register_component::<Y>();

// Then, get the components by ID. You'll receive a vec of ptrs.
let ptrs = world.entity(entity).get_by_id(&HashSet::from_iter([x_id, y_id]));

pub fn components<Q: ReadOnlyQueryData>(&self) -> Q::Item<'w>

Returns read-only components for the current entity that match the query Q.

Panics

If the entity does not have the components required by the query Q.

pub fn get_components<Q: ReadOnlyQueryData>(&self) -> Option<Q::Item<'w>>

Returns read-only components for the current entity that match the query Q, or None if the entity does not have the components required by the query Q.

Trait Implementations

impl<'w> Clone for EntityRef<'w>

fn clone(&self) -> EntityRef<'w>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> From<&'a EntityMut<'_>> for EntityRef<'a>

fn from(value: &'a EntityMut<'_>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a EntityRef<'_>> for FilteredEntityRef<'a>

fn from(entity: &'a EntityRef<'_>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a EntityWorldMut<'_>> for EntityRef<'a>

fn from(value: &'a EntityWorldMut<'_>) -> Self

Converts to this type from the input type.

impl<'w> From<EntityMut<'w>> for EntityRef<'w>

fn from(value: EntityMut<'w>) -> Self

Converts to this type from the input type.

impl<'a> From<EntityRef<'a>> for FilteredEntityRef<'a>

fn from(entity: EntityRef<'a>) -> Self

Converts to this type from the input type.

impl<'w> From<EntityWorldMut<'w>> for EntityRef<'w>

fn from(entity_mut: EntityWorldMut<'w>) -> EntityRef<'w>

Converts to this type from the input type.

impl<'a> QueryData for EntityRef<'a>

SAFETY: Self is the same as Self::ReadOnly

type ReadOnly = EntityRef<'a>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

impl<'a> TryFrom<&'a FilteredEntityMut<'_>> for EntityRef<'a>

type Error = TryFromFilteredError

The type returned in the event of a conversion error.

fn try_from(value: &'a FilteredEntityMut<'_>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a FilteredEntityRef<'_>> for EntityRef<'a>

type Error = TryFromFilteredError

The type returned in the event of a conversion error.

fn try_from(value: &'a FilteredEntityRef<'_>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<FilteredEntityMut<'a>> for EntityRef<'a>

type Error = TryFromFilteredError

The type returned in the event of a conversion error.

fn try_from(value: FilteredEntityMut<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<FilteredEntityRef<'a>> for EntityRef<'a>

type Error = TryFromFilteredError

The type returned in the event of a conversion error.

fn try_from(value: FilteredEntityRef<'a>) -> Result<Self, Self::Error>

Performs the conversion.

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.

const IS_DENSE: bool = true

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.

type Item<'w> = EntityRef<'w>

The item returned by this WorldQuery For QueryData this will be the item returned by the query. For QueryFilter this will be either (), or a bool indicating whether the entity should be included or a tuple of such things.

type Fetch<'w> = UnsafeWorldCell<'w>

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

type State = ()

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

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

This function manually implements subtyping for the query items.

fn shrink_fetch<'wlong: 'wshort, 'wshort>( fetch: Self::Fetch<'wlong>, ) -> Self::Fetch<'wshort>

This function manually implements subtyping for the query fetches.

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.

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

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

unsafe fn set_table<'w>( _fetch: &mut 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.

unsafe fn fetch<'w>( world: &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.

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

Adds any component accesses used by this WorldQuery to access.

fn init_state(_world: &mut World)

Creates and initializes a State for this WorldQuery type.

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

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

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.

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

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

impl<'w> Copy for EntityRef<'w>

impl ReadOnlyQueryData for EntityRef<'_>

SAFETY: access is read only