maolan 0.2.2

Rust DAW application for recording, editing, routing, automation, export, and plugin hosting
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::message::Message;
use iced::{
    Color, Point, Rectangle, Renderer, Theme, mouse,
    widget::{
        canvas::Cache, canvas::Frame, canvas::Geometry, canvas::Path, canvas::Program,
        canvas::Stroke,
    },
};
use std::{
    cell::Cell,
    hash::{Hash, Hasher},
};

/// A single sample/value point on a normalized curve.
///
/// `value` is expected to be in the `[0, 1]` range; it is clamped when drawn.
#[derive(Debug, Clone, Copy)]
pub struct CurvePoint {
    pub sample: usize,
    pub value: f32,
}

impl CurvePoint {
    /// Compute the local position of this point inside `bounds`.
    ///
    /// The returned `Point` is relative to the top-left corner of the canvas,
    /// since `iced` translates the renderer by `(bounds.x, bounds.y)` before
    /// calling `Program::draw`.
    pub fn position(&self, bounds: Rectangle, pixels_per_sample: f32) -> Point {
        let x = self.sample as f32 * pixels_per_sample;
        let y = if bounds.height <= f32::EPSILON {
            0.0
        } else {
            bounds.height * (1.0 - self.value.clamp(0.0, 1.0))
        };
        Point::new(x, y)
    }
}

#[derive(Clone)]
pub struct CurveCanvas {
    pub points: Vec<CurvePoint>,
    pub pixels_per_sample: f32,
    pub color: Color,
    pub dot_radius: f32,
    pub line_width: f32,
}

#[derive(Default)]
pub struct CurveCanvasState {
    cache: Cache,
    last_hash: Cell<u64>,
}

impl CurveCanvas {
    fn shape_hash(&self, bounds: Rectangle) -> u64 {
        let mut hasher = std::collections::hash_map::DefaultHasher::new();
        bounds.width.to_bits().hash(&mut hasher);
        bounds.height.to_bits().hash(&mut hasher);
        self.pixels_per_sample.to_bits().hash(&mut hasher);
        self.color.r.to_bits().hash(&mut hasher);
        self.color.g.to_bits().hash(&mut hasher);
        self.color.b.to_bits().hash(&mut hasher);
        self.color.a.to_bits().hash(&mut hasher);
        self.dot_radius.to_bits().hash(&mut hasher);
        self.line_width.to_bits().hash(&mut hasher);
        self.points.len().hash(&mut hasher);
        for point in &self.points {
            point.sample.hash(&mut hasher);
            point.value.to_bits().hash(&mut hasher);
        }
        hasher.finish()
    }
}

impl Program<Message> for CurveCanvas {
    type State = CurveCanvasState;

    fn draw(
        &self,
        state: &Self::State,
        renderer: &Renderer,
        _theme: &Theme,
        bounds: Rectangle,
        _cursor: mouse::Cursor,
    ) -> Vec<Geometry> {
        if bounds.width <= f32::EPSILON || bounds.height <= f32::EPSILON {
            return vec![];
        }

        let hash = self.shape_hash(bounds);
        if state.last_hash.get() != hash {
            state.cache.clear();
            state.last_hash.set(hash);
        }

        let geometry = state
            .cache
            .draw(renderer, bounds.size(), |frame: &mut Frame| {
                if self.points.len() < 2 {
                    return;
                }

                let mut sorted = self.points.clone();
                sorted.sort_unstable_by_key(|point| point.sample);

                let line = Path::new(|path| {
                    let first = sorted[0].position(bounds, self.pixels_per_sample);
                    path.move_to(first);
                    for point in sorted.iter().skip(1) {
                        path.line_to(point.position(bounds, self.pixels_per_sample));
                    }
                });
                frame.stroke(
                    &line,
                    Stroke::default()
                        .with_color(self.color)
                        .with_width(self.line_width),
                );

                for point in sorted {
                    let center = point.position(bounds, self.pixels_per_sample);
                    let circle = Path::circle(center, self.dot_radius.max(0.0));
                    frame.fill(&circle, self.color);
                }
            });

        vec![geometry]
    }
}