Type Alias bevy::sprite::DrawSprite

pub type DrawSprite = (SetItemPipeline, SetSpriteViewBindGroup<0>, SetSpriteTextureBindGroup<1>, DrawSpriteBatch);

Trait Implementations

impl<'de, T0, T1, T2, T3> Deserialize<'de> for (T0, T1, T2, T3)where T0: Deserialize<'de>, T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<(T0, T1, T2, T3), <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P0, P1, P2, P3> ExclusiveSystemParam for (P0, P1, P2, P3)where P0: ExclusiveSystemParam, P1: ExclusiveSystemParam, P2: ExclusiveSystemParam, P3: ExclusiveSystemParam,

type State = (<P0 as ExclusiveSystemParam>::State, <P1 as ExclusiveSystemParam>::State, <P2 as ExclusiveSystemParam>::State, <P3 as ExclusiveSystemParam>::State)

Used to store data which persists across invocations of a system.

type Item<'s> = (<P0 as ExclusiveSystemParam>::Item<'s>, <P1 as ExclusiveSystemParam>::Item<'s>, <P2 as ExclusiveSystemParam>::Item<'s>, <P3 as ExclusiveSystemParam>::Item<'s>)

The item type returned when constructing this system param. See SystemParam::Item.

fn init( _world: &mut World, _system_meta: &mut SystemMeta ) -> <(P0, P1, P2, P3) as ExclusiveSystemParam>::State

Creates a new instance of this param’s State.

fn get_param<'s>( state: &'s mut <(P0, P1, P2, P3) as ExclusiveSystemParam>::State, system_meta: &SystemMeta ) -> <(P0, P1, P2, P3) as ExclusiveSystemParam>::Item<'s>

Creates a parameter to be passed into an ExclusiveSystemParamFunction.

impl<T> From<[T; 4]> for (T, T, T, T)

fn from(array: [T; 4]) -> (T, T, T, T)

Converts to this type from the input type.

impl<A, B, C, D> FromReflect for (A, B, C, D)where A: FromReflect + TypePath, B: FromReflect + TypePath, C: FromReflect + TypePath, D: FromReflect + TypePath,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<(A, B, C, D)>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect, Global> ) -> Result<Self, Box<dyn Reflect, Global>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl<A, B, C, D> GetTypeRegistration for (A, B, C, D)where A: Reflect + TypePath, B: Reflect + TypePath, C: Reflect + TypePath, D: Reflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl<T0, T1, T2, T3> IntoBindGroupLayoutEntryBuilderArray<4> for (T0, T1, T2, T3)where T0: IntoBindGroupLayoutEntryBuilder, T1: IntoBindGroupLayoutEntryBuilder, T2: IntoBindGroupLayoutEntryBuilder, T3: IntoBindGroupLayoutEntryBuilder,

fn into_array(self) -> [BindGroupLayoutEntryBuilder; 4]

impl<'b, T0, T1, T2, T3> IntoBindingArray<'b, 4> for (T0, T1, T2, T3)where T0: IntoBinding<'b>, T1: IntoBinding<'b>, T2: IntoBinding<'b>, T3: IntoBinding<'b>,

fn into_array(self) -> [BindingResource<'b>; 4]

impl<Marker, F> IntoSystem<<F as ExclusiveSystemParamFunction<Marker>>::In, <F as ExclusiveSystemParamFunction<Marker>>::Out, (IsExclusiveFunctionSystem, Marker)> for Fwhere Marker: 'static, F: ExclusiveSystemParamFunction<Marker>,

type System = ExclusiveFunctionSystem<Marker, F>

The type of System that this instance converts into.

fn into_system( func: F ) -> <F as IntoSystem<<F as ExclusiveSystemParamFunction<Marker>>::In, <F as ExclusiveSystemParamFunction<Marker>>::Out, (IsExclusiveFunctionSystem, Marker)>>::System

Turns this value into its corresponding System.

fn pipe<B, Final, MarkerB>( self, system: B ) -> CombinatorSystem<Pipe, Self::System, <B as IntoSystem<Out, Final, MarkerB>>::System>where B: IntoSystem<Out, Final, MarkerB>,

Pass the output of this system A into a second system B, creating a new compound system.

fn map<T, F>(self, f: F) -> AdapterSystem<F, Self::System>where F: Send + Sync + 'static + FnMut(Out) -> T,

Pass the output of this system into the passed function f, creating a new system that outputs the value returned from the function.

impl<Marker, F> IntoSystem<<F as SystemParamFunction<Marker>>::In, <F as SystemParamFunction<Marker>>::Out, (IsFunctionSystem, Marker)> for Fwhere Marker: 'static, F: SystemParamFunction<Marker>,

type System = FunctionSystem<Marker, F>

The type of System that this instance converts into.

fn into_system( func: F ) -> <F as IntoSystem<<F as SystemParamFunction<Marker>>::In, <F as SystemParamFunction<Marker>>::Out, (IsFunctionSystem, Marker)>>::System

Turns this value into its corresponding System.

fn pipe<B, Final, MarkerB>( self, system: B ) -> CombinatorSystem<Pipe, Self::System, <B as IntoSystem<Out, Final, MarkerB>>::System>where B: IntoSystem<Out, Final, MarkerB>,

Pass the output of this system A into a second system B, creating a new compound system.

fn map<T, F>(self, f: F) -> AdapterSystem<F, Self::System>where F: Send + Sync + 'static + FnMut(Out) -> T,

Pass the output of this system into the passed function f, creating a new system that outputs the value returned from the function.

impl<P0, S0, P1, S1, P2, S2, P3, S3> IntoSystemConfigs<(SystemConfigTupleMarker, P0, P1, P2, P3)> for (S0, S1, S2, S3)where S0: IntoSystemConfigs<P0>, S1: IntoSystemConfigs<P1>, S2: IntoSystemConfigs<P2>, S3: IntoSystemConfigs<P3>,

fn into_configs(self) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Convert into a SystemConfigs.

fn in_set( self, set: impl SystemSet ) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Add these systems to the provided set.

fn before<M>( self, set: impl IntoSystemSet<M> ) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Run before all systems in set.

fn after<M>( self, set: impl IntoSystemSet<M> ) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Run after all systems in set.

fn distributive_run_if<M>( self, condition: impl Condition<M, ()> + Clone ) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Add a run condition to each contained system.

fn run_if<M>( self, condition: impl Condition<M, ()> ) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Run the systems only if the Condition is true.

fn ambiguous_with<M>( self, set: impl IntoSystemSet<M> ) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in set.

fn ambiguous_with_all( self ) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

fn chain(self) -> NodeConfigs<Box<dyn System<In = (), Out = ()>, Global>>

Treat this collection as a sequence of systems.

impl<Marker, F> IntoSystemSet<(IsExclusiveFunctionSystem, Marker)> for Fwhere F: ExclusiveSystemParamFunction<Marker>,

type Set = SystemTypeSet<F>

The type of SystemSet this instance converts into.

fn into_system_set( self ) -> <F as IntoSystemSet<(IsExclusiveFunctionSystem, Marker)>>::Set

Converts this instance to its associated SystemSet type.

impl<Marker, F> IntoSystemSet<(IsFunctionSystem, Marker)> for Fwhere F: SystemParamFunction<Marker>,

type Set = SystemTypeSet<F>

The type of SystemSet this instance converts into.

fn into_system_set( self ) -> <F as IntoSystemSet<(IsFunctionSystem, Marker)>>::Set

Converts this instance to its associated SystemSet type.

impl<S0, S1, S2, S3> IntoSystemSetConfigs for (S0, S1, S2, S3)where S0: IntoSystemSetConfigs, S1: IntoSystemSetConfigs, S2: IntoSystemSetConfigs, S3: IntoSystemSetConfigs,

fn in_set(self, set: impl SystemSet) -> NodeConfigs<Interned<dyn SystemSet>>

Add these system sets to the provided set.

fn before<M>( self, set: impl IntoSystemSet<M> ) -> NodeConfigs<Interned<dyn SystemSet>>

Run before all systems in set.

fn after<M>( self, set: impl IntoSystemSet<M> ) -> NodeConfigs<Interned<dyn SystemSet>>

Run after all systems in set.

fn run_if<M>( self, condition: impl Condition<M, ()> ) -> NodeConfigs<Interned<dyn SystemSet>>

Run the systems in this set(s) only if the Condition is true.

fn ambiguous_with<M>( self, set: impl IntoSystemSet<M> ) -> NodeConfigs<Interned<dyn SystemSet>>

Suppress warnings and errors that would result from systems in these sets having ambiguities (conflicting access but indeterminate order) with systems in set.

fn ambiguous_with_all(self) -> NodeConfigs<Interned<dyn SystemSet>>

Suppress warnings and errors that would result from systems in these sets having ambiguities (conflicting access but indeterminate order) with any other system.

fn chain(self) -> NodeConfigs<Interned<dyn SystemSet>>

Treat this collection as a sequence of system sets.

impl<A, B, C, D> Reflect for (A, B, C, D)where A: Reflect + TypePath, B: Reflect + TypePath, C: Reflect + TypePath, D: Reflect + TypePath,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn into_any(self: Box<(A, B, C, D), Global>) -> Box<dyn Any, Global>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<(A, B, C, D), Global>) -> Box<dyn Reflect, Global>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value.

fn apply(&mut self, value: &(dyn Reflect + 'static))

Applies a reflected value to this value.

fn set( &mut self, value: Box<dyn Reflect, Global> ) -> Result<(), Box<dyn Reflect, Global>>

Performs a type-checked assignment of a reflected value to this value.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<(A, B, C, D), Global>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn clone_value(&self) -> Box<dyn Reflect, Global>

Clones the value as a Reflect trait object.

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<P, C0, C1, C2, C3> RenderCommand<P> for (C0, C1, C2, C3)where P: PhaseItem, C0: RenderCommand<P>, C1: RenderCommand<P>, C2: RenderCommand<P>, C3: RenderCommand<P>,

type Param = (<C0 as RenderCommand<P>>::Param, <C1 as RenderCommand<P>>::Param, <C2 as RenderCommand<P>>::Param, <C3 as RenderCommand<P>>::Param)

Specifies the general ECS data (e.g. resources) required by RenderCommand::render.

type ViewWorldQuery = (<C0 as RenderCommand<P>>::ViewWorldQuery, <C1 as RenderCommand<P>>::ViewWorldQuery, <C2 as RenderCommand<P>>::ViewWorldQuery, <C3 as RenderCommand<P>>::ViewWorldQuery)

Specifies the ECS data of the view entity required by RenderCommand::render.

type ItemWorldQuery = (<C0 as RenderCommand<P>>::ItemWorldQuery, <C1 as RenderCommand<P>>::ItemWorldQuery, <C2 as RenderCommand<P>>::ItemWorldQuery, <C3 as RenderCommand<P>>::ItemWorldQuery)

Specifies the ECS data of the item entity required by RenderCommand::render.

fn render<'w>( _item: &P, _: <<<(C0, C1, C2, C3) as RenderCommand<P>>::ViewWorldQuery as WorldQueryData>::ReadOnly as WorldQuery>::Item<'w>, _: <<<(C0, C1, C2, C3) as RenderCommand<P>>::ItemWorldQuery as WorldQueryData>::ReadOnly as WorldQuery>::Item<'w>, _: <<(C0, C1, C2, C3) as RenderCommand<P>>::Param as SystemParam>::Item<'w, '_>, _pass: &mut TrackedRenderPass<'w> ) -> RenderCommandResult

Renders a PhaseItem by recording commands (e.g. setting pipelines, binding bind groups, issuing draw calls, etc.) via the TrackedRenderPass.

impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3)where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<P0, P1, P2, P3> SystemParam for (P0, P1, P2, P3)where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam,

type State = (<P0 as SystemParam>::State, <P1 as SystemParam>::State, <P2 as SystemParam>::State, <P3 as SystemParam>::State)

Used to store data which persists across invocations of a system.

type Item<'w, 's> = (<P0 as SystemParam>::Item<'w, 's>, <P1 as SystemParam>::Item<'w, 's>, <P2 as SystemParam>::Item<'w, 's>, <P3 as SystemParam>::Item<'w, 's>)

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state( _world: &mut World, _system_meta: &mut SystemMeta ) -> <(P0, P1, P2, P3) as SystemParam>::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.

fn new_archetype( _: &mut <(P0, P1, P2, P3) as SystemParam>::State, _archetype: &Archetype, _system_meta: &mut SystemMeta )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).

fn apply( _: &mut <(P0, P1, P2, P3) as SystemParam>::State, _system_meta: &SystemMeta, _world: &mut World )

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during apply_deferred.

unsafe fn get_param<'w, 's>( state: &'s mut <(P0, P1, P2, P3) as SystemParam>::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, _change_tick: Tick ) -> <(P0, P1, P2, P3) as SystemParam>::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

impl<E, T0, T1, T2, T3> TryFrom<OwnedValue> for (T0, T1, T2, T3)where T0: TryFrom<Value<'static>, Error = E>, T1: TryFrom<Value<'static>, Error = E>, T2: TryFrom<Value<'static>, Error = E>, T3: TryFrom<Value<'static>, Error = E>, Error: From<E>,

type Error = Error

The type returned in the event of a conversion error.

fn try_from( v: OwnedValue ) -> Result<(T0, T1, T2, T3), <(T0, T1, T2, T3) as TryFrom<OwnedValue>>::Error>

Performs the conversion.

impl<'a, E, T0, T1, T2, T3> TryFrom<Structure<'a>> for (T0, T1, T2, T3)where T0: TryFrom<Value<'a>, Error = E>, T1: TryFrom<Value<'a>, Error = E>, T2: TryFrom<Value<'a>, Error = E>, T3: TryFrom<Value<'a>, Error = E>, Error: From<E>,

type Error = Error

The type returned in the event of a conversion error.

fn try_from( s: Structure<'a> ) -> Result<(T0, T1, T2, T3), <(T0, T1, T2, T3) as TryFrom<Structure<'a>>>::Error>

Performs the conversion.

impl<'a, E, T0, T1, T2, T3> TryFrom<Value<'a>> for (T0, T1, T2, T3)where T0: TryFrom<Value<'a>, Error = E>, T1: TryFrom<Value<'a>, Error = E>, T2: TryFrom<Value<'a>, Error = E>, T3: TryFrom<Value<'a>, Error = E>, Error: From<E>,

type Error = Error

The type returned in the event of a conversion error.

fn try_from( v: Value<'a> ) -> Result<(T0, T1, T2, T3), <(T0, T1, T2, T3) as TryFrom<Value<'a>>>::Error>

Performs the conversion.

impl<A, B, C, D> Tuple for (A, B, C, D)where A: Reflect + TypePath, B: Reflect + TypePath, C: Reflect + TypePath, D: Reflect + TypePath,

fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn field_len(&self) -> usize

Returns the number of fields in the tuple.

fn iter_fields(&self) -> TupleFieldIter<'_>

Returns an iterator over the values of the tuple’s fields.

fn drain( self: Box<(A, B, C, D), Global> ) -> Vec<Box<dyn Reflect, Global>, Global>

Drain the fields of this tuple to get a vector of owned values.

fn clone_dynamic(&self) -> DynamicTuple

Clones the struct into a DynamicTuple.

impl<P1, P2, P3, P0> TypePath for (P1, P2, P3, P0)where P1: TypePath, P2: TypePath, P3: TypePath, P0: TypePath,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl<A0, A1, A2, A3> TypeUuid for (A0, A1, A2, A3)where A0: TypeUuid, A1: TypeUuid, A2: TypeUuid, A3: TypeUuid,

const TYPE_UUID: Uuid = _

impl<A, B, C, D> Typed for (A, B, C, D)where A: Reflect + TypePath, B: Reflect + TypePath, C: Reflect + TypePath, D: Reflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl<F0, F1, F2, F3> WorldQuery for (F0, F1, F2, F3)where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>)

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

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>)

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

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 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<'wlong, 'wshort>( item: <(F0, F1, F2, F3) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3) as WorldQuery>::Item<'wshort>where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>

Creates a new instance of this fetch.

const IS_DENSE: bool = _

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.

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3) as WorldQuery>::State, _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>( _fetch: &mut <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3) as WorldQuery>::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>( _fetch: &mut <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3) as WorldQuery>::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: &<(F0, F1, F2, F3) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

Adds any component accesses used by this WorldQuery to access.

fn update_archetype_component_access( state: &<(F0, F1, F2, F3) as WorldQuery>::State, _archetype: &Archetype, _access: &mut Access<ArchetypeComponentId> )

For the given archetype, adds any component accessed used by this WorldQuery to access.

fn init_state(_world: &mut World) -> <(F0, F1, F2, F3) as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn matches_component_set( state: &<(F0, F1, F2, F3) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

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

impl<F0, F1, F2, F3> WorldQueryData for (F0, F1, F2, F3)where F0: WorldQueryData, F1: WorldQueryData, F2: WorldQueryData, F3: WorldQueryData,

type ReadOnly = (<F0 as WorldQueryData>::ReadOnly, <F1 as WorldQueryData>::ReadOnly, <F2 as WorldQueryData>::ReadOnly, <F3 as WorldQueryData>::ReadOnly)

The read-only variant of this WorldQueryData, which satisfies the ReadOnlyWorldQueryData trait.

impl<F0, F1, F2, F3> WorldQueryFilter for (F0, F1, F2, F3)where F0: WorldQueryFilter, F1: WorldQueryFilter, F2: WorldQueryFilter, F3: WorldQueryFilter,

const IS_ARCHETYPAL: bool = _

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

unsafe fn filter_fetch( fetch: &mut <(F0, F1, F2, F3) as WorldQuery>::Fetch<'_>, _entity: Entity, _table_row: TableRow ) -> bool

Safety

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

fn zeroed() -> Self

Calls zeroed.

impl<F0, F1, F2, F3> ArchetypeFilter for (F0, F1, F2, F3)where F0: ArchetypeFilter, F1: ArchetypeFilter, F2: ArchetypeFilter, F3: ArchetypeFilter,

impl<B0, B1, B2, B3> Bundle for (B0, B1, B2, B3)where B0: Bundle, B1: Bundle, B2: Bundle, B3: Bundle,

impl<B0, B1, B2, B3> DynamicBundle for (B0, B1, B2, B3)where B0: Bundle, B1: Bundle, B2: Bundle, B3: Bundle,

impl<P0, P1, P2, P3> ReadOnlySystemParam for (P0, P1, P2, P3)where P0: ReadOnlySystemParam, P1: ReadOnlySystemParam, P2: ReadOnlySystemParam, P3: ReadOnlySystemParam,

impl<F0, F1, F2, F3> ReadOnlyWorldQueryData for (F0, F1, F2, F3)where F0: ReadOnlyWorldQueryData, F1: ReadOnlyWorldQueryData, F2: ReadOnlyWorldQueryData, F3: ReadOnlyWorldQueryData,

SAFETY: each item in the tuple is read only