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    #[serde(default = "default_character")]
56    pub character: f32,
57    pub mute: bool,
58}
59
60fn default_lfo_rate() -> f32 {
61    0.5
62}
63fn default_lfo_target() -> f32 {
64    1.0
65}
66fn default_character() -> f32 {
67    0.5
68}
69
70fn default_hits() -> f32 {
71    4.0
72}
73
74pub fn save(dir: &Path, engine: &EngineHandle) -> Result<PathBuf> {
75    std::fs::create_dir_all(dir).context("create preset dir")?;
76    let name = chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string();
77    let path = dir.join(format!("{name}.toml"));
78
79    let tracks_guard = engine.tracks.lock();
80    let preset = PresetFile {
81        name: name.clone(),
82        bpm: engine.global.bpm.value(),
83        master_gain: engine.global.master_gain.value(),
84        brightness: engine.global.brightness.value(),
85        tracks: tracks_guard
86            .iter()
87            .map(|t| {
88                let s = t.params.snapshot();
89                TrackPreset {
90                    name: t.name.clone(),
91                    kind: kind_to_str(t.kind).to_string(),
92                    freq: s.freq,
93                    gain: s.gain,
94                    cutoff: s.cutoff,
95                    resonance: s.resonance,
96                    detune: s.detune,
97                    sweep_k: s.sweep_k,
98                    sweep_center: s.sweep_center,
99                    reverb_mix: s.reverb_mix,
100                    supermass: s.supermass,
101                    pulse_depth: s.pulse_depth,
102                    pattern_hits: s.pattern_hits,
103                    pattern_rotation: s.pattern_rotation,
104                    lfo_rate: s.lfo_rate,
105                    lfo_depth: s.lfo_depth,
106                    lfo_target: s.lfo_target,
107                    character: s.character,
108                    mute: s.muted,
109                }
110            })
111            .collect(),
112    };
113    drop(tracks_guard);
114
115    let text = toml::to_string_pretty(&preset).context("serialize preset")?;
116    std::fs::write(&path, text).with_context(|| format!("write {}", path.display()))?;
117    Ok(path)
118}
119
120pub fn load(path: &Path, engine: &EngineHandle) -> Result<usize> {
121    let text = std::fs::read_to_string(path)
122        .with_context(|| format!("read {}", path.display()))?;
123    let preset: PresetFile = toml::from_str(&text).context("parse preset TOML")?;
124
125    engine.global.bpm.set_value(preset.bpm.clamp(20.0, 200.0));
126    engine.global.master_gain.set_value(preset.master_gain.clamp(0.0, 1.5));
127    engine.global.brightness.set_value(preset.brightness.clamp(0.0, 1.0));
128
129    let tracks_guard = engine.tracks.lock();
130    let mut applied = 0;
131    for (i, snap) in preset.tracks.iter().enumerate() {
132        let Some(track) = tracks_guard.get(i) else {
133            break;
134        };
135        if kind_to_str(track.kind) != snap.kind {
136            continue; // slot mismatch — skip quietly
137        }
138        let p = &track.params;
139        p.freq.set_value(snap.freq);
140        p.gain.set_value(snap.gain);
141        p.cutoff.set_value(snap.cutoff);
142        p.resonance.set_value(snap.resonance);
143        p.detune.set_value(snap.detune);
144        p.sweep_k.set_value(snap.sweep_k);
145        p.sweep_center.set_value(snap.sweep_center);
146        p.reverb_mix.set_value(snap.reverb_mix);
147        p.supermass.set_value(snap.supermass);
148        p.pulse_depth.set_value(snap.pulse_depth);
149        p.pattern_hits.set_value(snap.pattern_hits.clamp(0.0, 16.0));
150        p.pattern_rotation
151            .set_value(snap.pattern_rotation.rem_euclid(16.0));
152        p.lfo_rate.set_value(snap.lfo_rate.clamp(0.01, 20.0));
153        p.lfo_depth.set_value(snap.lfo_depth.clamp(0.0, 1.0));
154        p.lfo_target.set_value(snap.lfo_target.clamp(0.0, 4.0));
155        p.character.set_value(snap.character.clamp(0.0, 1.0));
156        p.mute.set_value(if snap.mute { 1.0 } else { 0.0 });
157        applied += 1;
158    }
159    Ok(applied)
160}
161
162/// Find the most recently modified `.toml` in `dir` and load it.
163pub fn load_latest(dir: &Path, engine: &EngineHandle) -> Result<Option<(PathBuf, usize)>> {
164    if !dir.exists() {
165        return Ok(None);
166    }
167    let latest = std::fs::read_dir(dir)?
168        .filter_map(|e| e.ok())
169        .filter(|e| e.path().extension().and_then(|s| s.to_str()) == Some("toml"))
170        .max_by_key(|e| e.metadata().and_then(|m| m.modified()).ok());
171
172    let Some(entry) = latest else {
173        return Ok(None);
174    };
175    let path = entry.path();
176    let applied = load(&path, engine)?;
177    Ok(Some((path, applied)))
178}
179
180fn kind_to_str(k: PresetKind) -> &'static str {
181    match k {
182        PresetKind::PadZimmer => "PadZimmer",
183        PresetKind::DroneSub => "DroneSub",
184        PresetKind::Shimmer => "Shimmer",
185        PresetKind::Heartbeat => "Heartbeat",
186        PresetKind::BassPulse => "BassPulse",
187        PresetKind::Bell => "Bell",
188        PresetKind::SuperSaw => "SuperSaw",
189        PresetKind::PluckSaw => "PluckSaw",
190    }
191}
rust_synth/persistence.rs

rust_synth/
persistence.rs
