Trait oxygengine_core::ecs::SystemData

pub trait SystemData<'a> {
    pub fn setup(world: &mut World);
    pub fn fetch(world: &'a World) -> Self;
    pub fn reads() -> Vec<ResourceId, Global>;
    pub fn writes() -> Vec<ResourceId, Global>;
}

A static system data that can specify its dependencies at statically (at compile-time). Most system data is a SystemData, the DynamicSystemData type is only needed for very special setups.

You can derive this using the #[derive(SystemData)] macro provided by shred-derive. That is as simple as enabling the shred-derive feature.

Examples

use shred::{Read, ResourceId, SystemData, World, Write};

#[derive(Default)]
pub struct Clock;
#[derive(Default)]
pub struct Timer;

// This will implement `SystemData` for `MySystemData`.
// Please note that this will only work if `SystemData`, `World` and `ResourceId` are included.
#[derive(SystemData)]
pub struct MySystemData<'a> {
    pub clock: Read<'a, Clock>,
    pub timer: Write<'a, Timer>,
}

Required methods

pub fn setup(world: &mut World)

Sets up the system data for fetching it from the World.

pub fn fetch(world: &'a World) -> Self

Fetches the system data from World. Note that this is only specified for one concrete lifetime 'a, you need to implement the SystemData trait for every possible lifetime.

pub fn reads() -> Vec<ResourceId, Global>

Returns all read dependencies as fetched from Self::fetch.

Please note that returning wrong dependencies can lead to a panic.

pub fn writes() -> Vec<ResourceId, Global>

Returns all write dependencies as fetched from Self::fetch.

Please note that returning wrong dependencies can lead to a panic.

Loading content...

Implementations on Foreign Types

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C> SystemData<'a> for (A, B, C) where
    C: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H, I, J, K, L)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H, I, J, K, L, M)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, T> SystemData<'a> for PhantomData<T> where
    T: ?Sized, 

pub fn setup(&mut World)

pub fn fetch(&World) -> PhantomData<T>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D> SystemData<'a> for (A, B, C, D) where
    C: SystemData<'a>,
    D: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H> SystemData<'a> for (A, B, C, D, E, F, G, H) where
    C: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a> SystemData<'a> for ()

pub fn setup(&mut World)

pub fn fetch(&'a World)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

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

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A> SystemData<'a> for (A,) where
    A: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A,)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I> SystemData<'a> for (A, B, C, D, E, F, G, H, I) where
    C: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H, I)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    T: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>,
    U: SystemData<'a>,
    V: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    T: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    T: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>,
    U: SystemData<'a>,
    V: SystemData<'a>,
    W: SystemData<'a>,
    X: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, T, F> SystemData<'a> for Option<Read<'a, T, F>> where
    T: Resource, 

pub fn setup(&mut World)

pub fn fetch(world: &'a World) -> Option<Read<'a, T, F>>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    T: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>,
    U: SystemData<'a>,
    V: SystemData<'a>,
    W: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K) where
    C: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H, I, J, K)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, T, F> SystemData<'a> for Option<Write<'a, T, F>> where
    T: Resource, 

pub fn setup(&mut World)

pub fn fetch(world: &'a World) -> Option<Write<'a, T, F>>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    T: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>,
    U: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    T: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>,
    U: SystemData<'a>,
    V: SystemData<'a>,
    W: SystemData<'a>,
    X: SystemData<'a>,
    Y: SystemData<'a>,
    Z: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E> SystemData<'a> for (A, B, C, D, E) where
    C: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where
    C: SystemData<'a>,
    L: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    T: SystemData<'a>,
    S: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    R: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>,
    K: SystemData<'a>,
    M: SystemData<'a>,
    N: SystemData<'a>,
    O: SystemData<'a>,
    P: SystemData<'a>,
    Q: SystemData<'a>,
    U: SystemData<'a>,
    V: SystemData<'a>,
    W: SystemData<'a>,
    X: SystemData<'a>,
    Y: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(
    world: &'a World
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B> SystemData<'a> for (A, B) where
    A: SystemData<'a>,
    B: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G, H, I, J> SystemData<'a> for (A, B, C, D, E, F, G, H, I, J) where
    C: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    I: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>,
    H: SystemData<'a>,
    J: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G, H, I, J)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, A, B, C, D, E, F, G> SystemData<'a> for (A, B, C, D, E, F, G) where
    C: SystemData<'a>,
    E: SystemData<'a>,
    D: SystemData<'a>,
    F: SystemData<'a>,
    A: SystemData<'a>,
    B: SystemData<'a>,
    G: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> (A, B, C, D, E, F, G)

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, P> SystemData<'a> for ParentData<'a, P> where
    P: Component + Parent,
    <P as Component>::Storage: Tracked,
    Read<'a, EntitiesRes, DefaultProvider>: SystemData<'a>,
    Storage<'a, P, Fetch<'a, MaskedStorage<P>>>: SystemData<'a>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> ParentData<'a, P>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

Loading content...

Implementors

impl<'a, T> SystemData<'a> for Storage<'a, T, Fetch<'a, MaskedStorage<T>>> where
    T: Component, 

pub fn setup(res: &mut World)

pub fn fetch(res: &'a World) -> Storage<'a, T, Fetch<'a, MaskedStorage<T>>>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, T> SystemData<'a> for Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> where
    T: Component, 

pub fn setup(res: &mut World)

pub fn fetch(res: &'a World) -> Storage<'a, T, FetchMut<'a, MaskedStorage<T>>>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, T, F> SystemData<'a> for Read<'a, T, F> where
    T: Resource,
    F: SetupHandler<T>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> Read<'a, T, F>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

impl<'a, T, F> SystemData<'a> for Write<'a, T, F> where
    T: Resource,
    F: SetupHandler<T>, 

pub fn setup(world: &mut World)

pub fn fetch(world: &'a World) -> Write<'a, T, F>

pub fn reads() -> Vec<ResourceId, Global>

pub fn writes() -> Vec<ResourceId, Global>

Loading content...