pipx 0.1.0

Composable pipelines for Rust with synchronous and asynchronous execution, middleware-style processing, and predictable data flow.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use std::sync::Arc;

use pipx::{Next, Pipe, Pipeline, PipelineResult};

#[derive(Debug)]
struct RenderFrame {
    label: String,
    command_log: Vec<String>,
    vertex_count: u32,
}

struct UploadBuffers;

impl Pipe<RenderFrame> for UploadBuffers {
    fn handle(
        &self,
        mut passable: RenderFrame,
        next: Next<'_, RenderFrame>,
    ) -> PipelineResult<RenderFrame> {
        passable.command_log.push("wgpu:upload-buffers".to_string());
        next.handle(passable)
    }
}

struct EncodeRenderPass;

impl Pipe<RenderFrame> for EncodeRenderPass {
    fn handle(
        &self,
        mut passable: RenderFrame,
        next: Next<'_, RenderFrame>,
    ) -> PipelineResult<RenderFrame> {
        passable.command_log.push(format!(
            "wgpu:encode-render-pass vertices={}",
            passable.vertex_count
        ));

        next.handle(passable)
    }
}

struct SubmitQueue;

impl Pipe<RenderFrame> for SubmitQueue {
    fn handle(
        &self,
        mut passable: RenderFrame,
        next: Next<'_, RenderFrame>,
    ) -> PipelineResult<RenderFrame> {
        passable.command_log.push("wgpu:queue-submit".to_string());
        next.handle(passable)
    }
}

fn main() -> pipx::PipelineResult<()> {
    let frame = RenderFrame {
        label: "main-pass".to_string(),
        command_log: Vec::new(),
        vertex_count: 36,
    };

    let frame = Pipeline::new()
        .send(frame)
        .through(vec![
            Arc::new(UploadBuffers),
            Arc::new(EncodeRenderPass),
            Arc::new(SubmitQueue),
        ])
        .then_return()?;

    println!("{} {:?}", frame.label, frame.command_log);
    Ok(())
}