phosphor-crt 0.1.0

A real-time plotter of waveforms, imitating oscillscope CRTs
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use wgpu::util::DeviceExt;
use wgpu::{Buffer, Device, VertexBufferLayout};

#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub(crate) enum WaveformMode {
    YT,
    XY,
}
#[derive(Debug)]
pub(crate) struct WaveformResources {
    num_samples: usize,
    buffer: Buffer,
    mode: WaveformMode,
}

impl WaveformResources {
    pub(crate) fn samples_size_bytes(&self) -> usize {
        match self.mode {
            WaveformMode::YT => size_of::<[f32; 1]>(),
            WaveformMode::XY => size_of::<[f32; 2]>(),
        }
    }
}

impl WaveformResources {
    pub(crate) fn new(waveform: &[f32], device: &Device, mode: WaveformMode) -> WaveformResources {
        let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Waveform buffer"),
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            contents: bytemuck::cast_slice(waveform),
        });

        let num_samples = match mode {
            WaveformMode::YT => waveform.len(),
            WaveformMode::XY => waveform.len() / 2,
        };

        WaveformResources {
            buffer,
            num_samples,
            mode,
        }
    }

    pub(crate) fn buffer_layout(&self) -> VertexBufferLayout<'static> {
        match self.mode {
            WaveformMode::YT => VertexBufferLayout {
                array_stride: 2 * size_of::<f32>() as wgpu::BufferAddress,
                step_mode: wgpu::VertexStepMode::Instance,
                attributes: &[
                    wgpu::VertexAttribute {
                        offset: 0,
                        shader_location: 0,
                        format: wgpu::VertexFormat::Float32,
                    },
                    wgpu::VertexAttribute {
                        offset: size_of::<f32>() as wgpu::BufferAddress,
                        shader_location: 1,
                        format: wgpu::VertexFormat::Float32,
                    },
                ],
            },
            WaveformMode::XY => VertexBufferLayout {
                array_stride: 4 * size_of::<f32>() as wgpu::BufferAddress,
                step_mode: wgpu::VertexStepMode::Instance,
                attributes: &[
                    wgpu::VertexAttribute {
                        offset: 0,
                        shader_location: 0,
                        format: wgpu::VertexFormat::Float32x2,
                    },
                    wgpu::VertexAttribute {
                        offset: 2 * size_of::<f32>() as wgpu::BufferAddress,
                        shader_location: 1,
                        format: wgpu::VertexFormat::Float32x2,
                    },
                ],
            },
        }
    }

    pub(crate) fn num_samples(&self) -> usize {
        self.num_samples
    }

    pub(crate) fn buffer(&self) -> &Buffer {
        &self.buffer
    }

    pub fn mode(&self) -> WaveformMode {
        self.mode
    }
}