Struct constellation::SystemScope

pub struct SystemScope<S: Send + Sync + 'static> { /* fields omitted */ }

Systems queued within a SystemScope may be scheduled to run in parallel.

Methods

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r0w0<F>(&mut self, f: F) -> u32 where
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r1w0<R0, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r2w0<R0, R1, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r3w0<R0, R1, R2, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r4w0<R0, R1, R2, R3, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r5w0<R0, R1, R2, R3, R4, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r6w0<R0, R1, R2, R3, R4, R5, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    R5: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4, &'b R5) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r0w1<W0, F>(&mut self, f: F) -> u32 where
    W0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b mut W0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r1w1<R0, W0, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    W0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b mut W0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r2w1<R0, R1, W0, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    W0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b mut W0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r3w1<R0, R1, R2, W0, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    W0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b mut W0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r4w1<R0, R1, R2, R3, W0, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    W0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b mut W0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r5w1<R0, R1, R2, R3, R4, W0, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    W0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4, &'b mut W0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r6w1<R0, R1, R2, R3, R4, R5, W0, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    R5: Resource,
    W0: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4, &'b R5, &'b mut W0) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r0w2<W0, W1, F>(&mut self, f: F) -> u32 where
    W0: Resource,
    W1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b mut W0, &'b mut W1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r1w2<R0, W0, W1, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    W0: Resource,
    W1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b mut W0, &'b mut W1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r2w2<R0, R1, W0, W1, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    W0: Resource,
    W1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b mut W0, &'b mut W1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r3w2<R0, R1, R2, W0, W1, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    W0: Resource,
    W1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b mut W0, &'b mut W1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r4w2<R0, R1, R2, R3, W0, W1, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    W0: Resource,
    W1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b mut W0, &'b mut W1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r5w2<R0, R1, R2, R3, R4, W0, W1, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    W0: Resource,
    W1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4, &'b mut W0, &'b mut W1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r6w2<R0, R1, R2, R3, R4, R5, W0, W1, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    R5: Resource,
    W0: Resource,
    W1: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4, &'b R5, &'b mut W0, &'b mut W1) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r0w3<W0, W1, W3, F>(&mut self, f: F) -> u32 where
    W0: Resource,
    W1: Resource,
    W3: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b mut W0, &'b mut W1, &'b mut W3) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r1w3<R0, W0, W1, W2, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    W0: Resource,
    W1: Resource,
    W2: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b mut W0, &'b mut W1, &'b mut W2) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r2w3<R0, R1, W0, W1, W2, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    W0: Resource,
    W1: Resource,
    W2: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b mut W0, &'b mut W1, &'b mut W2) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r3w3<R0, R1, R2, W0, W1, W2, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    W0: Resource,
    W1: Resource,
    W2: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b mut W0, &'b mut W1, &'b mut W2) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r4w3<R0, R1, R2, R3, W0, W1, W2, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    W0: Resource,
    W1: Resource,
    W2: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b mut W0, &'b mut W1, &'b mut W2) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r5w3<R0, R1, R2, R3, R4, W0, W1, W2, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    W0: Resource,
    W1: Resource,
    W2: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4, &'b mut W0, &'b mut W1, &'b mut W2) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.

impl<S: Send + Sync + 'static> SystemScope<S>

fn run_r6w3<R0, R1, R2, R3, R4, R5, W0, W1, W2, F>(&mut self, f: F) -> u32 where
    R0: Resource,
    R1: Resource,
    R2: Resource,
    R3: Resource,
    R4: Resource,
    R5: Resource,
    W0: Resource,
    W1: Resource,
    W2: Resource,
    F: for<'a, 'b> FnMut(&'a mut SystemContext<'b, S>, &'b R0, &'b R1, &'b R2, &'b R3, &'b R4, &'b R5, &'b mut W0, &'b mut W1, &'b mut W2) + Send + 'static, 

Queues a new system into the command buffer.

Each system queued within a single SystemScope may be executed in parallel with each other. See crate documentation for more information.