Type Alias oxygengine_core::prefab::PrefabSystemResources

pub type PrefabSystemResources<'a> = (&'a AssetsDatabase, &'a mut PrefabManager, &'a mut PrefabSystemCache);

Trait Implementations

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

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

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

([reads], [writes])

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

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

Checks if the Bundle contains the given T:

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

type 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() -> (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: <(C, B, A) as Fetch>::State)

Acquire dynamic borrows from archetype

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

Look up state for archetype if it should be traversed

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

Construct a Fetch for archetype based on the associated state

fn release(archetype: &Archetype, state: <(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<C, B, A> Query for (C, B, A)where C: Query, B: Query, A: Query,

type 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> ResQuery for (A, B, C)where A: ResQuery, B: ResQuery, C: ResQuery,

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

fn fetch(universe: &Universe) -> Self::Fetch

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

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

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

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