flowy/src/main.rs


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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

pub mod motion;

use log::debug;
use motion::{dec::MotionDecoder, enc::MotionEncoder, CommonBuffers, Params};
use pollster::FutureExt;
use std::io::{stdin, stdout, Read, Write};
use wgpu::{
    Backends, DeviceDescriptor, Extent3d, Features, Instance, InstanceDescriptor, Limits,
    MaintainBase, PowerPreference, RequestAdapterOptions,
};

use crate::motion::RoundParams;

fn main() {
    env_logger::init_from_env("LOG");

    let instance = Instance::new(InstanceDescriptor {
        backends: Backends::all(),
        ..Default::default()
    });

    let adapter = instance
        .request_adapter(&RequestAdapterOptions {
            power_preference: PowerPreference::HighPerformance,
            force_fallback_adapter: false,
            compatible_surface: None,
        })
        .block_on()
        .unwrap();

    let (device, queue) = adapter
        .request_device(
            &DeviceDescriptor {
                label: None,
                features: Features::BGRA8UNORM_STORAGE,
                limits: Limits::default(),
            },
            None,
        )
        .block_on()
        .unwrap();

    let (width, height) = (1920, 1080);
    let bsize = 8;
    let params = Params {
        width,
        height,
        extent: Extent3d {
            width: width as u32,
            height: height as u32,
            depth_or_array_layers: 1,
        },
        blocks_x: width / bsize,
        blocks_y: height / bsize,
        block_width: bsize,
        block_height: bsize,
        blocks: (width / bsize) * (height / bsize),
    };

    let bufs = CommonBuffers::create(&device, &params);
    let menc = MotionEncoder::create(&device, &params, &bufs);
    let mdec = MotionDecoder::create(&device, &params, &bufs);

    let mut buffer = vec![0u8; width * height * 4];

    menc.write_uniforms(&queue);
    mdec.write_uniforms(&queue);

    let mut i = 0;
    loop {
        let rp = RoundParams { swap: i % 2 };
        debug!("read");
        stdin().read_exact(&mut buffer).unwrap();

        debug!("upload");
        bufs.upload(&queue, &params, &rp, &buffer);

        debug!("compute");

        let mut encoder = device.create_command_encoder(&Default::default());

        if i > 1 {
            menc.pass(&mut encoder, &params, &rp);
            mdec.pass(&mut encoder, &params, &rp);
        }
        bufs.prepare_texture_download(&mut encoder, &params, &rp);

        queue.submit(Some(encoder.finish()));
        device.poll(MaintainBase::Wait);

        debug!("download");
        bufs.download(&device, &mut buffer);

        debug!("write");
        stdout().write_all(&buffer).unwrap();
        i += 1;
    }
}