Struct SubEntity 

pub struct SubEntity<L>(/* private fields */)
where
    L: AppLabel + Clone + Copy + Eq;

Component added on the main world entities that are synced to the Sub World in order to keep track of the corresponding sub world entity.

Can also be used as a newtype wrapper for sub world entities.

Implementations

impl<L> SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

pub fn id(&self) -> Entity

Methods from Deref<Target = Entity>

pub const PLACEHOLDER: Entity

Trait Implementations

impl<L> ArchetypeQueryData for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

impl<L> Clone for SubEntity<L>

where L: Clone + AppLabel + Copy + Eq,

fn clone(&self) -> SubEntity<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L> Component for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq, SubEntity<L>: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<SubEntity<L>>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

const HAS_SUMMARY_TICK: bool = false

Set this constant to true if the component should track a summary tick.

impl<L> ContainsEntity for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

fn entity(&self) -> Entity

Returns the contained entity.

impl<L> Copy for SubEntity<L>

where L: Copy + AppLabel + Clone + Eq,

impl<L> Debug for SubEntity<L>

where L: Debug + AppLabel + Clone + Copy + Eq,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<L> Deref for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

type Target = Entity

The resulting type after dereferencing.

fn deref(&self) -> &<SubEntity<L> as Deref>::Target

Dereferences the value.

impl<L> EntityEquivalent for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

impl<L> Eq for SubEntity<L>

where L: Eq + AppLabel + Clone + Copy,

impl<L> From<Entity> for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

fn from(entity: Entity) -> SubEntity<L>

Converts to this type from the input type.

impl<L> Hash for SubEntity<L>

where L: Hash + AppLabel + Clone + Copy + Eq,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<L> IterQueryData for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

SAFETY: access is read only and only on the current entity

impl<L> PartialEq for SubEntity<L>

where L: PartialEq + AppLabel + Clone + Copy + Eq,

fn eq(&self, other: &SubEntity<L>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<L> QueryData for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

const IS_READ_ONLY: bool = true

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool = <&MainEntity as QueryData>::IS_ARCHETYPAL

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = SubEntity<L>

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

type Item<'w, 's> = Entity

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <SubEntity<L> as QueryData>::Item<'wlong, 's>, ) -> <SubEntity<L> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( state: &'s <SubEntity<L> as WorldQuery>::State, fetch: &mut <SubEntity<L> as WorldQuery>::Fetch<'w>, entity: Entity, table_row: TableRow, ) -> Option<<SubEntity<L> as QueryData>::Item<'w, 's>>

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 an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<SubEntity<L> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<L> ReadOnlyQueryData for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

SAFETY: access is read only

impl<L> ReleaseStateQueryData for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

fn release_state<'w>( item: <SubEntity<L> as QueryData>::Item<'w, '_>, ) -> <SubEntity<L> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<L> SingleEntityQueryData for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

SAFETY: access is only on the current entity

impl<L> StructuralPartialEq for SubEntity<L>

where L: PartialEq + AppLabel + Clone + Copy + Eq,

impl<L> WorldQuery for SubEntity<L>

where L: AppLabel + Clone + Copy + Eq,

const IS_DENSE: bool = <&'static SubEntity<L> as WorldQuery>::IS_DENSE

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

type Fetch<'w> = <&'static SubEntity<L> as WorldQuery>::Fetch<'w>

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

type State = <&'static SubEntity<L> as WorldQuery>::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_fetch<'wlong, 'wshort>( fetch: <SubEntity<L> as WorldQuery>::Fetch<'wlong>, ) -> <SubEntity<L> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( world: UnsafeWorldCell<'w>, component_id: &'s ComponentId, last_run: Tick, this_run: Tick, ) -> <SubEntity<L> as WorldQuery>::Fetch<'w>

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

unsafe fn set_archetype<'w, 's>( fetch: &mut <SubEntity<L> as WorldQuery>::Fetch<'w>, component_id: &'s ComponentId, archetype: &'w Archetype, table: &'w Table, )

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

unsafe fn set_table<'w, 's>( fetch: &mut <SubEntity<L> as WorldQuery>::Fetch<'w>, _: &'s ComponentId, table: &'w Table, )

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

fn update_component_access(_: &ComponentId, access: &mut FilteredAccess)

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

fn init_nested_access( _state: &<SubEntity<L> as WorldQuery>::State, _system_name: Option<&str>, _component_access_set: &mut FilteredAccessSet, _world: UnsafeWorldCell<'_>, )

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

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

Creates and initializes a State for this WorldQuery type.

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

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

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

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

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

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