feat(oscilloscope): stacked display mode (#17)

Signed-off-by: Maika Namuo <httpworldview@gmail.com>

Author: httpsworldview

src/persistence/visuals.rs

@@ -226,6 +226,7 @@ visual_settings!(OscilloscopeSettings from OscilloscopeConfig {
     channel_1: Channel, channel_2: Channel,
 } extra {
     persistence: f32 = 0.0,
+    stacked: bool = false,
 });
 
 visual_settings!(WaveformSettings from WaveformConfig {

src/ui/settings/oscilloscope.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Maika Namuo
 
-use super::widgets::{SliderRange, card, palette_card, pick, set_if_changed, update_f32_range};
+use super::widgets::{SliderRange, card, palette_card, pick, set_if_changed, toggle, update_f32_range};
 use crate::persistence::settings::OscilloscopeSettings;
 use crate::util::audio::Channel;
 use crate::visuals::oscilloscope::processor::TriggerMode;
@@ -65,6 +65,7 @@ settings_messages!(pane, value {
     TriggerSource(Channel) => set_if_changed(&mut pane.settings.trigger_source, value);
     Channel1(Channel) => set_if_changed(&mut pane.settings.channel_1, value);
     Channel2(Channel) => set_if_changed(&mut pane.settings.channel_2, value);
+    Stacked(bool) => set_if_changed(&mut pane.settings.stacked, value);
 });
 
 impl Pane {
@@ -109,6 +110,7 @@ impl Pane {
             card("Signal", signal);
             card("Trigger", trigger);
             card("Display", controls!(8.0;
+                toggle("Stacked", self.settings.stacked, Message::Stacked);
                 slider!("Persistence", self.settings.persistence, PERSISTENCE_RANGE, Message::Persistence, "{:.2}");
             ));
             palette_card(&self.palette, Message::Palette);

src/visuals/oscilloscope/processor.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::VecDeque;
 use std::sync::Arc;
 
-const TRACE_COUNT: usize = 2;
+pub(in crate::visuals::oscilloscope) const TRACE_COUNT: usize = 2;
 
 fn parabolic_refine(y_prev: f32, y_curr: f32, y_next: f32, tau: usize) -> f32 {
     let denom = y_prev - 2.0 * y_curr + y_next;
@@ -562,6 +562,7 @@ fn find_rising_zero_crossing(
 pub struct OscilloscopeSnapshot {
     pub epoch: u64,
     pub channels: usize,
+    pub slots: [usize; TRACE_COUNT],
     pub samples: Vec<f32>,
     pub samples_per_channel: usize,
 }
@@ -722,6 +723,7 @@ impl OscilloscopeProcessor {
                 capture,
                 target,
             ) {
+                self.snapshot.slots[self.snapshot.channels] = slot;
                 self.snapshot.channels += 1;
             }
         }

src/visuals/oscilloscope/render.rs

@@ -4,6 +4,7 @@
 use iced::Rectangle;
 use iced::advanced::graphics::Viewport;
 
+use super::processor::TRACE_COUNT;
 use crate::util::color::rgba_with_alpha;
 use crate::visuals::render::common::sdf_primitive;
 use crate::visuals::render::common::{
@@ -16,8 +17,10 @@ pub struct OscilloscopeParams {
     pub bounds: Rectangle,
     pub channels: usize,
     pub samples_per_channel: usize,
+    pub slots: [usize; TRACE_COUNT],
     pub samples: Vec<f32>,
-    pub color: [f32; 4],
+    pub colors: [[f32; 4]; TRACE_COUNT],
+    pub stacked: bool,
     pub fill_alpha: f32,
 }
 
@@ -29,9 +32,12 @@ impl OscilloscopePrimitive {
         const STROKE_WIDTH: f32 = 1.0;
 
         let samples_per_channel = self.params.samples_per_channel;
-        let channels = self.params.channels.max(1);
+        let channels = self.params.channels.min(TRACE_COUNT);
 
-        if samples_per_channel < 2 || self.params.samples.len() < channels * samples_per_channel {
+        if channels == 0
+            || samples_per_channel < 2
+            || self.params.samples.len() < channels * samples_per_channel
+        {
             return;
         }
 
@@ -40,7 +46,7 @@ impl OscilloscopePrimitive {
 
         let layout = ChannelLayout::new(
             bounds,
-            channels,
+            if self.params.stacked { 1 } else { channels },
             VERTICAL_PADDING,
             CHANNEL_GAP,
             AMPLITUDE_SCALE,
@@ -51,15 +57,12 @@ impl OscilloscopePrimitive {
         let vertices = &mut scratch.vertices;
         let positions = &mut scratch.points;
 
-        for (channel_idx, channel_samples) in self
-            .params
-            .samples
-            .chunks_exact(samples_per_channel)
-            .take(channels)
-            .enumerate()
-        {
-            let color = self.params.color;
-            let center = layout.center_y(channel_idx);
+        for i in 0..channels {
+            let channel_idx = if self.params.stacked { channels - 1 - i } else { i };
+            let start = channel_idx * samples_per_channel;
+            let channel_samples = &self.params.samples[start..start + samples_per_channel];
+            let color = self.params.colors[self.params.slots[channel_idx].min(TRACE_COUNT - 1)];
+            let center = layout.center_y(if self.params.stacked { 0 } else { channel_idx });
 
             positions.clear();
             positions.extend(channel_samples.iter().enumerate().map(|(i, &s)| {

src/visuals/oscilloscope/state.rs

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Maika Namuo
 
-use super::processor::OscilloscopeSnapshot;
+use super::processor::{OscilloscopeSnapshot, TRACE_COUNT};
 use super::render::{OscilloscopeParams, OscilloscopePrimitive};
 use crate::persistence::settings::OscilloscopeSettings;
 use crate::util::color::color_to_rgba;
 use crate::visuals::palettes;
 use iced::Color;
 
-const OSCILLOSCOPE_PALETTE_SIZE: usize = 1;
+const OSCILLOSCOPE_PALETTE_SIZE: usize = TRACE_COUNT;
 const MAX_PERSISTENCE: f32 = 0.98;
 const FILL_ALPHA: f32 = 0.15;
 
@@ -17,6 +17,7 @@ pub(in crate::visuals) struct OscilloscopeState {
     snapshot: OscilloscopeSnapshot,
     pub(in crate::visuals) colors: [Color; OSCILLOSCOPE_PALETTE_SIZE],
     pub(in crate::visuals) persistence: f32,
+    pub(in crate::visuals) stacked: bool,
     key: u64,
 }
 
@@ -27,16 +28,18 @@ impl OscilloscopeState {
             snapshot: OscilloscopeSnapshot::default(),
             colors: palettes::oscilloscope::COLORS,
             persistence: defaults.persistence,
+            stacked: defaults.stacked,
             key: crate::visuals::next_key(),
         }
     }
 
-    pub fn update_view_settings(&mut self, persistence: f32, reset_snapshot: bool) {
+    pub fn update_view_settings(&mut self, persistence: f32, stacked: bool, reset_snapshot: bool) {
         self.persistence = if persistence.is_finite() {
             persistence.clamp(0.0, 1.0)
         } else {
             OscilloscopeSettings::default().persistence
         };
+        self.stacked = stacked;
         if reset_snapshot {
             self.snapshot = OscilloscopeSnapshot::default();
         }
@@ -53,6 +56,7 @@ impl OscilloscopeState {
             && snapshot.channels == self.snapshot.channels
             && snapshot.samples_per_channel == self.snapshot.samples_per_channel
             && snapshot.samples.len() == self.snapshot.samples.len()
+            && snapshot.slots[..snapshot.channels] == self.snapshot.slots[..self.snapshot.channels]
         {
             let persistence = self.persistence.clamp(0.0, MAX_PERSISTENCE);
             if persistence > f32::EPSILON {
@@ -80,8 +84,10 @@ impl OscilloscopeState {
             bounds,
             channels,
             samples_per_channel,
+            slots: self.snapshot.slots,
             samples: self.snapshot.samples.clone(),
-            color: color_to_rgba(self.colors[0]),
+            colors: self.colors.map(color_to_rgba),
+            stacked: self.stacked,
             fill_alpha: FILL_ALPHA,
         })
     }

src/visuals/palettes.rs

@@ -117,9 +117,12 @@ pub mod waveform {
 
 pub mod oscilloscope {
     use super::Color;
-    pub const COLORS: [Color; 1] = [Color::from_rgb8(0xFF, 0xFF, 0xFF)];
-    pub const LABELS: &[&str] = &["Trace"];
-    pub const DEFAULT_POSITIONS: [f32; COLORS.len()] = [0.0];
+    pub const COLORS: [Color; 2] = [
+        Color::from_rgb8(0xFF, 0xFF, 0xFF),
+        Color::from_rgb8(0xFF, 0xFF, 0xFF),
+    ];
+    pub const LABELS: &[&str] = &["Channel 1", "Channel 2"];
+    pub const DEFAULT_POSITIONS: [f32; COLORS.len()] = [0.0, 1.0];
 }
 
 pub mod stereometer {

src/visuals/registry.rs

@@ -23,13 +23,35 @@ use std::{cell::RefCell, rc::Rc};
 
 type Shared<T> = Rc<RefCell<T>>;
 
+// too many stops -> keep first N
+// too few stops -> copy provided, repeat last
 fn resolve_palette<const N: usize>(
     custom: Option<&PaletteSettings>,
     default: &[Color; N],
 ) -> [Color; N] {
-    custom
-        .and_then(PaletteSettings::to_array)
-        .unwrap_or(*default)
+    let Some(custom) = custom else {
+        return *default;
+    };
+
+    if let Some(colors) = custom.to_array() {
+        return colors;
+    }
+
+    let mut colors = *default;
+    let mut last = None;
+    let mut used = 0;
+    for (dst, stop) in colors.iter_mut().zip(&custom.stops) {
+        let color = (*stop).into();
+        *dst = color;
+        last = Some(color);
+        used += 1;
+    }
+    if let Some(color) = last
+        && used < N
+    {
+        colors[used..].fill(color);
+    }
+    colors
 }
 
 macro_rules! visuals {
@@ -131,10 +153,10 @@ visuals! {
         oscilloscope::OscilloscopeProcessor, OscilloscopeConfig, OscilloscopeState;
         settings_cfg::OscilloscopeSettings;
         apply(p, s, set) { visuals!(@apply_config p, set); let reset = [set.channel_1, set.channel_2] == [Channel::None; 2];
-            let mut st = s.borrow_mut(); st.update_view_settings(set.persistence, reset);
+            let mut st = s.borrow_mut(); st.update_view_settings(set.persistence, set.stacked, reset);
             visuals!(@apply_palette st, set, &palettes::oscilloscope::COLORS); };
         export(p, s) { let st = s.borrow(); let mut out = settings_cfg::OscilloscopeSettings::from_config(&p.config());
-            out.persistence = st.persistence;
+            out.persistence = st.persistence; out.stacked = st.stacked;
             out.palette = visuals!(@export_palette &st.colors, &palettes::oscilloscope::COLORS); out };
 
     Waveform(220.0, 220.0) =>
@@ -401,3 +423,23 @@ impl VisualManager {
 }
 
 pub(crate) type VisualManagerHandle = Shared<VisualManager>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn short_palettes_extend_with_last_stop() {
+        let a = Color::from_rgb8(1, 2, 3);
+        let b = Color::from_rgb8(4, 5, 6);
+        let palette = PaletteSettings {
+            stops: vec![a.into(), b.into()],
+            ..Default::default()
+        };
+
+        assert_eq!(
+            resolve_palette(Some(&palette), &[Color::BLACK; 4]),
+            [a, b, b, b]
+        );
+    }
+}