Skip to content

Instantly share code, notes, and snippets.

@luser

luser/bevy_ecs.rs

Created August 12, 2020 21:24
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save luser/cac2e488be11c8bda12eb9d566acbfe2 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save luser/cac2e488be11c8bda12eb9d566acbfe2 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
bevy_ecs.rs
This file has been truncated, but you can view the full file.
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
pub use bevy_hecs::{Query as HecsQuery, *};
mod resource {
mod resource_query {
use super::{FromResources, Resources};
use crate::{system::{SystemId, TypeAccess}, Resource, ResourceIndex};
use core::{any::TypeId, ops::{Deref, DerefMut}, ptr::NonNull};
use bevy_hecs::smaller_tuples_too;
use std::marker::PhantomData;
/// Shared borrow of a Resource
pub struct Res<'a, T: Resource> {
value: &'a T,
}
impl <'a, T: Resource> Res<'a, T> {
pub unsafe fn new(value: NonNull<T>) -> Self {
Self{value: &*value.as_ptr(),}
}
}
/// A clone that is unsafe to perform. You probably shouldn't use this.
pub trait UnsafeClone {
unsafe fn unsafe_clone(&self)
-> Self;
}
impl <'a, T: Resource> UnsafeClone for Res<'a, T> {
unsafe fn unsafe_clone(&self) -> Self { Self{value: self.value,} }
}
unsafe impl <T: Resource> Send for Res<'_, T> { }
unsafe impl <T: Resource> Sync for Res<'_, T> { }
impl <'a, T: Resource> Deref for Res<'a, T> {
type Target = T;
fn deref(&self) -> &T { self.value }
}
/// Unique borrow of a Resource
pub struct ResMut<'a, T: Resource> {
_marker: PhantomData<&'a T>,
value: *mut T,
}
impl <'a, T: Resource> ResMut<'a, T> {
pub unsafe fn new(value: NonNull<T>) -> Self {
Self{value: value.as_ptr(), _marker: Default::default(),}
}
}
unsafe impl <T: Resource> Send for ResMut<'_, T> { }
unsafe impl <T: Resource> Sync for ResMut<'_, T> { }
impl <'a, T: Resource> Deref for ResMut<'a, T> {
type Target = T;
fn deref(&self) -> &T { unsafe { &*self.value } }
}
impl <'a, T: Resource> DerefMut for ResMut<'a, T> {
fn deref_mut(&mut self) -> &mut T { unsafe { &mut *self.value } }
}
impl <'a, T: Resource> UnsafeClone for ResMut<'a, T> {
unsafe fn unsafe_clone(&self) -> Self {
Self{value: self.value, _marker: Default::default(),}
}
}
/// Local<T> resources are unique per-system. Two instances of the same system will each have their own resource.
/// Local resources are automatically initialized using the FromResources trait.
pub struct Local<'a, T: Resource + FromResources> {
value: *mut T,
_marker: PhantomData<&'a T>,
}
impl <'a, T: Resource + FromResources> UnsafeClone for Local<'a, T> {
unsafe fn unsafe_clone(&self) -> Self {
Self{value: self.value, _marker: Default::default(),}
}
}
impl <'a, T: Resource + FromResources> Deref for Local<'a, T> {
type Target = T;
fn deref(&self) -> &T { unsafe { &*self.value } }
}
impl <'a, T: Resource + FromResources> DerefMut for Local<'a, T> {
fn deref_mut(&mut self) -> &mut T { unsafe { &mut *self.value } }
}
/// A collection of resource types fetch from a `Resources` collection
pub trait ResourceQuery {
type Fetch: for<'a> FetchResource<'a>;
fn initialize(_resources: &mut Resources,
_system_id: Option<SystemId>) {
}
}
/// Streaming iterators over contiguous homogeneous ranges of resources
pub trait FetchResource<'a>: Sized {
/// Type of value to be fetched
type Item: UnsafeClone;
fn access()
-> TypeAccess;
fn borrow(resources: &Resources);
fn release(resources: &Resources);
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>)
-> Self::Item;
}
impl <'a, T: Resource> ResourceQuery for Res<'a, T> {
type Fetch = FetchResourceRead<T>;
}
/// Fetches a shared resource reference
pub struct FetchResourceRead<T>(NonNull<T>);
impl <'a, T: Resource> FetchResource<'a> for FetchResourceRead<T> {
type Item = Res<'a, T>;
unsafe fn get(resources: &'a Resources,
_system_id: Option<SystemId>) -> Self::Item {
Res::new(resources.get_unsafe_ref::<T>(ResourceIndex::Global))
}
fn borrow(resources: &Resources) { resources.borrow::<T>(); }
fn release(resources: &Resources) { resources.release::<T>(); }
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.immutable.insert(TypeId::of::<T>());
access
}
}
impl <'a, T: Resource> ResourceQuery for ResMut<'a, T> {
type Fetch = FetchResourceWrite<T>;
}
/// Fetches a unique resource reference
pub struct FetchResourceWrite<T>(NonNull<T>);
impl <'a, T: Resource> FetchResource<'a> for FetchResourceWrite<T> {
type Item = ResMut<'a, T>;
unsafe fn get(resources: &'a Resources,
_system_id: Option<SystemId>) -> Self::Item {
ResMut::new(resources.get_unsafe_ref::<T>(ResourceIndex::Global))
}
fn borrow(resources: &Resources) { resources.borrow_mut::<T>(); }
fn release(resources: &Resources) {
resources.release_mut::<T>();
}
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.mutable.insert(TypeId::of::<T>());
access
}
}
impl <'a, T: Resource + FromResources> ResourceQuery for Local<'a, T>
{
type Fetch = FetchResourceLocalMut<T>;
fn initialize(resources: &mut Resources, id: Option<SystemId>) {
let value = T::from_resources(resources);
let id =
id.expect("Local<T> resources can only be used by systems");
resources.insert_local(id, value);
}
}
/// Fetches a `Local<T>` resource reference
pub struct FetchResourceLocalMut<T>(NonNull<T>);
impl <'a, T: Resource + FromResources> FetchResource<'a> for
FetchResourceLocalMut<T> {
type Item = Local<'a, T>;
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
let id =
system_id.expect("Local<T> resources can only be used by systems");
Local{value:
resources.get_unsafe_ref::<T>(ResourceIndex::System(id)).as_ptr(),
_marker: Default::default(),}
}
fn borrow(resources: &Resources) { resources.borrow_mut::<T>(); }
fn release(resources: &Resources) {
resources.release_mut::<T>();
}
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.mutable.insert(TypeId::of::<T>());
access
}
}
macro_rules! tuple_impl {
($ ($ name : ident), *) =>
{
impl < 'a, $ ($ name : FetchResource < 'a >), * >
FetchResource < 'a > for($ ($ name,) *)
{
type Item = ($ ($ name :: Item,) *) ; #
[allow(unused_variables)] fn
borrow(resources : & Resources)
{ $ ($ name :: borrow(resources) ;) * } #
[allow(unused_variables)] fn
release(resources : & Resources)
{ $ ($ name :: release(resources) ;) * } #
[allow(unused_variables)] unsafe fn
get(resources : & 'a Resources, system_id : Option <
SystemId >) -> Self :: Item
{ ($ ($ name :: get(resources, system_id),) *) } #
[allow(unused_mut)] fn access() -> TypeAccess
{
let mut access = TypeAccess :: default() ; $
(access . union(& $ name :: access()) ;) * access
}
} impl < $ ($ name : ResourceQuery), * > ResourceQuery
for($ ($ name,) *)
{
type Fetch = ($ ($ name :: Fetch,) *) ; #
[allow(unused_variables)] fn
initialize(resources : & mut Resources, system_id : Option
< SystemId >)
{ $ ($ name :: initialize(resources, system_id) ;) * }
} # [allow(unused_variables)] # [allow(non_snake_case)] impl <
$ ($ name : UnsafeClone), * > UnsafeClone for($ ($ name,) *)
{
unsafe fn unsafe_clone(& self) -> Self
{
let($ ($ name,) *) = self ;
($ ($ name . unsafe_clone(),) *)
}
}
} ;
}
impl <'a, O: FetchResource<'a>, N: FetchResource<'a>,
M: FetchResource<'a>, L: FetchResource<'a>,
K: FetchResource<'a>, J: FetchResource<'a>,
I: FetchResource<'a>, H: FetchResource<'a>,
G: FetchResource<'a>, F: FetchResource<'a>,
E: FetchResource<'a>, D: FetchResource<'a>,
C: FetchResource<'a>, B: FetchResource<'a>,
A: FetchResource<'a>> FetchResource<'a> for
(O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) {
type Item =
(O::Item, N::Item, M::Item, L::Item, K::Item, J::Item, I::Item,
H::Item, G::Item, F::Item, E::Item, D::Item, C::Item, B::Item,
A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
O::borrow(resources);
N::borrow(resources);
M::borrow(resources);
L::borrow(resources);
K::borrow(resources);
J::borrow(resources);
I::borrow(resources);
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
O::release(resources);
N::release(resources);
M::release(resources);
L::release(resources);
K::release(resources);
J::release(resources);
I::release(resources);
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(O::get(resources, system_id), N::get(resources, system_id),
M::get(resources, system_id), L::get(resources, system_id),
K::get(resources, system_id), J::get(resources, system_id),
I::get(resources, system_id), H::get(resources, system_id),
G::get(resources, system_id), F::get(resources, system_id),
E::get(resources, system_id), D::get(resources, system_id),
C::get(resources, system_id), B::get(resources, system_id),
A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&O::access());
access.union(&N::access());
access.union(&M::access());
access.union(&L::access());
access.union(&K::access());
access.union(&J::access());
access.union(&I::access());
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <O: ResourceQuery, N: ResourceQuery, M: ResourceQuery,
L: ResourceQuery, K: ResourceQuery, J: ResourceQuery,
I: ResourceQuery, H: ResourceQuery, G: ResourceQuery,
F: ResourceQuery, E: ResourceQuery, D: ResourceQuery,
C: ResourceQuery, B: ResourceQuery, A: ResourceQuery>
ResourceQuery for (O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) {
type Fetch =
(O::Fetch, N::Fetch, M::Fetch, L::Fetch, K::Fetch, J::Fetch,
I::Fetch, H::Fetch, G::Fetch, F::Fetch, E::Fetch, D::Fetch,
C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
O::initialize(resources, system_id);
N::initialize(resources, system_id);
M::initialize(resources, system_id);
L::initialize(resources, system_id);
K::initialize(resources, system_id);
J::initialize(resources, system_id);
I::initialize(resources, system_id);
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <O: UnsafeClone, N: UnsafeClone, M: UnsafeClone, L: UnsafeClone,
K: UnsafeClone, J: UnsafeClone, I: UnsafeClone, H: UnsafeClone,
G: UnsafeClone, F: UnsafeClone, E: UnsafeClone, D: UnsafeClone,
C: UnsafeClone, B: UnsafeClone, A: UnsafeClone> UnsafeClone for
(O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) = self;
(O.unsafe_clone(), N.unsafe_clone(), M.unsafe_clone(),
L.unsafe_clone(), K.unsafe_clone(), J.unsafe_clone(),
I.unsafe_clone(), H.unsafe_clone(), G.unsafe_clone(),
F.unsafe_clone(), E.unsafe_clone(), D.unsafe_clone(),
C.unsafe_clone(), B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, N: FetchResource<'a>, M: FetchResource<'a>,
L: FetchResource<'a>, K: FetchResource<'a>,
J: FetchResource<'a>, I: FetchResource<'a>,
H: FetchResource<'a>, G: FetchResource<'a>,
F: FetchResource<'a>, E: FetchResource<'a>,
D: FetchResource<'a>, C: FetchResource<'a>,
B: FetchResource<'a>, A: FetchResource<'a>> FetchResource<'a>
for (N, M, L, K, J, I, H, G, F, E, D, C, B, A) {
type Item =
(N::Item, M::Item, L::Item, K::Item, J::Item, I::Item, H::Item,
G::Item, F::Item, E::Item, D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
N::borrow(resources);
M::borrow(resources);
L::borrow(resources);
K::borrow(resources);
J::borrow(resources);
I::borrow(resources);
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
N::release(resources);
M::release(resources);
L::release(resources);
K::release(resources);
J::release(resources);
I::release(resources);
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(N::get(resources, system_id), M::get(resources, system_id),
L::get(resources, system_id), K::get(resources, system_id),
J::get(resources, system_id), I::get(resources, system_id),
H::get(resources, system_id), G::get(resources, system_id),
F::get(resources, system_id), E::get(resources, system_id),
D::get(resources, system_id), C::get(resources, system_id),
B::get(resources, system_id), A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&N::access());
access.union(&M::access());
access.union(&L::access());
access.union(&K::access());
access.union(&J::access());
access.union(&I::access());
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <N: ResourceQuery, M: ResourceQuery, L: ResourceQuery,
K: ResourceQuery, J: ResourceQuery, I: ResourceQuery,
H: ResourceQuery, G: ResourceQuery, F: ResourceQuery,
E: ResourceQuery, D: ResourceQuery, C: ResourceQuery,
B: ResourceQuery, A: ResourceQuery> ResourceQuery for
(N, M, L, K, J, I, H, G, F, E, D, C, B, A) {
type Fetch =
(N::Fetch, M::Fetch, L::Fetch, K::Fetch, J::Fetch, I::Fetch,
H::Fetch, G::Fetch, F::Fetch, E::Fetch, D::Fetch, C::Fetch,
B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
N::initialize(resources, system_id);
M::initialize(resources, system_id);
L::initialize(resources, system_id);
K::initialize(resources, system_id);
J::initialize(resources, system_id);
I::initialize(resources, system_id);
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <N: UnsafeClone, M: UnsafeClone, L: UnsafeClone, K: UnsafeClone,
J: UnsafeClone, I: UnsafeClone, H: UnsafeClone, G: UnsafeClone,
F: UnsafeClone, E: UnsafeClone, D: UnsafeClone, C: UnsafeClone,
B: UnsafeClone, A: UnsafeClone> UnsafeClone for
(N, M, L, K, J, I, H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (N, M, L, K, J, I, H, G, F, E, D, C, B, A) = self;
(N.unsafe_clone(), M.unsafe_clone(), L.unsafe_clone(),
K.unsafe_clone(), J.unsafe_clone(), I.unsafe_clone(),
H.unsafe_clone(), G.unsafe_clone(), F.unsafe_clone(),
E.unsafe_clone(), D.unsafe_clone(), C.unsafe_clone(),
B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, M: FetchResource<'a>, L: FetchResource<'a>,
K: FetchResource<'a>, J: FetchResource<'a>,
I: FetchResource<'a>, H: FetchResource<'a>,
G: FetchResource<'a>, F: FetchResource<'a>,
E: FetchResource<'a>, D: FetchResource<'a>,
C: FetchResource<'a>, B: FetchResource<'a>,
A: FetchResource<'a>> FetchResource<'a> for
(M, L, K, J, I, H, G, F, E, D, C, B, A) {
type Item =
(M::Item, L::Item, K::Item, J::Item, I::Item, H::Item, G::Item,
F::Item, E::Item, D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
M::borrow(resources);
L::borrow(resources);
K::borrow(resources);
J::borrow(resources);
I::borrow(resources);
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
M::release(resources);
L::release(resources);
K::release(resources);
J::release(resources);
I::release(resources);
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(M::get(resources, system_id), L::get(resources, system_id),
K::get(resources, system_id), J::get(resources, system_id),
I::get(resources, system_id), H::get(resources, system_id),
G::get(resources, system_id), F::get(resources, system_id),
E::get(resources, system_id), D::get(resources, system_id),
C::get(resources, system_id), B::get(resources, system_id),
A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&M::access());
access.union(&L::access());
access.union(&K::access());
access.union(&J::access());
access.union(&I::access());
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <M: ResourceQuery, L: ResourceQuery, K: ResourceQuery,
J: ResourceQuery, I: ResourceQuery, H: ResourceQuery,
G: ResourceQuery, F: ResourceQuery, E: ResourceQuery,
D: ResourceQuery, C: ResourceQuery, B: ResourceQuery,
A: ResourceQuery> ResourceQuery for
(M, L, K, J, I, H, G, F, E, D, C, B, A) {
type Fetch =
(M::Fetch, L::Fetch, K::Fetch, J::Fetch, I::Fetch, H::Fetch,
G::Fetch, F::Fetch, E::Fetch, D::Fetch, C::Fetch, B::Fetch,
A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
M::initialize(resources, system_id);
L::initialize(resources, system_id);
K::initialize(resources, system_id);
J::initialize(resources, system_id);
I::initialize(resources, system_id);
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <M: UnsafeClone, L: UnsafeClone, K: UnsafeClone, J: UnsafeClone,
I: UnsafeClone, H: UnsafeClone, G: UnsafeClone, F: UnsafeClone,
E: UnsafeClone, D: UnsafeClone, C: UnsafeClone, B: UnsafeClone,
A: UnsafeClone> UnsafeClone for
(M, L, K, J, I, H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (M, L, K, J, I, H, G, F, E, D, C, B, A) = self;
(M.unsafe_clone(), L.unsafe_clone(), K.unsafe_clone(),
J.unsafe_clone(), I.unsafe_clone(), H.unsafe_clone(),
G.unsafe_clone(), F.unsafe_clone(), E.unsafe_clone(),
D.unsafe_clone(), C.unsafe_clone(), B.unsafe_clone(),
A.unsafe_clone())
}
}
impl <'a, L: FetchResource<'a>, K: FetchResource<'a>,
J: FetchResource<'a>, I: FetchResource<'a>,
H: FetchResource<'a>, G: FetchResource<'a>,
F: FetchResource<'a>, E: FetchResource<'a>,
D: FetchResource<'a>, C: FetchResource<'a>,
B: FetchResource<'a>, A: FetchResource<'a>> FetchResource<'a>
for (L, K, J, I, H, G, F, E, D, C, B, A) {
type Item =
(L::Item, K::Item, J::Item, I::Item, H::Item, G::Item, F::Item,
E::Item, D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
L::borrow(resources);
K::borrow(resources);
J::borrow(resources);
I::borrow(resources);
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
L::release(resources);
K::release(resources);
J::release(resources);
I::release(resources);
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(L::get(resources, system_id), K::get(resources, system_id),
J::get(resources, system_id), I::get(resources, system_id),
H::get(resources, system_id), G::get(resources, system_id),
F::get(resources, system_id), E::get(resources, system_id),
D::get(resources, system_id), C::get(resources, system_id),
B::get(resources, system_id), A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&L::access());
access.union(&K::access());
access.union(&J::access());
access.union(&I::access());
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <L: ResourceQuery, K: ResourceQuery, J: ResourceQuery,
I: ResourceQuery, H: ResourceQuery, G: ResourceQuery,
F: ResourceQuery, E: ResourceQuery, D: ResourceQuery,
C: ResourceQuery, B: ResourceQuery, A: ResourceQuery>
ResourceQuery for (L, K, J, I, H, G, F, E, D, C, B, A) {
type Fetch =
(L::Fetch, K::Fetch, J::Fetch, I::Fetch, H::Fetch, G::Fetch,
F::Fetch, E::Fetch, D::Fetch, C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
L::initialize(resources, system_id);
K::initialize(resources, system_id);
J::initialize(resources, system_id);
I::initialize(resources, system_id);
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <L: UnsafeClone, K: UnsafeClone, J: UnsafeClone, I: UnsafeClone,
H: UnsafeClone, G: UnsafeClone, F: UnsafeClone, E: UnsafeClone,
D: UnsafeClone, C: UnsafeClone, B: UnsafeClone, A: UnsafeClone>
UnsafeClone for (L, K, J, I, H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (L, K, J, I, H, G, F, E, D, C, B, A) = self;
(L.unsafe_clone(), K.unsafe_clone(), J.unsafe_clone(),
I.unsafe_clone(), H.unsafe_clone(), G.unsafe_clone(),
F.unsafe_clone(), E.unsafe_clone(), D.unsafe_clone(),
C.unsafe_clone(), B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, K: FetchResource<'a>, J: FetchResource<'a>,
I: FetchResource<'a>, H: FetchResource<'a>,
G: FetchResource<'a>, F: FetchResource<'a>,
E: FetchResource<'a>, D: FetchResource<'a>,
C: FetchResource<'a>, B: FetchResource<'a>,
A: FetchResource<'a>> FetchResource<'a> for
(K, J, I, H, G, F, E, D, C, B, A) {
type Item =
(K::Item, J::Item, I::Item, H::Item, G::Item, F::Item, E::Item,
D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
K::borrow(resources);
J::borrow(resources);
I::borrow(resources);
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
K::release(resources);
J::release(resources);
I::release(resources);
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(K::get(resources, system_id), J::get(resources, system_id),
I::get(resources, system_id), H::get(resources, system_id),
G::get(resources, system_id), F::get(resources, system_id),
E::get(resources, system_id), D::get(resources, system_id),
C::get(resources, system_id), B::get(resources, system_id),
A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&K::access());
access.union(&J::access());
access.union(&I::access());
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <K: ResourceQuery, J: ResourceQuery, I: ResourceQuery,
H: ResourceQuery, G: ResourceQuery, F: ResourceQuery,
E: ResourceQuery, D: ResourceQuery, C: ResourceQuery,
B: ResourceQuery, A: ResourceQuery> ResourceQuery for
(K, J, I, H, G, F, E, D, C, B, A) {
type Fetch =
(K::Fetch, J::Fetch, I::Fetch, H::Fetch, G::Fetch, F::Fetch,
E::Fetch, D::Fetch, C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
K::initialize(resources, system_id);
J::initialize(resources, system_id);
I::initialize(resources, system_id);
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <K: UnsafeClone, J: UnsafeClone, I: UnsafeClone, H: UnsafeClone,
G: UnsafeClone, F: UnsafeClone, E: UnsafeClone, D: UnsafeClone,
C: UnsafeClone, B: UnsafeClone, A: UnsafeClone> UnsafeClone for
(K, J, I, H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (K, J, I, H, G, F, E, D, C, B, A) = self;
(K.unsafe_clone(), J.unsafe_clone(), I.unsafe_clone(),
H.unsafe_clone(), G.unsafe_clone(), F.unsafe_clone(),
E.unsafe_clone(), D.unsafe_clone(), C.unsafe_clone(),
B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, J: FetchResource<'a>, I: FetchResource<'a>,
H: FetchResource<'a>, G: FetchResource<'a>,
F: FetchResource<'a>, E: FetchResource<'a>,
D: FetchResource<'a>, C: FetchResource<'a>,
B: FetchResource<'a>, A: FetchResource<'a>> FetchResource<'a>
for (J, I, H, G, F, E, D, C, B, A) {
type Item =
(J::Item, I::Item, H::Item, G::Item, F::Item, E::Item, D::Item,
C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
J::borrow(resources);
I::borrow(resources);
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
J::release(resources);
I::release(resources);
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(J::get(resources, system_id), I::get(resources, system_id),
H::get(resources, system_id), G::get(resources, system_id),
F::get(resources, system_id), E::get(resources, system_id),
D::get(resources, system_id), C::get(resources, system_id),
B::get(resources, system_id), A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&J::access());
access.union(&I::access());
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <J: ResourceQuery, I: ResourceQuery, H: ResourceQuery,
G: ResourceQuery, F: ResourceQuery, E: ResourceQuery,
D: ResourceQuery, C: ResourceQuery, B: ResourceQuery,
A: ResourceQuery> ResourceQuery for
(J, I, H, G, F, E, D, C, B, A) {
type Fetch =
(J::Fetch, I::Fetch, H::Fetch, G::Fetch, F::Fetch, E::Fetch,
D::Fetch, C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
J::initialize(resources, system_id);
I::initialize(resources, system_id);
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <J: UnsafeClone, I: UnsafeClone, H: UnsafeClone, G: UnsafeClone,
F: UnsafeClone, E: UnsafeClone, D: UnsafeClone, C: UnsafeClone,
B: UnsafeClone, A: UnsafeClone> UnsafeClone for
(J, I, H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (J, I, H, G, F, E, D, C, B, A) = self;
(J.unsafe_clone(), I.unsafe_clone(), H.unsafe_clone(),
G.unsafe_clone(), F.unsafe_clone(), E.unsafe_clone(),
D.unsafe_clone(), C.unsafe_clone(), B.unsafe_clone(),
A.unsafe_clone())
}
}
impl <'a, I: FetchResource<'a>, H: FetchResource<'a>,
G: FetchResource<'a>, F: FetchResource<'a>,
E: FetchResource<'a>, D: FetchResource<'a>,
C: FetchResource<'a>, B: FetchResource<'a>,
A: FetchResource<'a>> FetchResource<'a> for
(I, H, G, F, E, D, C, B, A) {
type Item =
(I::Item, H::Item, G::Item, F::Item, E::Item, D::Item, C::Item,
B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
I::borrow(resources);
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
I::release(resources);
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(I::get(resources, system_id), H::get(resources, system_id),
G::get(resources, system_id), F::get(resources, system_id),
E::get(resources, system_id), D::get(resources, system_id),
C::get(resources, system_id), B::get(resources, system_id),
A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&I::access());
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <I: ResourceQuery, H: ResourceQuery, G: ResourceQuery,
F: ResourceQuery, E: ResourceQuery, D: ResourceQuery,
C: ResourceQuery, B: ResourceQuery, A: ResourceQuery>
ResourceQuery for (I, H, G, F, E, D, C, B, A) {
type Fetch =
(I::Fetch, H::Fetch, G::Fetch, F::Fetch, E::Fetch, D::Fetch,
C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
I::initialize(resources, system_id);
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <I: UnsafeClone, H: UnsafeClone, G: UnsafeClone, F: UnsafeClone,
E: UnsafeClone, D: UnsafeClone, C: UnsafeClone, B: UnsafeClone,
A: UnsafeClone> UnsafeClone for (I, H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (I, H, G, F, E, D, C, B, A) = self;
(I.unsafe_clone(), H.unsafe_clone(), G.unsafe_clone(),
F.unsafe_clone(), E.unsafe_clone(), D.unsafe_clone(),
C.unsafe_clone(), B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, H: FetchResource<'a>, G: FetchResource<'a>,
F: FetchResource<'a>, E: FetchResource<'a>,
D: FetchResource<'a>, C: FetchResource<'a>,
B: FetchResource<'a>, A: FetchResource<'a>> FetchResource<'a>
for (H, G, F, E, D, C, B, A) {
type Item =
(H::Item, G::Item, F::Item, E::Item, D::Item, C::Item, B::Item,
A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
H::borrow(resources);
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
H::release(resources);
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(H::get(resources, system_id), G::get(resources, system_id),
F::get(resources, system_id), E::get(resources, system_id),
D::get(resources, system_id), C::get(resources, system_id),
B::get(resources, system_id), A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&H::access());
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <H: ResourceQuery, G: ResourceQuery, F: ResourceQuery,
E: ResourceQuery, D: ResourceQuery, C: ResourceQuery,
B: ResourceQuery, A: ResourceQuery> ResourceQuery for
(H, G, F, E, D, C, B, A) {
type Fetch =
(H::Fetch, G::Fetch, F::Fetch, E::Fetch, D::Fetch, C::Fetch,
B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
H::initialize(resources, system_id);
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <H: UnsafeClone, G: UnsafeClone, F: UnsafeClone, E: UnsafeClone,
D: UnsafeClone, C: UnsafeClone, B: UnsafeClone, A: UnsafeClone>
UnsafeClone for (H, G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (H, G, F, E, D, C, B, A) = self;
(H.unsafe_clone(), G.unsafe_clone(), F.unsafe_clone(),
E.unsafe_clone(), D.unsafe_clone(), C.unsafe_clone(),
B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, G: FetchResource<'a>, F: FetchResource<'a>,
E: FetchResource<'a>, D: FetchResource<'a>,
C: FetchResource<'a>, B: FetchResource<'a>,
A: FetchResource<'a>> FetchResource<'a> for
(G, F, E, D, C, B, A) {
type Item =
(G::Item, F::Item, E::Item, D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
G::borrow(resources);
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
G::release(resources);
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(G::get(resources, system_id), F::get(resources, system_id),
E::get(resources, system_id), D::get(resources, system_id),
C::get(resources, system_id), B::get(resources, system_id),
A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&G::access());
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <G: ResourceQuery, F: ResourceQuery, E: ResourceQuery,
D: ResourceQuery, C: ResourceQuery, B: ResourceQuery,
A: ResourceQuery> ResourceQuery for (G, F, E, D, C, B, A) {
type Fetch =
(G::Fetch, F::Fetch, E::Fetch, D::Fetch, C::Fetch, B::Fetch,
A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
G::initialize(resources, system_id);
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <G: UnsafeClone, F: UnsafeClone, E: UnsafeClone, D: UnsafeClone,
C: UnsafeClone, B: UnsafeClone, A: UnsafeClone> UnsafeClone for
(G, F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (G, F, E, D, C, B, A) = self;
(G.unsafe_clone(), F.unsafe_clone(), E.unsafe_clone(),
D.unsafe_clone(), C.unsafe_clone(), B.unsafe_clone(),
A.unsafe_clone())
}
}
impl <'a, F: FetchResource<'a>, E: FetchResource<'a>,
D: FetchResource<'a>, C: FetchResource<'a>,
B: FetchResource<'a>, A: FetchResource<'a>> FetchResource<'a>
for (F, E, D, C, B, A) {
type Item =
(F::Item, E::Item, D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
F::borrow(resources);
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
F::release(resources);
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(F::get(resources, system_id), E::get(resources, system_id),
D::get(resources, system_id), C::get(resources, system_id),
B::get(resources, system_id), A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&F::access());
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <F: ResourceQuery, E: ResourceQuery, D: ResourceQuery,
C: ResourceQuery, B: ResourceQuery, A: ResourceQuery>
ResourceQuery for (F, E, D, C, B, A) {
type Fetch =
(F::Fetch, E::Fetch, D::Fetch, C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
F::initialize(resources, system_id);
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <F: UnsafeClone, E: UnsafeClone, D: UnsafeClone, C: UnsafeClone,
B: UnsafeClone, A: UnsafeClone> UnsafeClone for
(F, E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (F, E, D, C, B, A) = self;
(F.unsafe_clone(), E.unsafe_clone(), D.unsafe_clone(),
C.unsafe_clone(), B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, E: FetchResource<'a>, D: FetchResource<'a>,
C: FetchResource<'a>, B: FetchResource<'a>,
A: FetchResource<'a>> FetchResource<'a> for (E, D, C, B, A) {
type Item = (E::Item, D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
E::borrow(resources);
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
E::release(resources);
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(E::get(resources, system_id), D::get(resources, system_id),
C::get(resources, system_id), B::get(resources, system_id),
A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&E::access());
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <E: ResourceQuery, D: ResourceQuery, C: ResourceQuery,
B: ResourceQuery, A: ResourceQuery> ResourceQuery for
(E, D, C, B, A) {
type Fetch = (E::Fetch, D::Fetch, C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
E::initialize(resources, system_id);
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <E: UnsafeClone, D: UnsafeClone, C: UnsafeClone, B: UnsafeClone,
A: UnsafeClone> UnsafeClone for (E, D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (E, D, C, B, A) = self;
(E.unsafe_clone(), D.unsafe_clone(), C.unsafe_clone(),
B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, D: FetchResource<'a>, C: FetchResource<'a>,
B: FetchResource<'a>, A: FetchResource<'a>> FetchResource<'a>
for (D, C, B, A) {
type Item = (D::Item, C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
D::borrow(resources);
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
D::release(resources);
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(D::get(resources, system_id), C::get(resources, system_id),
B::get(resources, system_id), A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&D::access());
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <D: ResourceQuery, C: ResourceQuery, B: ResourceQuery,
A: ResourceQuery> ResourceQuery for (D, C, B, A) {
type Fetch = (D::Fetch, C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
D::initialize(resources, system_id);
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <D: UnsafeClone, C: UnsafeClone, B: UnsafeClone, A: UnsafeClone>
UnsafeClone for (D, C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (D, C, B, A) = self;
(D.unsafe_clone(), C.unsafe_clone(), B.unsafe_clone(),
A.unsafe_clone())
}
}
impl <'a, C: FetchResource<'a>, B: FetchResource<'a>,
A: FetchResource<'a>> FetchResource<'a> for (C, B, A) {
type Item = (C::Item, B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
C::borrow(resources);
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
C::release(resources);
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(C::get(resources, system_id), B::get(resources, system_id),
A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&C::access());
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <C: ResourceQuery, B: ResourceQuery, A: ResourceQuery>
ResourceQuery for (C, B, A) {
type Fetch = (C::Fetch, B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
C::initialize(resources, system_id);
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <C: UnsafeClone, B: UnsafeClone, A: UnsafeClone> UnsafeClone for
(C, B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (C, B, A) = self;
(C.unsafe_clone(), B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, B: FetchResource<'a>, A: FetchResource<'a>>
FetchResource<'a> for (B, A) {
type Item = (B::Item, A::Item);
#[allow(unused_variables)]
fn borrow(resources: &Resources) {
B::borrow(resources);
A::borrow(resources);
}
#[allow(unused_variables)]
fn release(resources: &Resources) {
B::release(resources);
A::release(resources);
}
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(B::get(resources, system_id), A::get(resources, system_id))
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&B::access());
access.union(&A::access());
access
}
}
impl <B: ResourceQuery, A: ResourceQuery> ResourceQuery for (B, A) {
type Fetch = (B::Fetch, A::Fetch);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
B::initialize(resources, system_id);
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <B: UnsafeClone, A: UnsafeClone> UnsafeClone for (B, A) {
unsafe fn unsafe_clone(&self) -> Self {
let (B, A) = self;
(B.unsafe_clone(), A.unsafe_clone())
}
}
impl <'a, A: FetchResource<'a>> FetchResource<'a> for (A,) {
type Item = (A::Item,);
#[allow(unused_variables)]
fn borrow(resources: &Resources) { A::borrow(resources); }
#[allow(unused_variables)]
fn release(resources: &Resources) { A::release(resources); }
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
(A::get(resources, system_id),)
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access.union(&A::access());
access
}
}
impl <A: ResourceQuery> ResourceQuery for (A,) {
type Fetch = (A::Fetch,);
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
A::initialize(resources, system_id);
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl <A: UnsafeClone> UnsafeClone for (A,) {
unsafe fn unsafe_clone(&self) -> Self {
let (A,) = self;
(A.unsafe_clone(),)
}
}
impl <'a> FetchResource<'a> for () {
type Item = ();
#[allow(unused_variables)]
fn borrow(resources: &Resources) { }
#[allow(unused_variables)]
fn release(resources: &Resources) { }
#[allow(unused_variables)]
unsafe fn get(resources: &'a Resources,
system_id: Option<SystemId>) -> Self::Item {
()
}
#[allow(unused_mut)]
fn access() -> TypeAccess {
let mut access = TypeAccess::default();
access
}
}
impl ResourceQuery for () {
type Fetch = ();
#[allow(unused_variables)]
fn initialize(resources: &mut Resources,
system_id: Option<SystemId>) {
}
}
#[allow(unused_variables)]
#[allow(non_snake_case)]
impl UnsafeClone for () {
unsafe fn unsafe_clone(&self) -> Self { let () = self; () }
}
}
mod resources {
use super::{FetchResource, ResourceQuery};
use crate::system::SystemId;
use core::any::TypeId;
use bevy_hecs::{Archetype, Ref, RefMut, TypeInfo};
use std::{collections::HashMap, ptr::NonNull};
/// A Resource type
pub trait Resource: Send + Sync + 'static { }
impl <T: Send + Sync + 'static> Resource for T { }
pub(crate) struct ResourceData {
archetype: Archetype,
default_index: Option<u32>,
system_id_to_archetype_index: HashMap<u32, u32>,
}
pub enum ResourceIndex { Global, System(SystemId), }
/// A collection of resource instances identified by their type.
pub struct Resources {
pub(crate) resource_data: HashMap<TypeId, ResourceData>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for Resources {
#[inline]
fn default() -> Resources {
Resources{resource_data: ::core::default::Default::default(),}
}
}
impl Resources {
pub fn insert<T: Resource>(&mut self, resource: T) {
self.insert_resource(resource, ResourceIndex::Global);
}
pub fn contains<T: Resource>(&self) -> bool {
self.get_resource::<T>(ResourceIndex::Global).is_some()
}
pub fn get<T: Resource>(&self) -> Option<Ref<'_, T>> {
self.get_resource(ResourceIndex::Global)
}
pub fn get_mut<T: Resource>(&self) -> Option<RefMut<'_, T>> {
self.get_resource_mut(ResourceIndex::Global)
}
pub fn get_local<'a, T: Resource>(&'a self, id: SystemId)
-> Option<Ref<'a, T>> {
self.get_resource(ResourceIndex::System(id))
}
pub fn get_local_mut<'a, T: Resource>(&'a self, id: SystemId)
-> Option<RefMut<'a, T>> {
self.get_resource_mut(ResourceIndex::System(id))
}
pub fn insert_local<T: Resource>(&mut self, id: SystemId,
resource: T) {
self.insert_resource(resource, ResourceIndex::System(id))
}
fn insert_resource<T: Resource>(&mut self, mut resource: T,
resource_index: ResourceIndex) {
let type_id = TypeId::of::<T>();
let data =
self.resource_data.entry(type_id).or_insert_with(||
{
let mut types =
Vec::new();
types.push(TypeInfo::of::<T>());
ResourceData{archetype:
Archetype::new(types),
default_index:
None,
system_id_to_archetype_index:
HashMap::new(),}
});
let archetype = &mut data.archetype;
let mut added = false;
let index =
match resource_index {
ResourceIndex::Global =>
*data.default_index.get_or_insert_with(||
{
added =
true;
archetype.len()
}),
ResourceIndex::System(id) =>
*data.system_id_to_archetype_index.entry(id.0).or_insert_with(||
{
added
=
true;
archetype.len()
}),
};
if index == archetype.len() {
unsafe { archetype.allocate(index) };
} else if index > archetype.len() {
{
::std::rt::begin_panic("attempted to access index beyond 'current_capacity + 1'")
}
}
unsafe {
let resource_ptr = (&mut resource as *mut T).cast::<u8>();
archetype.put_dynamic(resource_ptr, type_id,
core::mem::size_of::<T>(), index,
added);
std::mem::forget(resource);
}
}
fn get_resource<T: Resource>(&self, resource_index: ResourceIndex)
-> Option<Ref<'_, T>> {
self.resource_data.get(&TypeId::of::<T>()).and_then(|data|
unsafe
{
let index =
match resource_index
{
ResourceIndex::Global
=>
data.default_index?,
ResourceIndex::System(id)
=>
*data.system_id_to_archetype_index.get(&id.0)?,
};
Ref::new(&data.archetype,
index).ok()
})
}
fn get_resource_mut<T: Resource>(&self,
resource_index: ResourceIndex)
-> Option<RefMut<'_, T>> {
self.resource_data.get(&TypeId::of::<T>()).and_then(|data|
unsafe
{
let index =
match resource_index
{
ResourceIndex::Global
=>
data.default_index?,
ResourceIndex::System(id)
=>
*data.system_id_to_archetype_index.get(&id.0)?,
};
RefMut::new(&data.archetype,
index).ok()
})
}
pub fn query<Q: ResourceQuery>(&self)
-> <Q::Fetch as FetchResource>::Item {
unsafe { Q::Fetch::get(&self, None) }
}
pub fn query_system<Q: ResourceQuery>(&self, id: SystemId)
-> <Q::Fetch as FetchResource>::Item {
unsafe { Q::Fetch::get(&self, Some(id)) }
}
#[inline]
pub unsafe fn get_unsafe_ref<T: Resource>(&self,
resource_index:
ResourceIndex)
-> NonNull<T> {
self.resource_data.get(&TypeId::of::<T>()).and_then(|data|
{
let index =
match resource_index
{
ResourceIndex::Global
=>
data.default_index?,
ResourceIndex::System(id)
=>
{
data.system_id_to_archetype_index.get(&id.0).cloned()?
}
};
Some(NonNull::new_unchecked(data.archetype.get::<T>()?.as_ptr().add(index
as
usize)))
}).unwrap_or_else(||
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Resource does not exist "],
&match (&std::any::type_name::<T>(),)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
})
}
pub fn borrow<T: Resource>(&self) {
if let Some(data) = self.resource_data.get(&TypeId::of::<T>())
{
data.archetype.borrow::<T>();
}
}
pub fn release<T: Resource>(&self) {
if let Some(data) = self.resource_data.get(&TypeId::of::<T>())
{
data.archetype.release::<T>();
}
}
pub fn borrow_mut<T: Resource>(&self) {
if let Some(data) = self.resource_data.get(&TypeId::of::<T>())
{
data.archetype.borrow_mut::<T>();
}
}
pub fn release_mut<T: Resource>(&self) {
if let Some(data) = self.resource_data.get(&TypeId::of::<T>())
{
data.archetype.release_mut::<T>();
}
}
}
unsafe impl Send for Resources { }
unsafe impl Sync for Resources { }
/// Creates `Self` using data from the `Resources` collection
pub trait FromResources {
/// Creates `Self` using data from the `Resources` collection
fn from_resources(resources: &Resources)
-> Self;
}
impl <T> FromResources for T where T: Default {
fn from_resources(_resources: &Resources) -> Self {
Self::default()
}
}
}
pub use resource_query::*;
pub use resources::*;
}
mod schedule {
mod parallel_executor {
use super::Schedule;
use crate::{resource::Resources,
system::{ArchetypeAccess, System, ThreadLocalExecution,
TypeAccess}};
use crossbeam_channel::{Receiver, Sender};
use fixedbitset::FixedBitSet;
use bevy_hecs::{ArchetypesGeneration, World};
use rayon::ScopeFifo;
use std::{ops::Range, sync::{Arc, Mutex}};
/// Executes each schedule stage in parallel by analyzing system dependencies.
/// System execution order is undefined except under the following conditions:
/// * systems in earlier stages run before systems in later stages
/// * in a given stage, systems that mutate archetype X cannot run before systems registered before them that read/write archetype X
/// * in a given stage, systems the read archetype X cannot run before systems registered before them that write archetype X
/// * in a given stage, systems that mutate resource Y cannot run before systems registered before them that read/write resource Y
/// * in a given stage, systems the read resource Y cannot run before systems registered before them that write resource Y
pub struct ParallelExecutor {
stages: Vec<ExecutorStage>,
last_schedule_generation: usize,
clear_trackers: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for ParallelExecutor {
fn fmt(&self, f: &mut ::core::fmt::Formatter)
-> ::core::fmt::Result {
match *self {
ParallelExecutor {
stages: ref __self_0_0,
last_schedule_generation: ref __self_0_1,
clear_trackers: ref __self_0_2 } => {
let mut debug_trait_builder =
f.debug_struct("ParallelExecutor");
let _ =
debug_trait_builder.field("stages",
&&(*__self_0_0));
let _ =
debug_trait_builder.field("last_schedule_generation",
&&(*__self_0_1));
let _ =
debug_trait_builder.field("clear_trackers",
&&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
impl Default for ParallelExecutor {
fn default() -> Self {
Self{stages: Default::default(),
last_schedule_generation: usize::MAX,
clear_trackers: true,}
}
}
impl ParallelExecutor {
pub fn without_tracker_clears() -> Self {
Self{clear_trackers: false, ..Default::default()}
}
pub fn run(&mut self, schedule: &mut Schedule, world: &mut World,
resources: &mut Resources) {
let schedule_generation = schedule.generation();
let schedule_changed =
schedule.generation() != self.last_schedule_generation;
if schedule_changed {
self.stages.clear();
self.stages.resize_with(schedule.stage_order.len(),
|| ExecutorStage::default());
}
for (stage_name, executor_stage) in
schedule.stage_order.iter().zip(self.stages.iter_mut()) {
if let Some(stage_systems) =
schedule.stages.get_mut(stage_name) {
executor_stage.run(world, resources, stage_systems,
schedule_changed);
}
}
if self.clear_trackers { world.clear_trackers(); }
self.last_schedule_generation = schedule_generation;
}
}
pub struct ExecutorStage {
/// each system's set of dependencies
system_dependencies: Vec<FixedBitSet>,
/// each system's dependents (the systems that can't run until this system has run)
system_dependents: Vec<Vec<usize>>,
/// stores the indices of thread local systems in this stage, which are used during stage.prepare()
thread_local_system_indices: Vec<usize>,
next_thread_local_index: usize,
/// the currently finished systems
finished_systems: FixedBitSet,
running_systems: FixedBitSet,
sender: Sender<usize>,
receiver: Receiver<usize>,
last_archetypes_generation: ArchetypesGeneration,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for ExecutorStage {
fn fmt(&self, f: &mut ::core::fmt::Formatter)
-> ::core::fmt::Result {
match *self {
ExecutorStage {
system_dependencies: ref __self_0_0,
system_dependents: ref __self_0_1,
thread_local_system_indices: ref __self_0_2,
next_thread_local_index: ref __self_0_3,
finished_systems: ref __self_0_4,
running_systems: ref __self_0_5,
sender: ref __self_0_6,
receiver: ref __self_0_7,
last_archetypes_generation: ref __self_0_8 } => {
let mut debug_trait_builder =
f.debug_struct("ExecutorStage");
let _ =
debug_trait_builder.field("system_dependencies",
&&(*__self_0_0));
let _ =
debug_trait_builder.field("system_dependents",
&&(*__self_0_1));
let _ =
debug_trait_builder.field("thread_local_system_indices",
&&(*__self_0_2));
let _ =
debug_trait_builder.field("next_thread_local_index",
&&(*__self_0_3));
let _ =
debug_trait_builder.field("finished_systems",
&&(*__self_0_4));
let _ =
debug_trait_builder.field("running_systems",
&&(*__self_0_5));
let _ =
debug_trait_builder.field("sender",
&&(*__self_0_6));
let _ =
debug_trait_builder.field("receiver",
&&(*__self_0_7));
let _ =
debug_trait_builder.field("last_archetypes_generation",
&&(*__self_0_8));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for ExecutorStage {
#[inline]
fn clone(&self) -> ExecutorStage {
match *self {
ExecutorStage {
system_dependencies: ref __self_0_0,
system_dependents: ref __self_0_1,
thread_local_system_indices: ref __self_0_2,
next_thread_local_index: ref __self_0_3,
finished_systems: ref __self_0_4,
running_systems: ref __self_0_5,
sender: ref __self_0_6,
receiver: ref __self_0_7,
last_archetypes_generation: ref __self_0_8 } =>
ExecutorStage{system_dependencies:
::core::clone::Clone::clone(&(*__self_0_0)),
system_dependents:
::core::clone::Clone::clone(&(*__self_0_1)),
thread_local_system_indices:
::core::clone::Clone::clone(&(*__self_0_2)),
next_thread_local_index:
::core::clone::Clone::clone(&(*__self_0_3)),
finished_systems:
::core::clone::Clone::clone(&(*__self_0_4)),
running_systems:
::core::clone::Clone::clone(&(*__self_0_5)),
sender:
::core::clone::Clone::clone(&(*__self_0_6)),
receiver:
::core::clone::Clone::clone(&(*__self_0_7)),
last_archetypes_generation:
::core::clone::Clone::clone(&(*__self_0_8)),},
}
}
}
impl Default for ExecutorStage {
fn default() -> Self {
let (sender, receiver) = crossbeam_channel::unbounded();
Self{system_dependents: Default::default(),
system_dependencies: Default::default(),
thread_local_system_indices: Default::default(),
next_thread_local_index: 0,
finished_systems: Default::default(),
running_systems: Default::default(),
sender,
receiver,
last_archetypes_generation:
ArchetypesGeneration(u64::MAX),}
}
}
enum RunReadyResult { Ok, ThreadLocalReady(usize), }
enum RunReadyType { Range(Range<usize>), Dependents(usize), }
impl ExecutorStage {
pub fn prepare_to_next_thread_local(&mut self, world: &World,
systems:
&[Arc<Mutex<Box<dyn System>>>],
schedule_changed: bool) {
let (prepare_system_start_index, last_thread_local_index) =
if self.next_thread_local_index == 0 {
(0, None)
} else {
(self.thread_local_system_indices[self.next_thread_local_index
- 1] + 1,
Some(self.thread_local_system_indices[self.next_thread_local_index
- 1]))
};
let prepare_system_index_range =
if let Some(index) =
self.thread_local_system_indices.get(self.next_thread_local_index)
{
prepare_system_start_index..(*index + 1)
} else { prepare_system_start_index..systems.len() };
let archetypes_generation_changed =
self.last_archetypes_generation !=
world.archetypes_generation();
if schedule_changed || archetypes_generation_changed {
for system_index in prepare_system_index_range.clone() {
let mut system =
systems[system_index].lock().unwrap();
system.update_archetype_access(world);
}
let mut current_archetype_access =
ArchetypeAccess::default();
let mut current_resource_access = TypeAccess::default();
for system_index in prepare_system_index_range.clone() {
let system = systems[system_index].lock().unwrap();
let archetype_access = system.archetype_access();
match system.thread_local_execution() {
ThreadLocalExecution::NextFlush => {
let resource_access =
system.resource_access();
if current_archetype_access.is_compatible(archetype_access)
== false ||
current_resource_access.is_compatible(resource_access)
== false {
for earlier_system_index in
prepare_system_index_range.start..system_index
{
let earlier_system =
systems[earlier_system_index].lock().unwrap();
if true {
{
match (&earlier_system.thread_local_execution(),
&ThreadLocalExecution::NextFlush)
{
(left_val, right_val) => {
if !(*left_val ==
*right_val) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["assertion failed: `(left == right)`\n left: `",
"`,\n right: `",
"`"],
&match (&&*left_val,
&&*right_val)
{
(arg0,
arg1)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Debug::fmt),
::core::fmt::ArgumentV1::new(arg1,
::core::fmt::Debug::fmt)],
}))
}
}
}
}
};
};
if earlier_system.archetype_access().is_compatible(archetype_access)
== false ||
earlier_system.resource_access().is_compatible(resource_access)
== false {
self.system_dependents[earlier_system_index].push(system_index);
self.system_dependencies[system_index].insert(earlier_system_index);
}
}
}
current_archetype_access.union(archetype_access);
current_resource_access.union(resource_access);
if let Some(last_thread_local_index) =
last_thread_local_index {
self.system_dependents[last_thread_local_index].push(system_index);
self.system_dependencies[system_index].insert(last_thread_local_index);
}
}
ThreadLocalExecution::Immediate => {
for earlier_system_index in
prepare_system_index_range.start..system_index
{
self.system_dependents[earlier_system_index].push(system_index);
self.system_dependencies[system_index].insert(earlier_system_index);
}
}
}
}
}
self.next_thread_local_index += 1;
}
fn run_ready_systems<'run>(&mut self,
systems:
&[Arc<Mutex<Box<dyn System>>>],
run_ready_type: RunReadyType,
scope: &ScopeFifo<'run>,
world: &'run World,
resources: &'run Resources)
-> RunReadyResult {
let mut all;
let mut dependents;
let system_index_iter: &mut dyn Iterator<Item = usize> =
match run_ready_type {
RunReadyType::Range(range) => {
all = range;
&mut all
}
RunReadyType::Dependents(system_index) => {
dependents =
self.system_dependents[system_index].iter().cloned();
&mut dependents
}
};
let mut systems_currently_running = false;
for system_index in system_index_iter {
if self.running_systems.contains(system_index) {
continue ;
}
if self.system_dependencies[system_index].is_subset(&self.finished_systems)
{
let system = systems[system_index].clone();
{
let system = system.lock().unwrap();
if let ThreadLocalExecution::Immediate =
system.thread_local_execution() {
if systems_currently_running {
continue ;
} else {
return RunReadyResult::ThreadLocalReady(system_index);
}
}
}
let sender = self.sender.clone();
self.running_systems.insert(system_index);
scope.spawn_fifo(move |_|
{
let mut system =
system.lock().unwrap();
system.run(world, resources);
sender.send(system_index).unwrap();
});
systems_currently_running = true;
}
}
RunReadyResult::Ok
}
pub fn run(&mut self, world: &mut World,
resources: &mut Resources,
systems: &[Arc<Mutex<Box<dyn System>>>],
schedule_changed: bool) {
if schedule_changed {
self.system_dependencies.clear();
self.system_dependencies.resize_with(systems.len(),
||
FixedBitSet::with_capacity(systems.len()));
self.thread_local_system_indices = Vec::new();
self.system_dependents.clear();
self.system_dependents.resize(systems.len(), Vec::new());
self.finished_systems.grow(systems.len());
self.running_systems.grow(systems.len());
for (system_index, system) in systems.iter().enumerate() {
let system = system.lock().unwrap();
if system.thread_local_execution() ==
ThreadLocalExecution::Immediate {
self.thread_local_system_indices.push(system_index);
}
}
}
self.next_thread_local_index = 0;
self.prepare_to_next_thread_local(world, systems,
schedule_changed);
self.finished_systems.clear();
self.running_systems.clear();
let mut run_ready_result = RunReadyResult::Ok;
let run_ready_system_index_range =
if let Some(index) =
self.thread_local_system_indices.get(0) {
0..(*index + 1)
} else { 0..systems.len() };
rayon::scope_fifo(|scope|
{
run_ready_result =
self.run_ready_systems(systems,
RunReadyType::Range(run_ready_system_index_range),
scope,
world,
resources);
});
loop {
if self.finished_systems.count_ones(..) == systems.len() {
break ;
}
if let RunReadyResult::ThreadLocalReady(thread_local_index)
= run_ready_result {
let mut system =
systems[thread_local_index].lock().unwrap();
self.running_systems.insert(thread_local_index);
system.run(world, resources);
system.run_thread_local(world, resources);
self.finished_systems.insert(thread_local_index);
self.sender.send(thread_local_index).unwrap();
self.prepare_to_next_thread_local(world, systems,
schedule_changed);
run_ready_result = RunReadyResult::Ok;
} else {
rayon::scope_fifo(|scope|
{
loop {
if self.finished_systems.count_ones(..)
== systems.len()
{
break ;
}
let finished_system =
self.receiver.recv().unwrap();
self.finished_systems.insert(finished_system);
run_ready_result =
self.run_ready_systems(systems,
RunReadyType::Dependents(finished_system),
scope,
world,
resources);
if let RunReadyResult::ThreadLocalReady(_)
=
run_ready_result
{
break ;
}
}
});
}
}
for system in systems.iter() {
let mut system = system.lock().unwrap();
match system.thread_local_execution() {
ThreadLocalExecution::NextFlush =>
system.run_thread_local(world, resources),
ThreadLocalExecution::Immediate => { }
}
}
self.last_archetypes_generation =
world.archetypes_generation();
}
}
}
mod schedule {
use crate::{resource::Resources,
system::{System, SystemId, ThreadLocalExecution}};
use bevy_hecs::World;
use std::{borrow::Cow, collections::{HashMap, HashSet},
sync::{Arc, Mutex}};
/// An ordered collection of stages, which each contain an ordered list of [System]s.
/// Schedules are essentially the "execution plan" for an App's systems.
/// They are run on a given [World] and [Resources] reference.
pub struct Schedule {
pub(crate) stages: HashMap<Cow<'static, str>,
Vec<Arc<Mutex<Box<dyn System>>>>>,
pub(crate) stage_order: Vec<Cow<'static, str>>,
pub(crate) system_ids: HashSet<SystemId>,
generation: usize,
last_initialize_generation: usize,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for Schedule {
#[inline]
fn default() -> Schedule {
Schedule{stages: ::core::default::Default::default(),
stage_order: ::core::default::Default::default(),
system_ids: ::core::default::Default::default(),
generation: ::core::default::Default::default(),
last_initialize_generation:
::core::default::Default::default(),}
}
}
impl Schedule {
pub fn add_stage(&mut self, stage: impl Into<Cow<'static, str>>) {
let stage: Cow<str> = stage.into();
if let Some(_) = self.stages.get(&stage) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Stage already exists: "],
&match (&stage,)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
};
} else {
self.stages.insert(stage.clone(), Vec::new());
self.stage_order.push(stage);
}
}
pub fn add_stage_after(&mut self,
target: impl Into<Cow<'static, str>>,
stage: impl Into<Cow<'static, str>>) {
let target: Cow<str> = target.into();
let stage: Cow<str> = stage.into();
if let Some(_) = self.stages.get(&stage) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Stage already exists: "],
&match (&stage,)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
};
}
let target_index =
self.stage_order.iter().enumerate().find(|(_i, stage)|
**stage ==
target).map(|(i,
_)|
i).unwrap_or_else(||
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Target stage does not exist: "],
&match (&target,)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
});
self.stages.insert(stage.clone(), Vec::new());
self.stage_order.insert(target_index + 1, stage);
}
pub fn add_stage_before(&mut self,
target: impl Into<Cow<'static, str>>,
stage: impl Into<Cow<'static, str>>) {
let target: Cow<str> = target.into();
let stage: Cow<str> = stage.into();
if let Some(_) = self.stages.get(&stage) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Stage already exists: "],
&match (&stage,)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
};
}
let target_index =
self.stage_order.iter().enumerate().find(|(_i, stage)|
**stage ==
target).map(|(i,
_)|
i).unwrap_or_else(||
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Target stage does not exist: "],
&match (&target,)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
});
self.stages.insert(stage.clone(), Vec::new());
self.stage_order.insert(target_index, stage);
}
pub fn add_system_to_stage(&mut self,
stage_name:
impl Into<Cow<'static, str>>,
system: Box<dyn System>) -> &mut Self {
let stage_name = stage_name.into();
let systems =
self.stages.get_mut(&stage_name).unwrap_or_else(||
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Stage does not exist: "],
&match (&stage_name,)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
});
if self.system_ids.contains(&system.id()) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["System with id ",
" (",
") already exists"],
&match (&system.id(),
&system.name())
{
(arg0,
arg1)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Debug::fmt),
::core::fmt::ArgumentV1::new(arg1,
::core::fmt::Display::fmt)],
}))
};
}
self.system_ids.insert(system.id());
systems.push(Arc::new(Mutex::new(system)));
self.generation += 1;
self
}
pub fn add_system_to_stage_front(&mut self,
stage_name:
impl Into<Cow<'static, str>>,
system: Box<dyn System>)
-> &mut Self {
let stage_name = stage_name.into();
let systems =
self.stages.get_mut(&stage_name).unwrap_or_else(||
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["Stage does not exist: "],
&match (&stage_name,)
{
(arg0,)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Display::fmt)],
}))
});
if self.system_ids.contains(&system.id()) {
{
::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["System with id ",
" (",
") already exists"],
&match (&system.id(),
&system.name())
{
(arg0,
arg1)
=>
[::core::fmt::ArgumentV1::new(arg0,
::core::fmt::Debug::fmt),
::core::fmt::ArgumentV1::new(arg1,
::core::fmt::Display::fmt)],
}))
};
}
self.system_ids.insert(system.id());
systems.insert(0, Arc::new(Mutex::new(system)));
self.generation += 1;
self
}
pub fn run(&mut self, world: &mut World,
resources: &mut Resources) {
for stage_name in self.stage_order.iter() {
if let Some(stage_systems) =
self.stages.get_mut(stage_name) {
for system in stage_systems.iter_mut() {
let mut system = system.lock().unwrap();
system.update_archetype_access(world);
match system.thread_local_execution() {
ThreadLocalExecution::NextFlush =>
system.run(world, resources),
ThreadLocalExecution::Immediate => {
system.run(world, resources);
system.run_thread_local(world, resources);
}
}
}
for system in stage_systems.iter_mut() {
let mut system = system.lock().unwrap();
match system.thread_local_execution() {
ThreadLocalExecution::NextFlush => {
system.run_thread_local(world, resources)
}
ThreadLocalExecution::Immediate => { }
}
}
}
}
world.clear_trackers();
}
pub fn initialize(&mut self, resources: &mut Resources) {
if self.last_initialize_generation == self.generation {
return;
}
for stage in self.stages.values_mut() {
for system in stage.iter_mut() {
let mut system = system.lock().unwrap();
system.initialize(resources);
}
}
self.last_initialize_generation = self.generation;
}
pub fn generation(&self) -> usize { self.generation }
}
}
pub use parallel_executor::*;
pub use schedule::*;
}
mod system {
mod commands {
use super::SystemId;
use crate::resource::{Resource, Resources};
use bevy_hecs::{Bundle, Component, DynamicBundle, Entity, World};
use std::sync::{Arc, Mutex};
/// A queued command to mutate the current [World] or [Resources]
pub enum Command {
WriteWorld(Box<dyn WorldWriter>),
WriteResources(Box<dyn ResourcesWriter>),
}
/// A [World] mutation
pub trait WorldWriter: Send + Sync {
fn write(self: Box<Self>, world: &mut World);
}
pub(crate) struct Spawn<T> where T: DynamicBundle + Send + Sync +
'static {
components: T,
}
impl <T> WorldWriter for Spawn<T> where T: DynamicBundle + Send +
Sync + 'static {
fn write(self: Box<Self>, world: &mut World) {
world.spawn(self.components);
}
}
pub(crate) struct SpawnAsEntity<T> where T: DynamicBundle + Send +
Sync + 'static {
entity: Entity,
components: T,
}
impl <T> WorldWriter for SpawnAsEntity<T> where T: DynamicBundle +
Send + Sync + 'static {
fn write(self: Box<Self>, world: &mut World) {
world.spawn_as_entity(self.entity, self.components);
}
}
pub(crate) struct SpawnBatch<I> where I: IntoIterator,
I::Item: Bundle {
components_iter: I,
}
impl <I> WorldWriter for SpawnBatch<I> where I: IntoIterator + Send +
Sync, I::Item: Bundle {
fn write(self: Box<Self>, world: &mut World) {
world.spawn_batch(self.components_iter);
}
}
pub(crate) struct Despawn {
entity: Entity,
}
impl WorldWriter for Despawn {
fn write(self: Box<Self>, world: &mut World) {
world.despawn(self.entity).unwrap();
}
}
pub struct Insert<T> where T: DynamicBundle + Send + Sync + 'static {
entity: Entity,
components: T,
}
impl <T> WorldWriter for Insert<T> where T: DynamicBundle + Send +
Sync + 'static {
fn write(self: Box<Self>, world: &mut World) {
world.insert(self.entity, self.components).unwrap();
}
}
pub(crate) struct InsertOne<T> where T: Component {
entity: Entity,
component: T,
}
impl <T> WorldWriter for InsertOne<T> where T: Component {
fn write(self: Box<Self>, world: &mut World) {
world.insert(self.entity, (self.component,)).unwrap();
}
}
pub trait ResourcesWriter: Send + Sync {
fn write(self: Box<Self>, resources: &mut Resources);
}
pub struct InsertResource<T: Resource> {
resource: T,
}
impl <T: Resource> ResourcesWriter for InsertResource<T> {
fn write(self: Box<Self>, resources: &mut Resources) {
resources.insert(self.resource);
}
}
pub(crate) struct InsertLocalResource<T: Resource> {
resource: T,
system_id: SystemId,
}
impl <T: Resource> ResourcesWriter for InsertLocalResource<T> {
fn write(self: Box<Self>, resources: &mut Resources) {
resources.insert_local(self.system_id, self.resource);
}
}
pub struct CommandsInternal {
pub commands: Vec<Command>,
pub current_entity: Option<Entity>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for CommandsInternal {
#[inline]
fn default() -> CommandsInternal {
CommandsInternal{commands:
::core::default::Default::default(),
current_entity:
::core::default::Default::default(),}
}
}
impl CommandsInternal {
pub fn spawn(&mut self,
components:
impl DynamicBundle + Send + Sync + 'static)
-> &mut Self {
self.spawn_as_entity(Entity::new(), components)
}
pub fn spawn_as_entity(&mut self, entity: Entity,
components:
impl DynamicBundle + Send + Sync +
'static) -> &mut Self {
self.current_entity = Some(entity);
self.commands.push(Command::WriteWorld(Box::new(SpawnAsEntity{entity,
components,})));
self
}
pub fn with_bundle(&mut self,
components:
impl DynamicBundle + Send + Sync + 'static)
-> &mut Self {
let current_entity =
self.current_entity.expect("Cannot add components because the 'current entity' is not set. You should spawn an entity first.");
self.commands.push(Command::WriteWorld(Box::new(Insert{entity:
current_entity,
components,})));
self
}
pub fn with(&mut self, component: impl Component) -> &mut Self {
let current_entity =
self.current_entity.expect("Cannot add component because the 'current entity' is not set. You should spawn an entity first.");
self.commands.push(Command::WriteWorld(Box::new(InsertOne{entity:
current_entity,
component,})));
self
}
pub fn write_world<W: WorldWriter +
'static>(&mut self, world_writer: W)
-> &mut Self {
self.commands.push(Command::WriteWorld(Box::new(world_writer)));
self
}
pub fn write_resources<W: ResourcesWriter +
'static>(&mut self, resources_writer: W)
-> &mut Self {
self.commands.push(Command::WriteResources(Box::new(resources_writer)));
self
}
}
/// A queue of [Command]s to run on the current [World] and [Resources]
pub struct Commands {
pub commands: Arc<Mutex<CommandsInternal>>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for Commands {
#[inline]
fn default() -> Commands {
Commands{commands: ::core::default::Default::default(),}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Commands {
#[inline]
fn clone(&self) -> Commands {
match *self {
Commands { commands: ref __self_0_0 } =>
Commands{commands:
::core::clone::Clone::clone(&(*__self_0_0)),},
}
}
}
impl Commands {
pub fn spawn(&mut self,
components:
impl DynamicBundle + Send + Sync + 'static)
-> &mut Self {
self.spawn_as_entity(Entity::new(), components)
}
pub fn spawn_as_entity(&mut self, entity: Entity,
components:
impl DynamicBundle + Send + Sync +
'static) -> &mut Self {
{
let mut commands = self.commands.lock().unwrap();
commands.spawn_as_entity(entity, components);
}
self
}
pub fn spawn_batch<I>(&mut self, components_iter: I) -> &mut Self
where I: IntoIterator + Send + Sync + 'static, I::Item: Bundle {
self.write_world(SpawnBatch{components_iter,})
}
/// Despawns only the specified entity, ignoring any other consideration.
pub fn despawn(&mut self, entity: Entity) -> &mut Self {
self.write_world(Despawn{entity,})
}
pub fn with(&mut self, component: impl Component) -> &mut Self {
{
let mut commands = self.commands.lock().unwrap();
commands.with(component);
}
self
}
pub fn with_bundle(&mut self,
components:
impl DynamicBundle + Send + Sync + 'static)
-> &mut Self {
{
let mut commands = self.commands.lock().unwrap();
commands.with_bundle(components);
}
self
}
pub fn insert(&mut self, entity: Entity,
components:
impl DynamicBundle + Send + Sync + 'static)
-> &mut Self {
self.write_world(Insert{entity, components,})
}
pub fn insert_one(&mut self, entity: Entity,
component: impl Component) -> &mut Self {
self.write_world(InsertOne{entity, component,})
}
pub fn insert_resource<T: Resource>(&mut self, resource: T)
-> &mut Self {
self.write_resources(InsertResource{resource,})
}
pub fn insert_local_resource<T: Resource>(&mut self,
system_id: SystemId,
resource: T)
-> &mut Self {
self.write_resources(InsertLocalResource{system_id,
resource,})
}
pub fn write_world<W: WorldWriter +
'static>(&mut self, world_writer: W)
-> &mut Self {
self.commands.lock().unwrap().write_world(world_writer);
self
}
pub fn write_resources<W: ResourcesWriter +
'static>(&mut self, resources_writer: W)
-> &mut Self {
self.commands.lock().unwrap().write_resources(resources_writer);
self
}
pub fn apply(&self, world: &mut World,
resources: &mut Resources) {
let mut commands = self.commands.lock().unwrap();
for command in commands.commands.drain(..) {
match command {
Command::WriteWorld(writer) => {
writer.write(world);
}
Command::WriteResources(writer) =>
writer.write(resources),
}
}
}
pub fn current_entity(&self) -> Option<Entity> {
let commands = self.commands.lock().unwrap();
commands.current_entity
}
pub fn for_current_entity(&mut self, mut f: impl FnMut(Entity))
-> &mut Self {
{
let commands = self.commands.lock().unwrap();
let current_entity =
commands.current_entity.expect("The 'current entity' is not set. You should spawn an entity first.");
f(current_entity);
}
self
}
}
}
mod into_system {
pub use super::Query;
use super::TypeAccess;
use crate::{resource::{FetchResource, ResourceQuery, Resources,
UnsafeClone},
system::{ArchetypeAccess, Commands, System, SystemId,
ThreadLocalExecution}};
use bevy_hecs::{Fetch, Query as HecsQuery, World};
use std::borrow::Cow;
pub(crate) struct SystemFn<State, F, ThreadLocalF, Init,
SetArchetypeAccess> where
F: FnMut(&World, &Resources, &ArchetypeAccess,
&mut State) + Send + Sync,
ThreadLocalF: FnMut(&mut World, &mut Resources,
&mut State) + Send + Sync,
Init: FnMut(&mut Resources) + Send + Sync,
SetArchetypeAccess: FnMut(&World,
&mut ArchetypeAccess,
&mut State) + Send + Sync,
State: Send + Sync {
pub state: State,
pub func: F,
pub thread_local_func: ThreadLocalF,
pub init_func: Init,
pub thread_local_execution: ThreadLocalExecution,
pub resource_access: TypeAccess,
pub name: Cow<'static, str>,
pub id: SystemId,
pub archetype_access: ArchetypeAccess,
pub set_archetype_access: SetArchetypeAccess,
}
impl <State, F, ThreadLocalF, Init, SetArchetypeAccess> System for
SystemFn<State, F, ThreadLocalF, Init, SetArchetypeAccess> where
F: FnMut(&World, &Resources, &ArchetypeAccess, &mut State) + Send +
Sync, ThreadLocalF: FnMut(&mut World, &mut Resources, &mut State) +
Send + Sync, Init: FnMut(&mut Resources) + Send + Sync,
SetArchetypeAccess: FnMut(&World, &mut ArchetypeAccess, &mut State) +
Send + Sync, State: Send + Sync {
fn name(&self) -> Cow<'static, str> { self.name.clone() }
fn update_archetype_access(&mut self, world: &World) {
(self.set_archetype_access)(world, &mut self.archetype_access,
&mut self.state);
}
fn archetype_access(&self) -> &ArchetypeAccess {
&self.archetype_access
}
fn resource_access(&self) -> &TypeAccess { &self.resource_access }
fn thread_local_execution(&self) -> ThreadLocalExecution {
self.thread_local_execution
}
#[inline]
fn run(&mut self, world: &World, resources: &Resources) {
(self.func)(world, resources, &self.archetype_access,
&mut self.state);
}
fn run_thread_local(&mut self, world: &mut World,
resources: &mut Resources) {
(self.thread_local_func)(world, resources, &mut self.state);
}
fn initialize(&mut self, resources: &mut Resources) {
(self.init_func)(resources);
}
fn id(&self) -> SystemId { self.id }
}
/// Converts `Self` into a For-Each system
pub trait IntoForEachSystem<CommandBuffer, R, C> {
fn system(self)
-> Box<dyn System>;
}
macro_rules! impl_into_foreach_system {
(($ ($ commands : ident) *), ($ ($ resource : ident), *),
($ ($ component : ident), *)) =>
{
impl < Func, $ ($ resource,) * $ ($ component,) * >
IntoForEachSystem < ($ ($ commands,) *), ($ ($ resource,) *),
($ ($ component,) *) > for Func where Func :
FnMut($ ($ commands,) * $ ($ resource,) * $ ($ component,) *)
+
FnMut($ ($ commands,) * $
(<< $ resource as ResourceQuery > :: Fetch as
FetchResource > :: Item,) * $
(<< $ component as HecsQuery > :: Fetch as Fetch > ::
Item,) *) + Send + Sync + 'static, $
($ component : HecsQuery,) * $ ($ resource : ResourceQuery,) *
{
# [allow(non_snake_case)] # [allow(unused_variables)] #
[allow(unused_unsafe)] fn system(mut self) -> Box < dyn
System >
{
let id = SystemId :: new() ; Box ::
new(SystemFn
{
state : Commands :: default(),
thread_local_execution : ThreadLocalExecution
:: NextFlush, name : core :: any :: type_name
:: < Self > () . into(), id, func : move |
world, resources, _archetype_access, state |
{
<< ($ ($ resource,) *) as ResourceQuery >
:: Fetch as FetchResource > ::
borrow(& resources) ;
{
let($ ($ resource,) *) = resources .
query_system :: < ($ ($ resource,) *)
> (id) ; for($ ($ component,) *) in
world . query :: <
($ ($ component,) *) > () . iter()
{
fn_call !
(self, ($ ($ commands, state) *),
($ ($ resource), *),
($ ($ component), *))
}
} << ($ ($ resource,) *) as ResourceQuery
> :: Fetch as FetchResource > ::
release(& resources) ;
}, thread_local_func : move | world,
resources, state |
{ state . apply(world, resources) ; },
init_func : move | resources |
{
< ($ ($ resource,) *) > ::
initialize(resources, Some(id)) ;
}, resource_access : << ($ ($ resource,) *) as
ResourceQuery > :: Fetch as FetchResource > ::
access(), archetype_access : ArchetypeAccess
:: default(), set_archetype_access : | world,
archetype_access, _state |
{
archetype_access . clear() ;
archetype_access . set_access_for_query ::
< ($ ($ component,) *) > (world) ;
},
})
}
}
} ;
}
struct QuerySystemState {
archetype_accesses: Vec<ArchetypeAccess>,
commands: Commands,
}
/// Converts `Self` into a Query System
pub trait IntoQuerySystem<Commands, R, Q> {
fn system(self)
-> Box<dyn System>;
}
macro_rules! impl_into_query_system {
(($ ($ commands : ident) *), ($ ($ resource : ident), *),
($ ($ query : ident), *)) =>
{
impl < Func, $ ($ resource,) * $ ($ query,) * >
IntoQuerySystem < ($ ($ commands,) *), ($ ($ resource,) *),
($ ($ query,) *) > for Func where Func :
FnMut($ ($ commands,) * $ ($ resource,) * $
(Query < $ query >,) *) +
FnMut($ ($ commands,) * $
(<< $ resource as ResourceQuery > :: Fetch as
FetchResource > :: Item,) * $ (Query < $ query >,) *) +
Send + Sync + 'static, $ ($ query : HecsQuery,) * $
($ resource : ResourceQuery,) *
{
# [allow(non_snake_case)] # [allow(unused_variables)] #
[allow(unused_unsafe)] # [allow(unused_assignments)] #
[allow(unused_mut)] fn system(mut self) -> Box < dyn
System >
{
let id = SystemId :: new() ; $
(let $ query = ArchetypeAccess :: default() ;) * Box
::
new(SystemFn
{
state : QuerySystemState
{
archetype_accesses : vec !
[$ ($ query,) *], commands : Commands ::
default(),
}, thread_local_execution :
ThreadLocalExecution :: NextFlush, id, name :
core :: any :: type_name :: < Self > () .
into(), func : move | world, resources,
archetype_access, state |
{
<< ($ ($ resource,) *) as ResourceQuery >
:: Fetch as FetchResource > ::
borrow(& resources) ;
{
let($ ($ resource,) *) = resources .
query_system :: < ($ ($ resource,) *)
> (id) ; let mut i = 0 ; $
(let $ query = Query :: < $ query > ::
new(world, & state .
archetype_accesses [i]) ; i += 1
;) * let commands = & state .
commands ; fn_call !
(self, ($ ($ commands, commands) *),
($ ($ resource), *),
($ ($ query), *))
} << ($ ($ resource,) *) as ResourceQuery
> :: Fetch as FetchResource > ::
release(& resources) ;
}, thread_local_func : move | world,
resources, state |
{
state . commands . apply(world, resources)
;
}, init_func : move | resources |
{
< ($ ($ resource,) *) > ::
initialize(resources, Some(id)) ;
}, resource_access : << ($ ($ resource,) *) as
ResourceQuery > :: Fetch as FetchResource > ::
access(), archetype_access : ArchetypeAccess
:: default(), set_archetype_access : | world,
archetype_access, state |
{
archetype_access . clear() ; let mut i = 0
; let mut access : & mut ArchetypeAccess ;
$
(access = & mut state . archetype_accesses
[i] ; access . clear() ; access .
set_access_for_query :: < $ query >
(world) ; archetype_access .
union(access) ; i += 1 ;) *
},
})
}
}
} ;
}
macro_rules! fn_call {
($ self : ident,
($ ($ commands : ident, $ commands_var : ident) *),
($ ($ resource : ident), *), ($ ($ a : ident), *)) =>
{
unsafe
{
$
self($ ($ commands_var . clone(),) * $
($ resource . unsafe_clone(),) * $ ($ a,) *)
}
} ;
($ self : ident, (), ($ ($ resource : ident), *),
($ ($ a : ident), *)) =>
{
unsafe
{ $ self($ ($ resource . unsafe_clone(),) * $ ($ a,) *) }
} ;
}
macro_rules! impl_into_query_systems {
(($ ($ resource : ident,) *), ($ ($ query : ident), *)) =>
{
# [rustfmt :: skip] impl_into_query_system !
((), ($ ($ resource), *), ($ ($ query), *)) ; #
[rustfmt :: skip] impl_into_query_system !
((Commands), ($ ($ resource), *), ($ ($ query), *)) ;
}
}
macro_rules! impl_into_foreach_systems {
(($ ($ resource : ident,) *), ($ ($ component : ident), *)) =>
{
# [rustfmt :: skip] impl_into_foreach_system !
((), ($ ($ resource), *), ($ ($ component), *)) ; #
[rustfmt :: skip] impl_into_foreach_system !
((Commands), ($ ($ resource), *), ($ ($ component), *)) ;
}
}
macro_rules! impl_into_systems {
($ ($ resource : ident), *) =>
{
# [rustfmt :: skip] impl_into_foreach_systems !
(($ ($ resource,) *), (A)) ; # [rustfmt :: skip]
impl_into_foreach_systems ! (($ ($ resource,) *), (A, B)) ; #
[rustfmt :: skip] impl_into_foreach_systems !
(($ ($ resource,) *), (A, B, C)) ; # [rustfmt :: skip]
impl_into_foreach_systems !
(($ ($ resource,) *), (A, B, C, D)) ; # [rustfmt :: skip]
impl_into_foreach_systems !
(($ ($ resource,) *), (A, B, C, D, E)) ; # [rustfmt :: skip]
impl_into_foreach_systems !
(($ ($ resource,) *), (A, B, C, D, E, F)) ; #
[rustfmt :: skip] impl_into_foreach_systems !
(($ ($ resource,) *), (A, B, C, D, E, F, G)) ; #
[rustfmt :: skip] impl_into_foreach_systems !
(($ ($ resource,) *), (A, B, C, D, E, F, G, H)) ; #
[rustfmt :: skip] impl_into_query_systems !
(($ ($ resource,) *), ()) ; # [rustfmt :: skip]
impl_into_query_systems ! (($ ($ resource,) *), (A)) ; #
[rustfmt :: skip] impl_into_query_systems !
(($ ($ resource,) *), (A, B)) ; # [rustfmt :: skip]
impl_into_query_systems ! (($ ($ resource,) *), (A, B, C)) ; #
[rustfmt :: skip] impl_into_query_systems !
(($ ($ resource,) *), (A, B, C, D)) ; # [rustfmt :: skip]
impl_into_query_systems !
(($ ($ resource,) *), (A, B, C, D, E)) ; # [rustfmt :: skip]
impl_into_query_systems !
(($ ($ resource,) *), (A, B, C, D, E, F)) ;
} ;
}
impl <Func, A> IntoForEachSystem<(), (), (A,)> for Func where
Func: FnMut(A) + FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item) +
Send + Sync + 'static, A: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe { self(A) }
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, A> IntoForEachSystem<(Commands,), (), (A,)> for Func where
Func: FnMut(Commands, A) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item) + Send +
Sync + 'static, A: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(state.clone(),
A)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, A, B> IntoForEachSystem<(), (), (A, B)> for Func where
Func: FnMut(A, B) +
FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe { self(A, B) }
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, A, B> IntoForEachSystem<(Commands,), (), (A, B)> for Func
where Func: FnMut(Commands, A, B) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(state.clone(),
A, B)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, A, B, C> IntoForEachSystem<(), (), (A, B, C)> for Func
where Func: FnMut(A, B, C) +
FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe { self(A, B, C) }
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, A, B, C> IntoForEachSystem<(Commands,), (), (A, B, C)> for
Func where Func: FnMut(Commands, A, B, C) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(state.clone(),
A, B, C)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, A, B, C, D> IntoForEachSystem<(), (), (A, B, C, D)> for
Func where Func: FnMut(A, B, C, D) +
FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(A, B, C, D)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, A, B, C, D>
IntoForEachSystem<(Commands,), (), (A, B, C, D)> for Func where
Func: FnMut(Commands, A, B, C, D) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(state.clone(),
A, B, C, D)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, A, B, C, D, E> IntoForEachSystem<(), (), (A, B, C, D, E)>
for Func where Func: FnMut(A, B, C, D, E) +
FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(A, B, C, D, E)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, A, B, C, D, E>
IntoForEachSystem<(Commands,), (), (A, B, C, D, E)> for Func where
Func: FnMut(Commands, A, B, C, D, E) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(state.clone(),
A, B, C, D, E)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, A, B, C, D, E, F>
IntoForEachSystem<(), (), (A, B, C, D, E, F)> for Func where
Func: FnMut(A, B, C, D, E, F) +
FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(A, B, C, D, E,
F)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, A, B, C, D, E, F>
IntoForEachSystem<(Commands,), (), (A, B, C, D, E, F)> for Func where
Func: FnMut(Commands, A, B, C, D, E, F) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(state.clone(),
A, B, C, D, E,
F)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, A, B, C, D, E, F, G>
IntoForEachSystem<(), (), (A, B, C, D, E, F, G)> for Func where
Func: FnMut(A, B, C, D, E, F, G) +
FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(A, B, C, D, E,
F, G)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, A, B, C, D, E, F, G>
IntoForEachSystem<(Commands,), (), (A, B, C, D, E, F, G)> for Func
where Func: FnMut(Commands, A, B, C, D, E, F, G) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(state.clone(),
A, B, C, D, E,
F, G)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, A, B, C, D, E, F, G, H>
IntoForEachSystem<(), (), (A, B, C, D, E, F, G, H)> for Func where
Func: FnMut(A, B, C, D, E, F, G, H) +
FnMut(<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(A, B, C, D, E,
F, G, H)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, A, B, C, D, E, F, G, H>
IntoForEachSystem<(Commands,), (), (A, B, C, D, E, F, G, H)> for Func
where Func: FnMut(Commands, A, B, C, D, E, F, G, H) +
FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(state.clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func> IntoQuerySystem<(), (), ()> for Func where Func: FnMut() +
FnMut() + Send + Sync + 'static {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe { self() }
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func> IntoQuerySystem<(Commands,), (), ()> for Func where
Func: FnMut(Commands) + FnMut(Commands) + Send + Sync + 'static {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe {
self(commands.clone())
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func, A> IntoQuerySystem<(), (), (A,)> for Func where
Func: FnMut(Query<A>) + FnMut(Query<A>) + Send + Sync + 'static,
A: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe { self(A) }
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A> IntoQuerySystem<(Commands,), (), (A,)> for Func where
Func: FnMut(Commands, Query<A>) + FnMut(Commands, Query<A>) + Send +
Sync + 'static, A: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
A)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B> IntoQuerySystem<(), (), (A, B)> for Func where
Func: FnMut(Query<A>, Query<B>) + FnMut(Query<A>, Query<B>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe { self(A, B) }
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B> IntoQuerySystem<(Commands,), (), (A, B)> for Func
where Func: FnMut(Commands, Query<A>, Query<B>) +
FnMut(Commands, Query<A>, Query<B>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
A, B)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C> IntoQuerySystem<(), (), (A, B, C)> for Func where
Func: FnMut(Query<A>, Query<B>, Query<C>) +
FnMut(Query<A>, Query<B>, Query<C>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery, C: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe { self(A, B, C) }
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C> IntoQuerySystem<(Commands,), (), (A, B, C)> for
Func where Func: FnMut(Commands, Query<A>, Query<B>, Query<C>) +
FnMut(Commands, Query<A>, Query<B>, Query<C>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
A, B, C)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C, D> IntoQuerySystem<(), (), (A, B, C, D)> for Func
where Func: FnMut(Query<A>, Query<B>, Query<C>, Query<D>) +
FnMut(Query<A>, Query<B>, Query<C>, Query<D>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe { self(A, B, C, D) }
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C, D> IntoQuerySystem<(Commands,), (), (A, B, C, D)>
for Func where
Func: FnMut(Commands, Query<A>, Query<B>, Query<C>, Query<D>) +
FnMut(Commands, Query<A>, Query<B>, Query<C>, Query<D>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
A, B, C, D)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C, D, E> IntoQuerySystem<(), (), (A, B, C, D, E)>
for Func where
Func: FnMut(Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) +
FnMut(Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(A, B, C, D, E)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C, D, E>
IntoQuerySystem<(Commands,), (), (A, B, C, D, E)> for Func where
Func: FnMut(Commands, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>) +
FnMut(Commands, Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
A, B, C, D, E)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C, D, E, F>
IntoQuerySystem<(), (), (A, B, C, D, E, F)> for Func where
Func: FnMut(Query<A>, Query<B>, Query<C>, Query<D>, Query<E>,
Query<F>) +
FnMut(Query<A>, Query<B>, Query<C>, Query<D>, Query<E>, Query<F>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, F: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(A, B, C, D, E, F)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, A, B, C, D, E, F>
IntoQuerySystem<(Commands,), (), (A, B, C, D, E, F)> for Func where
Func: FnMut(Commands, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>, Query<F>) +
FnMut(Commands, Query<A>, Query<B>, Query<C>, Query<D>, Query<E>,
Query<F>) + Send + Sync + 'static, A: HecsQuery, B: HecsQuery,
C: HecsQuery, D: HecsQuery, E: HecsQuery, F: HecsQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<() as ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let () =
resources.query_system::<()>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
A, B, C, D, E, F)
}
}
<<() as ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<()>::initialize(resources,
Some(id));
},
resource_access:
<<() as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A> IntoForEachSystem<(), (Ra,), (A,)> for Func where
Func: FnMut(Ra, A) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, A> IntoForEachSystem<(Commands,), (Ra,), (A,)> for
Func where Func: FnMut(Commands, Ra, A) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, A, B> IntoForEachSystem<(), (Ra,), (A, B)> for Func
where Func: FnMut(Ra, A, B) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A, B)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, A, B> IntoForEachSystem<(Commands,), (Ra,), (A, B)>
for Func where Func: FnMut(Commands, Ra, A, B) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A, B)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, A, B, C> IntoForEachSystem<(), (Ra,), (A, B, C)> for
Func where Func: FnMut(Ra, A, B, C) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery
{
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, A, B, C>
IntoForEachSystem<(Commands,), (Ra,), (A, B, C)> for Func where
Func: FnMut(Commands, Ra, A, B, C) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery
{
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D> IntoForEachSystem<(), (Ra,), (A, B, C, D)>
for Func where Func: FnMut(Ra, A, B, C, D) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D>
IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D)> for Func where
Func: FnMut(Commands, Ra, A, B, C, D) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E>
IntoForEachSystem<(), (Ra,), (A, B, C, D, E)> for Func where
Func: FnMut(Ra, A, B, C, D, E) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E>
IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E)> for Func where
Func: FnMut(Commands, Ra, A, B, C, D, E) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E, F>
IntoForEachSystem<(), (Ra,), (A, B, C, D, E, F)> for Func where
Func: FnMut(Ra, A, B, C, D, E, F) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E, F>
IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E, F)> for Func
where Func: FnMut(Commands, Ra, A, B, C, D, E, F) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E, F, G>
IntoForEachSystem<(), (Ra,), (A, B, C, D, E, F, G)> for Func where
Func: FnMut(Ra, A, B, C, D, E, F, G) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E, F, G>
IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E, F, G)> for Func
where Func: FnMut(Commands, Ra, A, B, C, D, E, F, G) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E, F, G, H>
IntoForEachSystem<(), (Ra,), (A, B, C, D, E, F, G, H)> for Func where
Func: FnMut(Ra, A, B, C, D, E, F, G, H) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, Ra, A, B, C, D, E, F, G, H>
IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E, F, G, H)> for
Func where Func: FnMut(Commands, Ra, A, B, C, D, E, F, G, H) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, Ra> IntoQuerySystem<(), (Ra,), ()> for Func where
Func: FnMut(Ra) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item) + Send +
Sync + 'static, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone())
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func, Ra> IntoQuerySystem<(Commands,), (Ra,), ()> for Func where
Func: FnMut(Commands, Ra) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item) + Send +
Sync + 'static, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone())
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func, Ra, A> IntoQuerySystem<(), (Ra,), (A,)> for Func where
Func: FnMut(Ra, Query<A>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>) + Send + Sync + 'static, A: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
A)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A> IntoQuerySystem<(Commands,), (Ra,), (A,)> for Func
where Func: FnMut(Commands, Ra, Query<A>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>) + Send + Sync + 'static, A: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
A)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B> IntoQuerySystem<(), (Ra,), (A, B)> for Func
where Func: FnMut(Ra, Query<A>, Query<B>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>) + Send + Sync + 'static, A: HecsQuery,
B: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
A, B)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B> IntoQuerySystem<(Commands,), (Ra,), (A, B)> for
Func where Func: FnMut(Commands, Ra, Query<A>, Query<B>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>) + Send + Sync + 'static, A: HecsQuery,
B: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
A, B)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C> IntoQuerySystem<(), (Ra,), (A, B, C)> for
Func where Func: FnMut(Ra, Query<A>, Query<B>, Query<C>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
A, B, C)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C>
IntoQuerySystem<(Commands,), (Ra,), (A, B, C)> for Func where
Func: FnMut(Commands, Ra, Query<A>, Query<B>, Query<C>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
A, B, C)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C, D> IntoQuerySystem<(), (Ra,), (A, B, C, D)>
for Func where
Func: FnMut(Ra, Query<A>, Query<B>, Query<C>, Query<D>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C, D>
IntoQuerySystem<(Commands,), (Ra,), (A, B, C, D)> for Func where
Func: FnMut(Commands, Ra, Query<A>, Query<B>, Query<C>, Query<D>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
A, B, C, D)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C, D, E>
IntoQuerySystem<(), (Ra,), (A, B, C, D, E)> for Func where
Func: FnMut(Ra, Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D, E)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C, D, E>
IntoQuerySystem<(Commands,), (Ra,), (A, B, C, D, E)> for Func where
Func: FnMut(Commands, Ra, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
A, B, C, D, E)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C, D, E, F>
IntoQuerySystem<(), (Ra,), (A, B, C, D, E, F)> for Func where
Func: FnMut(Ra, Query<A>, Query<B>, Query<C>, Query<D>, Query<E>,
Query<F>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>, Query<F>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, F: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
A, B, C, D, E, F)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, A, B, C, D, E, F>
IntoQuerySystem<(Commands,), (Ra,), (A, B, C, D, E, F)> for Func
where
Func: FnMut(Commands, Ra, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>, Query<F>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>, Query<F>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, F: HecsQuery, Ra: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::borrow(&resources);
{
let (Ra,) =
resources.query_system::<(Ra,)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
A, B, C, D, E, F)
}
}
<<(Ra,) as ResourceQuery>::Fetch
as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra,) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A> IntoForEachSystem<(), (Ra, Rb), (A,)> for Func
where Func: FnMut(Ra, Rb, A) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, Rb, A> IntoForEachSystem<(Commands,), (Ra, Rb), (A,)>
for Func where Func: FnMut(Commands, Ra, Rb, A) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B> IntoForEachSystem<(), (Ra, Rb), (A, B)> for
Func where Func: FnMut(Ra, Rb, A, B) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B>
IntoForEachSystem<(Commands,), (Ra, Rb), (A, B)> for Func where
Func: FnMut(Commands, Ra, Rb, A, B) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C>
IntoForEachSystem<(), (Ra, Rb), (A, B, C)> for Func where
Func: FnMut(Ra, Rb, A, B, C) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C>
IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C)> for Func where
Func: FnMut(Commands, Ra, Rb, A, B, C) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D>
IntoForEachSystem<(), (Ra, Rb), (A, B, C, D)> for Func where
Func: FnMut(Ra, Rb, A, B, C, D) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D>
IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D)> for Func where
Func: FnMut(Commands, Ra, Rb, A, B, C, D) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E>
IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E)> for Func where
Func: FnMut(Ra, Rb, A, B, C, D, E) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E>
IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E)> for Func
where Func: FnMut(Commands, Ra, Rb, A, B, C, D, E) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F>
IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F)> for Func where
Func: FnMut(Ra, Rb, A, B, C, D, E, F) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F>
IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F)> for Func
where Func: FnMut(Commands, Ra, Rb, A, B, C, D, E, F) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F, G>
IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F, G)> for Func where
Func: FnMut(Ra, Rb, A, B, C, D, E, F, G) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F, G>
IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F, G)> for
Func where Func: FnMut(Commands, Ra, Rb, A, B, C, D, E, F, G) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F, G, H>
IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F, G, H)> for Func
where Func: FnMut(Ra, Rb, A, B, C, D, E, F, G, H) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F, G, H>
IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F, G, H)>
for Func where
Func: FnMut(Commands, Ra, Rb, A, B, C, D, E, F, G, H) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, Ra, Rb> IntoQuerySystem<(), (Ra, Rb), ()> for Func where
Func: FnMut(Ra, Rb) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item) + Send +
Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone())
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func, Ra, Rb> IntoQuerySystem<(Commands,), (Ra, Rb), ()> for
Func where Func: FnMut(Commands, Ra, Rb) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item) + Send +
Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone())
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func, Ra, Rb, A> IntoQuerySystem<(), (Ra, Rb), (A,)> for Func
where Func: FnMut(Ra, Rb, Query<A>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>) + Send + Sync + 'static, A: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A> IntoQuerySystem<(Commands,), (Ra, Rb), (A,)>
for Func where Func: FnMut(Commands, Ra, Rb, Query<A>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>) + Send + Sync + 'static, A: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B> IntoQuerySystem<(), (Ra, Rb), (A, B)> for
Func where Func: FnMut(Ra, Rb, Query<A>, Query<B>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>) + Send + Sync + 'static, A: HecsQuery,
B: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B>
IntoQuerySystem<(Commands,), (Ra, Rb), (A, B)> for Func where
Func: FnMut(Commands, Ra, Rb, Query<A>, Query<B>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>) + Send + Sync + 'static, A: HecsQuery,
B: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C> IntoQuerySystem<(), (Ra, Rb), (A, B, C)>
for Func where Func: FnMut(Ra, Rb, Query<A>, Query<B>, Query<C>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C>
IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C)> for Func where
Func: FnMut(Commands, Ra, Rb, Query<A>, Query<B>, Query<C>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C, D>
IntoQuerySystem<(), (Ra, Rb), (A, B, C, D)> for Func where
Func: FnMut(Ra, Rb, Query<A>, Query<B>, Query<C>, Query<D>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C, D>
IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C, D)> for Func where
Func: FnMut(Commands, Ra, Rb, Query<A>, Query<B>, Query<C>,
Query<D>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E>
IntoQuerySystem<(), (Ra, Rb), (A, B, C, D, E)> for Func where
Func: FnMut(Ra, Rb, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E>
IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C, D, E)> for Func
where
Func: FnMut(Commands, Ra, Rb, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F>
IntoQuerySystem<(), (Ra, Rb), (A, B, C, D, E, F)> for Func where
Func: FnMut(Ra, Rb, Query<A>, Query<B>, Query<C>, Query<D>, Query<E>,
Query<F>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>, Query<F>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, F: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E, F)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, A, B, C, D, E, F>
IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F)> for Func
where
Func: FnMut(Commands, Ra, Rb, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>, Query<F>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>, Query<F>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, F: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb) =
resources.query_system::<(Ra,
Rb)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
A, B, C, D, E, F)
}
}
<<(Ra, Rb) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra,
Rb)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb) as ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A> IntoForEachSystem<(), (Ra, Rb, Rc), (A,)>
for Func where Func: FnMut(Ra, Rb, Rc, A) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A,)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, A) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B>
IntoForEachSystem<(), (Ra, Rb, Rc), (A, B)> for Func where
Func: FnMut(Ra, Rb, Rc, A, B) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, A, B) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C>
IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C)> for Func where
Func: FnMut(Ra, Rb, Rc, A, B, C) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C)> for Func
where Func: FnMut(Commands, Ra, Rb, Rc, A, B, C) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D>
IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D)> for Func where
Func: FnMut(Ra, Rb, Rc, A, B, C, D) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D)> for Func
where Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E>
IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where
Func: FnMut(Ra, Rb, Rc, A, B, C, D, E) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery
{
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E)> for
Func where Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery
{
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F>
IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F)> for Func
where Func: FnMut(Ra, Rb, Rc, A, B, C, D, E, F) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E, F)> for
Func where Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E, F) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F, G>
IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F, G)> for Func
where Func: FnMut(Ra, Rb, Rc, A, B, C, D, E, F, G) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F, G>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E, F, G)>
for Func where
Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E, F, G) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F, G, H>
IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F, G, H)> for
Func where Func: FnMut(Ra, Rb, Rc, A, B, C, D, E, F, G, H) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F, G, H>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc),
(A, B, C, D, E, F, G, H)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E, F, G, H) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc> IntoQuerySystem<(), (Ra, Rb, Rc), ()> for Func
where Func: FnMut(Ra, Rb, Rc) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item) + Send +
Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone())
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func, Ra, Rb, Rc> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), ()>
for Func where Func: FnMut(Commands, Ra, Rb, Rc) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item) + Send +
Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone())
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
},})
}
}
impl <Func, Ra, Rb, Rc, A> IntoQuerySystem<(), (Ra, Rb, Rc), (A,)> for
Func where Func: FnMut(Ra, Rb, Rc, Query<A>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>) + Send + Sync + 'static, A: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A>
IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A,)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, Query<A>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>) + Send + Sync + 'static, A: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B>
IntoQuerySystem<(), (Ra, Rb, Rc), (A, B)> for Func where
Func: FnMut(Ra, Rb, Rc, Query<A>, Query<B>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>) + Send + Sync + 'static, A: HecsQuery,
B: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery
{
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B>
IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, Query<A>, Query<B>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>) + Send + Sync + 'static, A: HecsQuery,
B: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery
{
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C>
IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C)> for Func where
Func: FnMut(Ra, Rb, Rc, Query<A>, Query<B>, Query<C>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C>
IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, Query<A>, Query<B>, Query<C>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>) + Send + Sync + 'static,
A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D>
IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C, D)> for Func where
Func: FnMut(Ra, Rb, Rc, Query<A>, Query<B>, Query<C>, Query<D>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D>
IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D)> for Func
where
Func: FnMut(Commands, Ra, Rb, Rc, Query<A>, Query<B>, Query<C>,
Query<D>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E>
IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where
Func: FnMut(Ra, Rb, Rc, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E>
IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E)> for Func
where
Func: FnMut(Commands, Ra, Rb, Rc, Query<A>, Query<B>, Query<C>,
Query<D>, Query<E>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>) + Send +
Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F>
IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F)> for Func where
Func: FnMut(Ra, Rb, Rc, Query<A>, Query<B>, Query<C>, Query<D>,
Query<E>, Query<F>) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>, Query<F>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, F: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E, F)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, A, B, C, D, E, F>
IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E, F)> for
Func where
Func: FnMut(Commands, Ra, Rb, Rc, Query<A>, Query<B>, Query<C>,
Query<D>, Query<E>, Query<F>) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
Query<A>, Query<B>, Query<C>, Query<D>, Query<E>, Query<F>) +
Send + Sync + 'static, A: HecsQuery, B: HecsQuery, C: HecsQuery,
D: HecsQuery, E: HecsQuery, F: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
#[allow(unused_assignments)]
#[allow(unused_mut)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
let A = ArchetypeAccess::default();
let B = ArchetypeAccess::default();
let C = ArchetypeAccess::default();
let D = ArchetypeAccess::default();
let E = ArchetypeAccess::default();
let F = ArchetypeAccess::default();
Box::new(SystemFn{state:
QuerySystemState{archetype_accesses:
<[_]>::into_vec(box
[A,
B,
C,
D,
E,
F]),
commands:
Commands::default(),},
thread_local_execution:
ThreadLocalExecution::NextFlush,
id,
name: core::any::type_name::<Self>().into(),
func:
move
|world, resources, archetype_access,
state|
{
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc) =
resources.query_system::<(Ra,
Rb,
Rc)>(id);
let mut i = 0;
let A =
Query::<A>::new(world,
&state.archetype_accesses[i]);
i += 1;
let B =
Query::<B>::new(world,
&state.archetype_accesses[i]);
i += 1;
let C =
Query::<C>::new(world,
&state.archetype_accesses[i]);
i += 1;
let D =
Query::<D>::new(world,
&state.archetype_accesses[i]);
i += 1;
let E =
Query::<E>::new(world,
&state.archetype_accesses[i]);
i += 1;
let F =
Query::<F>::new(world,
&state.archetype_accesses[i]);
i += 1;
let commands =
&state.commands;
unsafe {
self(commands.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
A, B, C, D, E, F)
}
}
<<(Ra, Rb, Rc) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{
state.commands.apply(world,
resources);
},
init_func:
move |resources|
{
<(Ra, Rb,
Rc)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc) as ResourceQuery>::Fetch
as FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, state|
{
archetype_access.clear();
let mut i = 0;
let mut access:
&mut ArchetypeAccess;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<A>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<B>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<C>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<D>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<E>(world);
archetype_access.union(access);
i += 1;
access =
&mut state.archetype_accesses[i];
access.clear();
access.set_access_for_query::<F>(world);
archetype_access.union(access);
i += 1;
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A,)> for Func where
Func: FnMut(Ra, Rb, Rc, Rd, A) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A,)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, Rd, A) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A,) in
world.query::<(A,)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B)> for Func where
Func: FnMut(Ra, Rb, Rc, Rd, A, B) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B)> for Func
where Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B) in
world.query::<(A,
B)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C)> for Func where
Func: FnMut(Ra, Rb, Rc, Rd, A, B, C) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C)> for Func
where Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C) in
world.query::<(A, B,
C)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D)> for Func where
Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,
Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D)> for
Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,
Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D) in
world.query::<(A, B, C,
D)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E)> for Func
where Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E)> for
Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D, E) in
world.query::<(A, B, C,
D,
E)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D, E)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F)> for Func
where Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E, F) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F)>
for Func where
Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E, F) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, Ra: ResourceQuery, Rb: ResourceQuery,
Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D, E, F) in
world.query::<(A, B, C,
D, E,
F)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D, E,
F)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F, G)> for
Func where Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E, F, G) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd),
(A, B, C, D, E, F, G)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, Ra: ResourceQuery,
Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D, E, F, G) in
world.query::<(A, B, C,
D, E, F,
G)>().iter()
{
unsafe {
self(state.clone(),
Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D, E,
F, G)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H>
IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F, G, H)> for
Func where Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H) +
FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,
Rd: ResourceQuery {
#[allow(non_snake_case)]
#[allow(unused_variables)]
#[allow(unused_unsafe)]
fn system(mut self) -> Box<dyn System> {
let id = SystemId::new();
Box::new(SystemFn{state: Commands::default(),
thread_local_execution:
ThreadLocalExecution::NextFlush,
name: core::any::type_name::<Self>().into(),
id,
func:
move
|world, resources,
_archetype_access, state|
{
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::borrow(&resources);
{
let (Ra, Rb, Rc, Rd) =
resources.query_system::<(Ra,
Rb,
Rc,
Rd)>(id);
for (A, B, C, D, E, F, G, H)
in
world.query::<(A, B, C,
D, E, F,
G,
H)>().iter()
{
unsafe {
self(Ra.unsafe_clone(),
Rb.unsafe_clone(),
Rc.unsafe_clone(),
Rd.unsafe_clone(),
A, B, C, D, E,
F, G, H)
}
}
}
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::release(&resources);
},
thread_local_func:
move |world, resources, state|
{ state.apply(world, resources); },
init_func:
move |resources|
{
<(Ra, Rb, Rc,
Rd)>::initialize(resources,
Some(id));
},
resource_access:
<<(Ra, Rb, Rc, Rd) as
ResourceQuery>::Fetch as
FetchResource>::access(),
archetype_access:
ArchetypeAccess::default(),
set_archetype_access:
|world, archetype_access, _state|
{
archetype_access.clear();
archetype_access.set_access_for_query::<(A,
B,
C,
D,
E,
F,
G,
H)>(world);
},})
}
}
impl <Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H>
IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd),
(A, B, C, D, E, F, G, H)> for Func where
Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H) +
FnMut(Commands,
<<Ra as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rb as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rc as ResourceQuery>::Fetch as FetchResource>::Item,
<<Rd as ResourceQuery>::Fetch as FetchResource>::Item,
<<A as HecsQuery>::Fetch as Fetch>::Item,
<<B as HecsQuery>::Fetch as Fetch>::Item,
<<C as HecsQuery>::Fetch as Fetch>::Item,
<<D as HecsQuery>::Fetch as Fetch>::Item,
<<E as HecsQuery>::Fetch as Fetch>::Item,
<<F as HecsQuery>::Fetch as Fetch>::Item,
<<G as HecsQuery>::Fetch as Fetch>::Item,
<<H as HecsQuery>::Fetch as Fetch>::Item) + Send + Sync +
'static, A: HecsQuery, B: HecsQuery, C: HecsQuery, D: HecsQuery,
E: HecsQuery, F: HecsQuery, G: HecsQuery, H: HecsQuery,
Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,
Rd: ResourceQuery {
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment