From 709f0cb45acfff21d5052b4d1c07ecc0cdd45653 Mon Sep 17 00:00:00 2001
From: Chris Laupama <42254688+chrislaupama@users.noreply.github.com>
Date: Sun, 15 Nov 2026 18:21:29 +0000
Subject: [PATCH] Add the expanded Character Mod window
The window plots the circuit's motion in its own unit (ms delay, Hz
sweep, dB gain or pan) with one rule per LFO cycle, the band its series
travel and a legend naming them, captioned with the circuit and its mode.
The circuit and LFO controls sit on the main card; the rack card holds
Input, the circuit's artifacts (those it lacks leave the row), Depth-M
and Depth-S, Seed (a click plays the next take), Mono and Output.
---
CHANGELOG.md | 3 +
README.md | 4 +-
crates/dstudio-app/src/device_fields.rs | 135 +++++++++++++++++-
crates/dstudio-app/src/device_window.rs | 131 ++++++++++++++++-
.../dstudio-app/src/device_window_fields.rs | 26 +++-
docs/devices.md | 7 +-
6 files changed, 290 insertions(+), 16 deletions(-)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 630524a5..6e6320fc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -34,3 +34,6 @@ Nothing has been released yet. The first release, 0.1.0, will cover what is on `
- Expanded windows for Tremolo, Auto-Panner, Chorus, Flanger, Phaser and Ring Mod: a large plot of the effect's
motion or frequency response with a time or frequency axis, units and a legend, which you can drag to set its
rate and depth (or feedback or bias), In and Out meters, and every control on one row.
+- An expanded window for Character Mod: the circuit's motion in its own unit (delay, sweep, gain or pan) with the
+ band it travels and a legend, the circuit and LFO controls on one card, and a rack card with Input, the circuit's
+ artifacts, Depth-M and Depth-S, Seed (click for the next take), Mono and Output.
diff --git a/README.md b/README.md
index 4c409d56..71f45b65 100644
--- a/README.md
+++ b/README.md
@@ -122,8 +122,8 @@ framed by tools/art/render.mjs.
Device comes with 44 devices of its own. Each one is a single declarative definition (parameters, panel layout and
factory presets) that the model, undo, saving, automation, engine and panel all derive from, with a C++ DSP kernel
behind it. Auto Filter, Channel EQ and Character EQ also open an expanded window with a large display and live analyser,
-In and Out meters and every control laid out in rows, and so do Tremolo, Auto-Panner, Chorus, Flanger, Phaser and
-Ring Mod, whose window plots their motion or response with a time or frequency axis and a legend; the other devices
+In and Out meters and every control laid out in rows, and so do Tremolo, Auto-Panner, Chorus, Flanger, Phaser,
+Ring Mod and Character Mod, whose window plots their motion or response with a time or frequency axis and a legend; the other devices
open their card in a window for now.
[docs/devices.md](docs/devices.md) explains how they work and how to add one.
diff --git a/crates/dstudio-app/src/device_fields.rs b/crates/dstudio-app/src/device_fields.rs
index 49f5fb7a..b1bab89a 100644
--- a/crates/dstudio-app/src/device_fields.rs
+++ b/crates/dstudio-app/src/device_fields.rs
@@ -13,9 +13,9 @@
//! gain or position over 3.35 LFO cycles (the span at the default 0.51 Hz).
use dstudio_core::builtin::character_mod::{
- CIRCUITS, CROSSED, ENSEMBLE, FLANGER, MODE_PARAMS, PANNER, PHASER, PHOTOCELL, ROTARY, SINGLE, TAPE, TREMOLO, TWIN,
+ CHARACTER_MOD, CIRCUITS, CROSSED, ENSEMBLE, FLANGER, MODE_PARAMS, PANNER, PHASER, PHOTOCELL, ROTARY, SINGLE, TAPE, TREMOLO, TWIN,
};
-use dstudio_core::builtin::{DIVISION_QUARTERS, synced_hz};
+use dstudio_core::builtin::{DIVISION_QUARTERS, MOD_NOTE_QUARTERS, synced_hz};
use std::f32::consts::{PI, TAU};
use std::sync::OnceLock;
@@ -81,6 +81,8 @@ pub struct Axis {
pub end: String,
/// The legend sits at the right end of the caption row instead of under the axis.
pub legend_in_caption: bool,
+ /// The window caption's label when the picture names it (Character Mod's circuit).
+ pub caption: String,
}
/// Legend glyph of a series.
@@ -872,6 +874,17 @@ fn character_mod(i: &Input) -> Plot {
let n = i.n.max(2);
let values: Vec> = series.iter().map(|(f, _)| (0..n).map(|k| f(k as f32 / (n - 1) as f32 * SPAN)).collect()).collect();
let (lo, hi) = values.iter().flatten().fold((f32::MAX, f32::MIN), |(a, b), v| (a.min(*v), b.max(*v)));
+ if i.win {
+ let hz = i.lfo_hz("rate", "note", MOD_NOTE_QUARTERS);
+ let label = match MODE_PARAMS[circuit as usize] {
+ Some(mp) => {
+ let modes = CHARACTER_MOD.param(mp).map_or(&[][..], |p| p.choices);
+ format!("{} \u{00b7} {}", CIRCUITS[circuit as usize], modes.get(mode).copied().unwrap_or(""))
+ }
+ None => CIRCUITS[circuit as usize].to_string(),
+ };
+ return character_mod_window(unit, &values, (lo, hi), charmod_names(circuit, mode, values.len()), SPAN, hz, label);
+ }
// Axis, ticks, rest line and caption per unit; y_of maps a value to 0..1.
let (y_of, ticks, rest, readout, band): (Box f32>, Vec<(f32, String)>, Option, String, bool) = match unit {
Unit::Ms => {
@@ -935,6 +948,108 @@ fn character_mod(i: &Input) -> Plot {
}
}
+/// Names of Character Mod's series in the window legend.
+fn charmod_names(circuit: u32, mode: usize, n: usize) -> Vec<&'static str> {
+ let names: &[&'static str] = match circuit {
+ ENSEMBLE => &["Voice 1", "Voice 2", "Voice 3"],
+ PHASER if mode == 4 => &["Voice 1", "Voice 2", "Voice 3"],
+ TAPE if mode > 0 => &["Left", "Right", "Dry"],
+ TREMOLO if mode == 2 => &["Low", "High"],
+ ROTARY => &["Horn", "Drum"],
+ PANNER => &["Pan"],
+ _ => &["Left", "Right"],
+ };
+ names.iter().copied().take(n).collect()
+}
+
+/// Character Mod's window picture: the circuit's ruler (delay in ms, a log sweep in Hz,
+/// gain in dB or pan), one rule per LFO cycle along the time axis, the band its series
+/// travel, and a legend naming each series.
+fn character_mod_window(
+ unit: Unit,
+ values: &[Vec],
+ (lo, hi): (f32, f32),
+ names: Vec<&'static str>,
+ span: f32,
+ hz: f32,
+ caption: String,
+) -> Plot {
+ let (y_of, ticks, rest, readout, foot, band): (Box f32>, Vec<(f32, String)>, Option, String, &str, bool) =
+ match unit {
+ Unit::Ms => {
+ let top = axis_top(hi);
+ let step = [0.5f32, 1.0, 2.0, 2.5, 5.0, 10.0, 20.0].into_iter().find(|s| top / s <= 6.0).unwrap_or(10.0);
+ let ticks = (0..=((top / (step / 2.0)) + 1e-4).floor() as usize)
+ .map(|k| {
+ let v = k as f32 * step / 2.0;
+ let label = if k % 2 == 0 { num(v) } else { String::new() };
+ (1.0 - v / top, label)
+ })
+ .collect();
+ (Box::new(move |v| lin(v, top, 0.0)), ticks, Some(1.0), format!("{lo:.1} \u{2013} {hi:.1} ms"), "ms delay", true)
+ }
+ Unit::Hz => {
+ let (a, b) = (WIN_HZ.0.ln(), WIN_HZ.1.ln());
+ let ticks =
+ [50.0f32, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0].iter().map(|f| ((b - f.ln()) / (b - a), hz_tick(*f))).collect();
+ let rest = (b - 1000f32.ln()) / (b - a);
+ (
+ Box::new(move |v| lin(v.max(1.0).ln(), b, a)),
+ ticks,
+ Some(rest),
+ format!("{} \u{2013} {}", khz_text(lo), khz_text(hi)),
+ "Hz sweep",
+ true,
+ )
+ }
+ Unit::Db => {
+ let ticks = (0..=8)
+ .map(|k| {
+ let db = -3.0 * k as f32;
+ (db / -24.0, if k % 2 == 0 { rung(db) } else { String::new() })
+ })
+ .collect();
+ let readout = if lo <= -90.0 { "\u{221e} dB".into() } else { format!("{:.1} dB", -lo) };
+ (Box::new(|v| lin(v, 0.0, -24.0)), ticks, Some(0.0), readout, "dB gain", true)
+ }
+ Unit::Pos => {
+ let ticks = [(0.0, "L"), (0.25, ""), (0.5, "C"), (0.75, ""), (1.0, "R")].iter().map(|(y, l)| (*y, l.to_string())).collect();
+ let readout = format!("\u{00b1}{}%", (lo.abs().max(hi.abs()) * 100.0).round());
+ (Box::new(|v| lin(v, -1.0, 1.0)), ticks, Some(0.5), readout, "pan", true)
+ }
+ };
+ let traces: Vec = values
+ .iter()
+ .enumerate()
+ .map(|(k, v)| Trace { ys: v.iter().map(|x| y_of(*x)).collect(), style: WIN_SERIES[k.min(WIN_SERIES.len() - 1)] })
+ .collect();
+ let mut legend: Vec<(Mark, String)> =
+ names.iter().enumerate().map(|(k, n)| (Mark::Line(WIN_SERIES[k.min(WIN_SERIES.len() - 1)]), n.to_string())).collect();
+ if band && !values.is_empty() {
+ legend.push((Mark::Band, "Sweep".into()));
+ }
+ let mut axis = motion_axis(span, hz, foot);
+ axis.caption = caption;
+ Plot { readout, ticks, rest, traces, fill: if band { Fill::Band } else { Fill::None }, widths: (1.75, 2.5), live: None, axis, legend }
+}
+
+/// Character Mod's window sweep ruler (Hz).
+const WIN_HZ: (f32, f32) = (40.0, 8000.0);
+
+/// Character Mod's window series: the first voice solid, then dashed and dotted.
+const WIN_SERIES: [Style; 3] = [Style::Solid, Style::Dash { on: 5.0, off: 4.0, alpha: 0.6 }, Style::Dash { on: 1.5, off: 3.0, alpha: 0.6 }];
+
+/// A sweep's frequency with its unit: 144 Hz, 2.00 kHz, 12.0 kHz.
+fn khz_text(f: f32) -> String {
+ if f >= 10_000.0 {
+ format!("{:.1} kHz", f / 1000.0)
+ } else if f >= 1000.0 {
+ format!("{:.2} kHz", f / 1000.0)
+ } else {
+ format!("{f:.0} Hz")
+ }
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -987,6 +1102,22 @@ mod tests {
assert!(plot_of("flanger", &[], None).axis.ticks.is_empty());
}
+ /// Character Mod's window names its circuit, reads the sweep in its own unit and
+ /// lists every series plus the band.
+ #[test]
+ fn character_mod_window_names_circuit_and_series() {
+ let p = window_plot_of("character-mod");
+ assert_eq!(p.axis.caption, "Twin BBD \u{00b7} I");
+ assert_eq!(p.axis.foot, "ms delay");
+ assert!(p.readout.ends_with(" ms"), "{}", p.readout);
+ let names: Vec<&str> = p.legend.iter().map(|l| l.1.as_str()).collect();
+ assert_eq!(names, ["Left", "Right", "Sweep"]);
+ assert_eq!(p.fill, Fill::Band);
+ assert_eq!(charmod_names(ENSEMBLE, 0, 3), ["Voice 1", "Voice 2", "Voice 3"]);
+ assert_eq!(khz_text(1265.0), "1.26 kHz");
+ assert_eq!(khz_text(144.0), "144 Hz");
+ }
+
#[test]
fn window_time_labels() {
assert_eq!(time_text(0.25), "250 ms");
diff --git a/crates/dstudio-app/src/device_window.rs b/crates/dstudio-app/src/device_window.rs
index ca4f7d29..da4c0941 100644
--- a/crates/dstudio-app/src/device_window.rs
+++ b/crates/dstudio-app/src/device_window.rs
@@ -75,7 +75,11 @@ const DRIVE_STEPS: [f32; 4] = [0.0, 25.0, 50.0, 75.0];
pub(crate) const ACT_ANALYZER: i32 = 7;
/// The analyser's Hold view latch.
pub(crate) const ACT_HOLD: i32 = 8;
+/// Character Mod: play the next take (seed).
+pub(crate) const ACT_SEED: i32 = 9;
const PILL_GHOST: i32 = 6;
+/// Character Mod's Mode parameter of each circuit (Ensemble has none).
+const CM_MODES: [Option<&str>; 11] = dstudio_core::builtin::character_mod::MODE_PARAMS;
const PILL_GHOST_LATCH: i32 = 7;
/// panel-menu code of the band picker (a menu of the EQ's bands).
pub(crate) const MENU_BANDS: i32 = -3;
@@ -89,7 +93,7 @@ pub(crate) fn has_window(def: &DeviceDef) -> bool {
/// Windows of the plotted-field family (motion and response pictures).
fn is_field_window(def: &DeviceDef) -> bool {
- matches!(def.id, "tremolo" | "autopanner" | "chorus" | "flanger" | "phaser" | "ring-mod")
+ matches!(def.id, "tremolo" | "autopanner" | "chorus" | "flanger" | "phaser" | "ring-mod" | "character-mod")
}
/// The frame of a device's window: content width, display box (x, y, w, h), the
@@ -122,6 +126,7 @@ pub(crate) fn kit(def: &DeviceDef) -> Kit {
"chorus" | "flanger" => field_kit(WIN_W, 354.0, 56.0, 44.0),
"phaser" => field_kit(WIN_W, 374.0, 56.0, 44.0),
"ring-mod" => field_kit(860.0, 254.0, 40.0, 29.0),
+ "character-mod" => field_kit(WIN_W, 222.0, 60.0, 44.0),
_ => eq(56.0, 394.0),
}
}
@@ -381,6 +386,8 @@ fn pill_w(label: &str) -> f32 {
"Tame" => 55.0,
"Off" | "On" => 41.5,
"2x" => 37.8,
+ "Lo" => 37.8,
+ "Hi" => 35.7,
"4x" => 38.3,
_ => (crate::text_measure::value_width(label) * 1.2 + 24.0).ceil(),
}
@@ -491,6 +498,10 @@ enum Item {
Knob(&'static str, &'static str, i32, f32, bool),
/// On / off toggle column (56 wide): parameter, name, inert.
Toggle(&'static str, &'static str, bool),
+ /// On / off toggle column of a given width: parameter, name, width.
+ ToggleW(&'static str, &'static str, f32),
+ /// One lit pill that runs a window action: action, label, name, width.
+ Action(i32, String, &'static str, f32),
/// Picker column: parameter (or a menu code), label, name, width, inert.
Picker(i32, String, &'static str, f32, bool),
/// Pill row column: parameter, labels with their values, name, width.
@@ -506,6 +517,8 @@ impl Item {
match self {
Item::Knob(_, _, _, w, _) => *w,
Item::Toggle(..) => 56.0,
+ Item::ToggleW(.., w) => *w,
+ Item::Action(.., w) => *w,
Item::Picker(_, _, _, w, _) => *w,
Item::Pills(.., w) => *w,
Item::ActionPills(_, _, _, _, w, _) => *w,
@@ -753,6 +766,19 @@ impl Controller {
p.inert = inert;
b.name(x, 56.0, row.name_y(), name, inert);
}
+ Item::ToggleW(id, name, w) => {
+ let on = val(id) >= 0.5;
+ let label = if on { "On" } else { "Off" };
+ let pw = pill_w(label);
+ b.rect(BOX_TRACK, x + (w - pw - 4.0) / 2.0, top + row.pill - 2.0, pw + 4.0, 28.0);
+ b.pill(PILL_TOGGLE, idx(id), 0, x + (w - pw) / 2.0, top + row.pill, pw, label, on);
+ b.name(x, w, row.name_y(), name, false);
+ }
+ Item::Action(action, label, name, w) => {
+ let pw = pill_w(&label);
+ b.pill(PILL_ACTION, action, 1, x + (w - pw) / 2.0, top + row.pill, pw, &label, true);
+ b.name(x, w, row.name_y(), name, false);
+ }
Item::Picker(param, label, name, w, inert) => {
let p = b.pill(PILL_PICKER, param, 0, x + w / 2.0, top + row.pill, 0.0, &label, false);
p.inert = inert;
@@ -893,6 +919,9 @@ impl Controller {
/// (Ring Mod: its modulator), the device's own selector, then its secondary knobs.
/// Returns the window's content height.
fn field_window(&self, d: &Device, def: &'static DeviceDef, b: &mut Builder, y: f32) -> f32 {
+ if def.id == "character-mod" {
+ return self.character_mod_window(d, def, b, y);
+ }
let val = |id: &str| def.param(id).map_or(0.0, |p| self.panel_value(d, def, p));
let rate = if val("sync") >= 0.5 { "rate_sync" } else { "rate" };
let lfo = || {
@@ -949,6 +978,65 @@ impl Controller {
y + row.h + 16.0
}
+ /// Character Mod's two cards: the circuit and its motion, then its rack (Input, the
+ /// circuit's artifacts, the mid / side depths, Seed and Mono, Output). A control the
+ /// circuit lacks leaves the row, and the gutters close up around it.
+ fn character_mod_window(&self, d: &Device, def: &'static DeviceDef, b: &mut Builder, y: f32) -> f32 {
+ let val = |id: &str| def.param(id).map_or(0.0, |p| self.panel_value(d, def, p));
+ let idx = |id: &str| def.index_of(id).map_or(-1, |i| i as i32);
+ let label = |id: &str| def.param(id).map(|p| p.format(val(id))).unwrap_or_default();
+ let circuit = (val("model").round().max(0.0) as usize).min(CM_MODES.len() - 1);
+ let mut character = vec![Item::Picker(idx("model"), label("model"), "Character", 112.0, false)];
+ if let Some(mode) = CM_MODES[circuit] {
+ character.push(Item::Picker(idx(mode), label(mode), "Mode", 104.0, false));
+ }
+ let rate = if val("sync") >= 0.5 { "note" } else { "rate" };
+ let main = Row::main(y);
+ self.win_card(
+ d,
+ def,
+ b,
+ main,
+ vec![
+ (character, 10.0),
+ (
+ vec![
+ Item::Pills("sync", vec![("Free", 0.0), ("Sync", 1.0)], "Timebase", 108.0),
+ Item::Knob(rate, "Rate", 2, 70.0, false),
+ Item::Knob("depth", "Depth", 2, 70.0, false),
+ Item::Knob("mix", "Mix", 1, 56.0, false),
+ ],
+ 10.0,
+ ),
+ (
+ vec![
+ Item::Knob("width", "Width", 1, 56.0, false),
+ Item::Knob("drift", "Drift", 1, 56.0, false),
+ Item::Knob("voice", "Voice", 1, 56.0, false),
+ ],
+ 10.0,
+ ),
+ ],
+ );
+ let shown = |id: &str| def.is_shown(d, id);
+ let artifacts: Vec- = [("art_hiss", "Hiss"), ("art_drive", "Drive"), ("art_darken", "Darken"), ("art_wow", "Wow")]
+ .into_iter()
+ .filter(|(id, _)| shown(id))
+ .map(|(id, name)| Item::Knob(id, name, 1, 56.0, false))
+ .collect();
+ let mut clusters = vec![(vec![Item::Pills("input", vec![("Off", 0.0), ("Lo", 1.0), ("Hi", 2.0)], "Input", 120.0)], 10.0)];
+ if !artifacts.is_empty() {
+ clusters.push((artifacts, 10.0));
+ }
+ clusters.push((vec![Item::Knob("depth_m", "Depth-M", 1, 60.0, false), Item::Knob("depth_s", "Depth-S", 1, 60.0, false)], 10.0));
+ let take = format!("Take {}", val("seed").round() as i32);
+ clusters.push((vec![Item::Action(ACT_SEED, take, "Seed", 96.0), Item::ToggleW("mono_audition", "Mono", 64.0)], 10.0));
+ clusters.push((vec![Item::Knob("trim", "Output", 1, 56.0, false)], 10.0));
+ let rack = Row::rack(y + main.h + 12.0);
+ self.win_card(d, def, b, rack, clusters);
+ rack.y + rack.h + 16.0
+ }
+
// ------------------------------------------------------------ EQs
/// Band pills of an EQ header: the selected band lit, bands out of the chain dimmed.
@@ -1265,6 +1353,14 @@ impl Controller {
self.devices.wins.analyzer.insert(device, view);
let _ = self.engine.builtin_set_spectrum(device.0, view.engine_mode());
}
+ (ACT_SEED, _) => {
+ let Some(p) = def.param("seed") else { return };
+ let span = (p.max - p.min + 1.0).round() as i32;
+ let cur = def.value(d, p).round() as i32 - p.min as i32;
+ let step = if value < 0 { -1 } else { 1 };
+ let next = p.min + (cur + step).rem_euclid(span) as f32;
+ self.panel_commit(Command::SetDeviceParam { device, param: p.id.into(), value: next });
+ }
(ACT_HOLD, _) => {
if !self.devices.wins.held.remove(&device) {
self.devices.wins.held.insert(device);
@@ -1416,7 +1512,7 @@ mod tests {
#[test]
fn field_windows_show_the_plot_and_every_control() {
use slint::Model;
- for id in ["tremolo", "autopanner", "chorus", "flanger", "phaser", "ring-mod"] {
+ for id in ["tremolo", "autopanner", "chorus", "flanger", "phaser", "ring-mod", "character-mod"] {
let (c, did, def) = controller_with(id);
assert!(has_window(def), "{id}");
let v = view(&c, did, def);
@@ -1440,7 +1536,7 @@ mod tests {
#[ignore]
fn bench_field_windows() {
let n = 500;
- for id in ["tremolo", "autopanner", "chorus", "flanger", "phaser", "ring-mod"] {
+ for id in ["tremolo", "autopanner", "chorus", "flanger", "phaser", "ring-mod", "character-mod"] {
let (c, did, def) = controller_with(id);
let d = c.project().device(did).unwrap().clone();
let t0 = std::time::Instant::now();
@@ -1457,6 +1553,35 @@ mod tests {
}
}
+ /// Character Mod: two cards; the rack drops the artifacts a circuit lacks, and the
+ /// Seed pill plays the next take, wrapping at the end.
+ #[test]
+ fn character_mod_window_rows_follow_the_circuit() {
+ use slint::Model;
+ let (mut c, did, def) = controller_with("character-mod");
+ let v = view(&c, did, def);
+ assert!((v.h / Z - 520.0).abs() < 0.5, "{}", v.h / Z);
+ assert_eq!(
+ knob_names(&v),
+ ["Rate", "Depth", "Mix", "Width", "Drift", "Voice", "Hiss", "Drive", "Darken", "Depth-M", "Depth-S", "Output"]
+ );
+ let take = |c: &Controller| view(c, did, def).pills.iter().find(|p| p.param == ACT_SEED).map(|p| p.label.to_string());
+ assert_eq!(take(&c).as_deref(), Some("Take 1"));
+ c.win_action(did, ACT_SEED, 1);
+ assert_eq!(take(&c).as_deref(), Some("Take 2"));
+ c.win_action(did, ACT_SEED, -1);
+ c.win_action(did, ACT_SEED, -1);
+ assert_eq!(take(&c).as_deref(), Some("Take 9999"));
+ // Panner has no artifacts but Wow-free circuits keep the rest; Ensemble has no Mode.
+ let model = def.index_of("model").unwrap() as i32;
+ c.win_choice(did, model, 10);
+ let names = knob_names(&view(&c, did, def));
+ assert!(!names.iter().any(|n| n == "Hiss" || n == "Drive" || n == "Darken"), "{names:?}");
+ c.win_choice(did, model, 3);
+ let modes = view(&c, did, def).texts.iter().filter(|t| t.text == "Mode").count();
+ assert_eq!(modes, 0, "Ensemble has no Mode picker");
+ }
+
/// Character EQ's lower card shows one section at a time.
#[test]
fn character_eq_sections_switch_the_lower_card() {
diff --git a/crates/dstudio-app/src/device_window_fields.rs b/crates/dstudio-app/src/device_window_fields.rs
index a38fc0cd..d37606b9 100644
--- a/crates/dstudio-app/src/device_window_fields.rs
+++ b/crates/dstudio-app/src/device_window_fields.rs
@@ -30,8 +30,9 @@ const STRONG: f32 = 0.13;
const INK_LO: f32 = 0.3;
const INK_HI: f32 = 0.92;
const LEGEND_INK: f32 = 0.7;
-/// The accent wash under a motion curve.
+/// The accent wash under a motion curve, and the band a sweep travels.
const WASH: f32 = 0.28;
+const BAND: f32 = 0.16;
/// Series widths: the subject, and a dashed second series.
const W_MAIN: f32 = 1.75;
const W_DASH: f32 = 1.25;
@@ -78,10 +79,10 @@ impl Controller {
// Caption: the name and the picture's one value, on the band above the plot.
let base = (CAPTION_BASELINE - t) * Z;
- let label = caption(def, &f);
+ let label: String = if plot.axis.caption.is_empty() { caption(def, &f).into() } else { plot.axis.caption.clone() };
let lx = if def.id == "ring-mod" { 0.0 } else { 2.0 * Z };
- texts.push(PanelText { weight: 700, ..text(lx, base - 4.4 * Z, 140.0 * Z, label, MUTE_TEXT, 12.0 * Z, 0) });
- let vx = lx + (label_w(label) + CAPTION_GAP) * Z;
+ texts.push(PanelText { weight: 700, ..text(lx, base - 4.4 * Z, 240.0 * Z, label.clone(), MUTE_TEXT, 12.0 * Z, 0) });
+ let vx = lx + (label_w(&label) + CAPTION_GAP) * Z;
texts.push(text(vx, base - 4.7 * Z, 260.0 * Z, plot.readout.clone(), white(INK_HI), 13.0 * Z, 0));
// The ladder: a rule per rung (the rest line stronger), numerals in the left margin.
@@ -152,6 +153,15 @@ impl Controller {
rgba(accent, WASH),
));
}
+ if plot.fill == Fill::Band {
+ let ys = plot.traces.iter().flat_map(|t| t.ys.iter().copied());
+ let (top, bottom) = ys.fold((f32::MAX, f32::MIN), |(a, b), y| (a.min(y), b.max(y)));
+ if top <= bottom {
+ let y0 = top.clamp(0.0, 1.0) * ph;
+ let y1 = (bottom.clamp(0.0, 1.0) * ph).max(y0 + 1.0);
+ paths.push(fill(format!("M0 {y0:.1} L{pw:.1} {y0:.1} L{pw:.1} {y1:.1} L0 {y1:.1} Z"), rgba(accent, BAND)));
+ }
+ }
for tr in plot.traces.iter().skip(1) {
if let Style::Dash { on, off, alpha } = tr.style {
paths.push(stroke(dashed(&points(&tr.ys), on * Z, off * Z), white(alpha), W_DASH * Z));
@@ -171,8 +181,10 @@ impl Controller {
for ((mark, name), w) in plot.legend.iter().zip(widths) {
match mark {
Mark::Band => {
- paths
- .push(fill(format!("M{x:.1} {:.1} h{glyph:.1} v{:.1} h{:.1} Z", y - 4.0 * Z, 8.0 * Z, -glyph), rgba(accent, WASH)));
+ paths.push(fill(
+ format!("M{x:.1} {:.1} h{glyph:.1} v{:.1} h{:.1} Z", y - 4.0 * Z, 8.0 * Z, -glyph),
+ rgba(accent, if plot.fill == Fill::Band { BAND } else { WASH }),
+ ));
}
Mark::Line(Style::Solid) => paths.push(stroke(format!("M{x:.1} {y:.1} L{:.1} {y:.1}", x + glyph), white(1.0), W_MAIN * Z)),
&Mark::Line(Style::Dash { on, off, alpha }) => {
@@ -202,7 +214,7 @@ impl Controller {
paths: model(paths),
texts: model(texts),
zones: model(vec![zone]),
- label: label.into(),
+ label: label.as_str().into(),
value: plot.readout.into(),
..Default::default()
}
diff --git a/docs/devices.md b/docs/devices.md
index 78a2ffe8..51b007d0 100644
--- a/docs/devices.md
+++ b/docs/devices.md
@@ -64,7 +64,7 @@ flowchart LR
expanded window (`device_window.rs`, `ui/device_window.slint`) when the
device has one (`device_window::has_window`; Auto Filter, Channel EQ,
Character EQ and the plotted-field family: Tremolo, Auto-Panner, Chorus,
- Flanger, Phaser and Ring Mod), otherwise the card itself in a window. A
+ Flanger, Phaser, Ring Mod and Character Mod), otherwise the card itself in a window. A
window is a face 960 pt wide (Ring Mod 860): a top bar (power, presets, the device's header pills), a
large display (the card's canvas drawn at window size with its axis and
legend), In / Out meters, and rows of controls laid out with the same
@@ -72,7 +72,10 @@ flowchart LR
window's display (`device_window_fields.rs`) asks the card's curve model in
`device_fields.rs` for its window form (`Input::win`): a taller ladder, a
time or frequency axis with units under the plot, and a legend naming each
- series; dragging the plot moves the card field's two parameters. The
+ series; dragging the plot moves the card field's two parameters. Character
+ Mod's picture reads in its circuit's own unit (ms delay, Hz sweep, dB gain or
+ pan) with the band its series travel, and its rack card drops the artifacts
+ a circuit lacks; its Seed pill plays the next take (`ACT_SEED`). The
meters read `se_builtin_set_metering` / `se_builtin_levels`
(`Engine::builtin_levels(id, &mut [f32; 4])`): while a window is open the
audio thread keeps the input and output peak of each block, and the app