sim-lib-view-daw 0.1.2

DAW timeline, mixer, plugin rack, and synth lenses for SIM Web.
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
94
95
96
97

//! The synth and signal lenses: parameter panels, modulation matrix, waveform,
//! and spectrum.
//!
//! A synth patch is a parameter map (name -> value). The panel renders each
//! parameter as a `scene/knob`, plus a modulation matrix (`scene/matrix`) and
//! live signal displays (`scene/waveform`, `scene/spectrum`). Parameter changes
//! flow through `intent/set-param` (see `param`).

use sim_kernel::Expr;
use sim_lib_scene::{node, sym};

/// The synth panel lens id.
pub const SYNTH_LENS: &str = "view:daw-synth";

/// Render a synth parameter map as a knob panel plus a modulation matrix.
pub fn synth_panel(params: &Expr) -> Expr {
    let knobs = match params {
        Expr::Map(entries) => entries
            .iter()
            .map(|(key, value)| knob(key, value))
            .collect(),
        _ => Vec::new(),
    };
    node(
        "stack",
        vec![
            ("role", sym("synth")),
            ("dir", sym("column")),
            (
                "children",
                Expr::List(vec![
                    node(
                        "stack",
                        vec![
                            ("role", sym("knobs")),
                            ("dir", sym("row")),
                            ("children", Expr::List(knobs)),
                        ],
                    ),
                    modulation_matrix(&[vec![0.0, 0.0], vec![0.0, 0.0]]),
                ]),
            ),
        ],
    )
}

fn knob(name: &Expr, value: &Expr) -> Expr {
    node(
        "knob",
        vec![
            ("param", name.clone()),
            ("min", number(0.0)),
            ("max", number(1.0)),
            ("value", value.clone()),
        ],
    )
}

/// A modulation matrix as an editable `scene/matrix`.
pub fn modulation_matrix(rows: &[Vec<f64>]) -> Expr {
    let rows = rows
        .iter()
        .map(|row| Expr::List(row.iter().map(|v| number(*v)).collect()))
        .collect();
    node(
        "matrix",
        vec![
            ("role", sym("modulation")),
            ("rows", Expr::List(rows)),
            ("editable", Expr::Bool(true)),
        ],
    )
}

/// A sampled-signal display.
pub fn waveform_view(samples: &[f32]) -> Expr {
    node(
        "waveform",
        vec![(
            "samples",
            Expr::List(samples.iter().map(|s| number(*s as f64)).collect()),
        )],
    )
}

/// A frequency-domain display.
pub fn spectrum_view(bins: &[f32]) -> Expr {
    node(
        "spectrum",
        vec![(
            "bins",
            Expr::List(bins.iter().map(|b| number(*b as f64)).collect()),
        )],
    )
}

use sim_value::build::float as number;