[−][src]Trait web_glitz::task::GpuTaskExt

pub trait GpuTaskExt<Ec>: GpuTask<Ec> {
    fn map<F, U>(self, f: F) -> Map<Self, F>
    where
        F: FnOnce(Self::Output) -> U,
        Self: Sized;

    fn join<B>(self, b: B) -> Join<Self, B, Ec>
    where
        B: GpuTask<Ec>,
        Self: Sized;

    fn join3<B, C>(self, b: B, c: C) -> Join3<Self, B, C, Ec>
    where
        B: GpuTask<Ec>,
        C: GpuTask<Ec>,
        Self: Sized;

    fn join4<B, C, D>(self, b: B, c: C, d: D) -> Join4<Self, B, C, D, Ec>
    where
        B: GpuTask<Ec>,
        C: GpuTask<Ec>,
        D: GpuTask<Ec>,
        Self: Sized;

    fn join5<B, C, D, E>(
        self, 
        b: B, 
        c: C, 
        d: D, 
        e: E
    ) -> Join5<Self, B, C, D, E, Ec>
    where
        B: GpuTask<Ec>,
        C: GpuTask<Ec>,
        D: GpuTask<Ec>,
        E: GpuTask<Ec>,
        Self: Sized;

    fn sequence<B>(self, b: B) -> Sequence<Self, B, Ec>
    where
        B: GpuTask<Ec>,
        Self: Sized;

    fn sequence3<B, C>(self, b: B, c: C) -> Sequence3<Self, B, C, Ec>
    where
        B: GpuTask<Ec>,
        C: GpuTask<Ec>,
        Self: Sized;

    fn sequence4<B, C, D>(
        self, 
        b: B, 
        c: C, 
        d: D
    ) -> Sequence4<Self, B, C, D, Ec>
    where
        B: GpuTask<Ec>,
        C: GpuTask<Ec>,
        D: GpuTask<Ec>,
        Self: Sized;

    fn sequence5<B, C, D, E>(
        self, 
        b: B, 
        c: C, 
        d: D, 
        e: E
    ) -> Sequence5<Self, B, C, D, E, Ec>
    where
        B: GpuTask<Ec>,
        C: GpuTask<Ec>,
        D: GpuTask<Ec>,
        E: GpuTask<Ec>,
        Self: Sized;
}

Required methods

fn map<F, U>(self, f: F) -> Map<Self, F> where
    F: FnOnce(Self::Output) -> U,
    Self: Sized, 

fn join<B>(self, b: B) -> Join<Self, B, Ec> where
    B: GpuTask<Ec>,
    Self: Sized, 

Combines this task with another task b, waiting for both tasks to complete in no particular order.

This returns a new "joined" task. This joined task may progress the its sub-tasks in any order. The joined task will finish when both sub-tasks have finished. When it finishes, it will output a tuple (A, B) where A is this tasks output and B is task b's output.

Panics

Panics if the ContextId of b is not compatible with this task's ContextId.

fn join3<B, C>(self, b: B, c: C) -> Join3<Self, B, C, Ec> where
    B: GpuTask<Ec>,
    C: GpuTask<Ec>,
    Self: Sized, 

Combines this task with 2 other tasks b and c, waiting for all tasks to complete in no particular order.

This returns a new "joined" task. This joined task may progress the its sub-tasks in any order. The joined task will finish when all sub-tasks have finished. When it finishes, it will output a tuple (A, B, C) where A is this tasks output, B is task b's output and C is task c's output.

Panics

Panics if any of the ContextIds of b and c are not compatible with this task's ContextId.

fn join4<B, C, D>(self, b: B, c: C, d: D) -> Join4<Self, B, C, D, Ec> where
    B: GpuTask<Ec>,
    C: GpuTask<Ec>,
    D: GpuTask<Ec>,
    Self: Sized, 

Combines this task with 3 other tasks b, c and d, waiting for all tasks to complete in no particular order.

This returns a new "joined" task. This joined task may progress the its sub-tasks in any order. The joined task will finish when all sub-tasks have finished. When it finishes, it will output a tuple (A, B, C, D) where A is this tasks output, B is task b's output, C is task c's output and D is task d's output.

Panics

Panics if any of the ContextIds of b, c and d are not compatible with this task's ContextId.

fn join5<B, C, D, E>(
    self,
    b: B,
    c: C,
    d: D,
    e: E
) -> Join5<Self, B, C, D, E, Ec> where
    B: GpuTask<Ec>,
    C: GpuTask<Ec>,
    D: GpuTask<Ec>,
    E: GpuTask<Ec>,
    Self: Sized, 

Combines this task with 4 other tasks b, c, d and e, waiting for all tasks to complete in no particular order.

This returns a new "joined" task. This joined task may progress the its sub-tasks in any order. The joined task will finish when all sub-tasks have finished. When it finishes, it will output a tuple (A, B, C, D, E) where A is this tasks output, B is task b's output, C is task c's output, D is task d's output and E is task e's output.

Panics

Panics if any of the ContextIds of b, c, d and e are not compatible with this task's ContextId.

fn sequence<B>(self, b: B) -> Sequence<Self, B, Ec> where
    B: GpuTask<Ec>,
    Self: Sized, 

Combines this task with another task b, waiting for both tasks to complete in order.

This returns a new "sequenced" task. This sequenced task must progress its sub-tasks in order: it may only start to progress the next task if the previous task has finished. The sequenced task will finish when the last sub-task has finished. When it finishes, it will output a tuple (A, B) where A is this tasks output and B is task b's output.

Panics

Panics if the ContextId of b is not compatible with this task's ContextId.

fn sequence3<B, C>(self, b: B, c: C) -> Sequence3<Self, B, C, Ec> where
    B: GpuTask<Ec>,
    C: GpuTask<Ec>,
    Self: Sized, 

Combines this task with 2 other tasks b and c, waiting for all tasks to complete in order.

This returns a new "sequenced" task. This sequenced task must progress its sub-tasks in order: it may only start to progress the next task if the previous task has finished. The sequenced task will finish when the last sub-task has finished. When it finishes, it will output a tuple (A, B, C) where A is this tasks output, B is task b's output and C is task c's output.

Panics

Panics if any of the ContextIds of b and c are not compatible with this task's ContextId.

fn sequence4<B, C, D>(self, b: B, c: C, d: D) -> Sequence4<Self, B, C, D, Ec> where
    B: GpuTask<Ec>,
    C: GpuTask<Ec>,
    D: GpuTask<Ec>,
    Self: Sized, 

Combines this task with 3 other tasks b, c and d, waiting for all tasks to complete in order.

This returns a new "sequenced" task. This sequenced task must progress its sub-tasks in order: it may only start to progress the next task if the previous task has finished. The sequenced task will finish when the last sub-task has finished. When it finishes, it will output a tuple (A, B, C, D) where A is this tasks output, B is task b's output, C is task c's output and D is task d's output.

Panics

Panics if any of the ContextIds of b, c and d are not compatible with this task's ContextId.

fn sequence5<B, C, D, E>(
    self,
    b: B,
    c: C,
    d: D,
    e: E
) -> Sequence5<Self, B, C, D, E, Ec> where
    B: GpuTask<Ec>,
    C: GpuTask<Ec>,
    D: GpuTask<Ec>,
    E: GpuTask<Ec>,
    Self: Sized, 

Combines this task with 4 other tasks b, c, d and e, waiting for all tasks to complete in order.

This returns a new "sequenced" task. This sequenced task must progress its sub-tasks in order: it may only start to progress the next task if the previous task has finished. The sequenced task will finish when the last sub-task has finished. When it finishes, it will output a tuple (A, B, C, D, E) where A is this tasks output, B is task b's output, C is task c's output, D is task d's output and E is task e's output.

Panics

Panics if any of the ContextIds of b, c, d and e are not compatible with this task's ContextId.

Loading content...

Implementors

impl<T, Ec> GpuTaskExt<Ec> for T where
    T: GpuTask<Ec>, [src]

Loading content...