rust_synth/
persistence.rs

1//! Preset save / load — human-readable TOML.
2//!
3//! Each preset captures the *live* state: global BPM + master gain and,
4//! per track, every tonal parameter and mute flag. The preset kind
5//! (`PadZimmer`, `DroneSub`, …) is stored for sanity-checking on load,
6//! but cannot be changed at runtime — kinds are baked into the audio
7//! graph built at startup, so load only copies params where the kind
8//! matches the current slot.
9
10use anyhow::{Context, Result};
11use serde::{Deserialize, Serialize};
12use std::path::{Path, PathBuf};
13
14use crate::audio::engine::EngineHandle;
15use crate::audio::preset::PresetKind;
16
17#[derive(Debug, Serialize, Deserialize)]
18pub struct PresetFile {
19    pub name: String,
20    pub bpm: f32,
21    pub master_gain: f32,
22    #[serde(default = "default_brightness")]
23    pub brightness: f32,
24    pub tracks: Vec<TrackPreset>,
25}
26
27fn default_brightness() -> f32 {
28    0.7
29}
30
31#[derive(Debug, Serialize, Deserialize)]
32pub struct TrackPreset {
33    pub name: String,
34    pub kind: String,
35    pub freq: f32,
36    pub gain: f32,
37    pub cutoff: f32,
38    pub resonance: f32,
39    pub detune: f32,
40    pub sweep_k: f32,
41    pub sweep_center: f32,
42    pub reverb_mix: f32,
43    pub supermass: f32,
44    pub pulse_depth: f32,
45    #[serde(default = "default_hits")]
46    pub pattern_hits: f32,
47    #[serde(default)]
48    pub pattern_rotation: f32,
49    #[serde(default = "default_lfo_rate")]
50    pub lfo_rate: f32,
51    #[serde(default)]
52    pub lfo_depth: f32,
53    #[serde(default = "default_lfo_target")]
54    pub lfo_target: f32,
55    pub mute: bool,
56}
57
58fn default_lfo_rate() -> f32 {
59    0.5
60}
61fn default_lfo_target() -> f32 {
62    1.0
63}
64
65fn default_hits() -> f32 {
66    4.0
67}
68
69pub fn save(dir: &Path, engine: &EngineHandle) -> Result<PathBuf> {
70    std::fs::create_dir_all(dir).context("create preset dir")?;
71    let name = chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string();
72    let path = dir.join(format!("{name}.toml"));
73
74    let tracks_guard = engine.tracks.lock();
75    let preset = PresetFile {
76        name: name.clone(),
77        bpm: engine.global.bpm.value(),
78        master_gain: engine.global.master_gain.value(),
79        brightness: engine.global.brightness.value(),
80        tracks: tracks_guard
81            .iter()
82            .map(|t| {
83                let s = t.params.snapshot();
84                TrackPreset {
85                    name: t.name.clone(),
86                    kind: kind_to_str(t.kind).to_string(),
87                    freq: s.freq,
88                    gain: s.gain,
89                    cutoff: s.cutoff,
90                    resonance: s.resonance,
91                    detune: s.detune,
92                    sweep_k: s.sweep_k,
93                    sweep_center: s.sweep_center,
94                    reverb_mix: s.reverb_mix,
95                    supermass: s.supermass,
96                    pulse_depth: s.pulse_depth,
97                    pattern_hits: s.pattern_hits,
98                    pattern_rotation: s.pattern_rotation,
99                    lfo_rate: s.lfo_rate,
100                    lfo_depth: s.lfo_depth,
101                    lfo_target: s.lfo_target,
102                    mute: s.muted,
103                }
104            })
105            .collect(),
106    };
107    drop(tracks_guard);
108
109    let text = toml::to_string_pretty(&preset).context("serialize preset")?;
110    std::fs::write(&path, text).with_context(|| format!("write {}", path.display()))?;
111    Ok(path)
112}
113
114pub fn load(path: &Path, engine: &EngineHandle) -> Result<usize> {
115    let text = std::fs::read_to_string(path)
116        .with_context(|| format!("read {}", path.display()))?;
117    let preset: PresetFile = toml::from_str(&text).context("parse preset TOML")?;
118
119    engine.global.bpm.set_value(preset.bpm.clamp(20.0, 200.0));
120    engine.global.master_gain.set_value(preset.master_gain.clamp(0.0, 1.5));
121    engine.global.brightness.set_value(preset.brightness.clamp(0.0, 1.0));
122
123    let tracks_guard = engine.tracks.lock();
124    let mut applied = 0;
125    for (i, snap) in preset.tracks.iter().enumerate() {
126        let Some(track) = tracks_guard.get(i) else {
127            break;
128        };
129        if kind_to_str(track.kind) != snap.kind {
130            continue; // slot mismatch — skip quietly
131        }
132        let p = &track.params;
133        p.freq.set_value(snap.freq);
134        p.gain.set_value(snap.gain);
135        p.cutoff.set_value(snap.cutoff);
136        p.resonance.set_value(snap.resonance);
137        p.detune.set_value(snap.detune);
138        p.sweep_k.set_value(snap.sweep_k);
139        p.sweep_center.set_value(snap.sweep_center);
140        p.reverb_mix.set_value(snap.reverb_mix);
141        p.supermass.set_value(snap.supermass);
142        p.pulse_depth.set_value(snap.pulse_depth);
143        p.pattern_hits.set_value(snap.pattern_hits.clamp(0.0, 16.0));
144        p.pattern_rotation
145            .set_value(snap.pattern_rotation.rem_euclid(16.0));
146        p.lfo_rate.set_value(snap.lfo_rate.clamp(0.01, 20.0));
147        p.lfo_depth.set_value(snap.lfo_depth.clamp(0.0, 1.0));
148        p.lfo_target.set_value(snap.lfo_target.clamp(0.0, 4.0));
149        p.mute.set_value(if snap.mute { 1.0 } else { 0.0 });
150        applied += 1;
151    }
152    Ok(applied)
153}
154
155/// Find the most recently modified `.toml` in `dir` and load it.
156pub fn load_latest(dir: &Path, engine: &EngineHandle) -> Result<Option<(PathBuf, usize)>> {
157    if !dir.exists() {
158        return Ok(None);
159    }
160    let latest = std::fs::read_dir(dir)?
161        .filter_map(|e| e.ok())
162        .filter(|e| e.path().extension().and_then(|s| s.to_str()) == Some("toml"))
163        .max_by_key(|e| e.metadata().and_then(|m| m.modified()).ok());
164
165    let Some(entry) = latest else {
166        return Ok(None);
167    };
168    let path = entry.path();
169    let applied = load(&path, engine)?;
170    Ok(Some((path, applied)))
171}
172
173fn kind_to_str(k: PresetKind) -> &'static str {
174    match k {
175        PresetKind::PadZimmer => "PadZimmer",
176        PresetKind::DroneSub => "DroneSub",
177        PresetKind::Shimmer => "Shimmer",
178        PresetKind::Heartbeat => "Heartbeat",
179        PresetKind::BassPulse => "BassPulse",
180        PresetKind::Bell => "Bell",
181        PresetKind::SuperSaw => "SuperSaw",
182        PresetKind::PluckSaw => "PluckSaw",
183    }
184}
rust_synth/persistence.rs

rust_synth/
persistence.rs
