Type Alias oxygengine::prelude::HierarchySystemResources

pub type HierarchySystemResources<'a> = (WorldRef, &'a mut UniverseCommands, &'a EntityChanges, &'a mut Hierarchy, Comp<&'a Parent>, Comp<&'a Name>);

Trait Implementations

impl<A, B, C, D, E, F> AccessType for (A, B, C, D, E, F)where A: AccessType, B: AccessType, C: AccessType, D: AccessType, E: AccessType, F: AccessType,

fn feed_types( reads: &mut HashSet<TypeId, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

fn get_types() -> (HashSet<TypeId, RandomState>, HashSet<TypeId, RandomState>)

([reads], [writes])

impl<A, B, C, D, E, F> DataStackPack for (A, B, C, D, E, F)where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F)

fn pack_types() -> Vec<TypeHash, Global>

fn stack_push_reversed(self, stack: &mut DataStack)

impl<F, E, D, C, B, A> DynamicBundle for (F, E, D, C, B, A)where F: Component, E: Component, D: Component, C: Component, B: Component, A: Component,

fn has<T>(&self) -> boolwhere T: Component,

Checks if the Bundle contains the given T:

impl<F, E, D, C, B, A> Fetch for (F, E, D, C, B, A)where F: Fetch, E: Fetch, D: Fetch, C: Fetch, B: Fetch, A: Fetch,

type State = (<F as Fetch>::State, <E as Fetch>::State, <D as Fetch>::State, <C as Fetch>::State, <B as Fetch>::State, <A as Fetch>::State)

The type of the data which can be cached to speed up retrieving the relevant type states from a matching Archetype

fn dangling() -> (F, E, D, C, B, A)

A value on which get may never be called

fn access(archetype: &Archetype) -> Option<Access>

How this query will access archetype, if at all

fn borrow(archetype: &Archetype, state: <(F, E, D, C, B, A) as Fetch>::State)

Acquire dynamic borrows from archetype

fn prepare( archetype: &Archetype ) -> Option<<(F, E, D, C, B, A) as Fetch>::State>

Look up state for archetype if it should be traversed

fn execute( archetype: &Archetype, state: <(F, E, D, C, B, A) as Fetch>::State ) -> (F, E, D, C, B, A)

Construct a Fetch for archetype based on the associated state

fn release(archetype: &Archetype, state: <(F, E, D, C, B, A) as Fetch>::State)

Release dynamic borrows acquired by borrow

fn for_each_borrow(f: impl FnMut(TypeId, bool))

Invoke f for every component type that may be borrowed and whether the borrow is unique

impl<F, E, D, C, B, A> Query for (F, E, D, C, B, A)where F: Query, E: Query, D: Query, C: Query, B: Query, A: Query,

type Item<'q> = (<F as Query>::Item<'q>, <E as Query>::Item<'q>, <D as Query>::Item<'q>, <C as Query>::Item<'q>, <B as Query>::Item<'q>, <A as Query>::Item<'q>)

Type of results yielded by the query

impl<A, B, C, D, E, F> ResQuery for (A, B, C, D, E, F)where A: ResQuery, B: ResQuery, C: ResQuery, D: ResQuery, E: ResQuery, F: ResQuery,

type Fetch = (<A as ResQuery>::Fetch, <B as ResQuery>::Fetch, <C as ResQuery>::Fetch, <D as ResQuery>::Fetch, <E as ResQuery>::Fetch, <F as ResQuery>::Fetch)

fn fetch(universe: &Universe) -> <(A, B, C, D, E, F) as ResQuery>::Fetch

impl<F, E, D, C, B, A> Bundle for (F, E, D, C, B, A)where F: Component, E: Component, D: Component, C: Component, B: Component, A: Component,

impl<F, E, D, C, B, A> DynamicBundleClone for (F, E, D, C, B, A)where F: Component + Clone, E: Component + Clone, D: Component + Clone, C: Component + Clone, B: Component + Clone, A: Component + Clone,

impl<F, E, D, C, B, A> QueryShared for (F, E, D, C, B, A)where F: QueryShared, E: QueryShared, D: QueryShared, C: QueryShared, B: QueryShared, A: QueryShared,

impl<A, B, C, D, E, F> ResAccess for (A, B, C, D, E, F)where A: ResAccess, B: ResAccess, C: ResAccess, D: ResAccess, E: ResAccess, F: ResAccess,