Introduce the concept of graphical widgets

gridbugs · gridbugs · commit 37b6233a3851 · 2025-04-20T16:35:02.000+10:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,12 +11,16 @@ members = [
     "core",
     "interactive",
     "keyboard",
+    "midi",
     "midi-file",
     "midi-live",
     "midi-serial",
-    "midi",
+    "midi-udp",
+    "midi-udp-client",
+    "midi-udp-widgets-app",
     "modules",
     "patches",
     "player",
     "utils",
+    "widgets",
 ]
diff --git a/interactive/Cargo.toml b/interactive/Cargo.toml
@@ -28,6 +28,7 @@ caw_modules = { version = "0.4", path = "../modules" }
 caw_patches = { version = "0.4", path = "../patches" }
 caw_utils = { version = "0.4", path = "../utils" }
 caw_audio_file = { version = "0.4", path = "../audio-file" }
+caw_widgets = { version = "0.1", path = "../widgets" }
 env_logger = "0.11"
 rand = "0.8"
 wide = "0.7"
diff --git a/interactive/src/window.rs b/interactive/src/window.rs
@@ -129,7 +129,7 @@ impl WindowBuilder {
             title: self.title.unwrap_or_else(|| "CAW Synthesizer".to_string()),
             width_px: self.width_px.unwrap_or(960),
             height_px: self.height_px.unwrap_or(720),
-            stable: self.stable.unwrap_or(false),
+            stable: self.stable.unwrap_or(true),
             stride: self.stride.unwrap_or(1),
             scale: self.scale.unwrap_or(1.0),
             spread: self.spread.unwrap_or(1),
diff --git a/midi-udp-client/Cargo.toml b/midi-udp-client/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "caw_midi_udp_client"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0"
+midly = "0.5"
+
+[dev-dependencies]
+env_logger = "0.11"
+clap = { version = "4", features = ["derive"] }
+
+[[example]]
+name = "midi_udp_client_controller"
diff --git a/midi-udp-client/examples/midi_udp_client_controller.rs b/midi-udp-client/examples/midi_udp_client_controller.rs
@@ -0,0 +1,27 @@
+use caw_midi_udp_client::{MidiEvent, MidiMessage, MidiUdpClient};
+use clap::Parser;
+
+#[derive(Parser, Debug)]
+struct Args {
+    #[arg(short, long)]
+    server: String,
+    #[arg(long, default_value_t = 0)]
+    channel: u8,
+    #[arg(short, long, default_value_t = 0)]
+    controller: u8,
+    #[arg(short, long)]
+    value: u8,
+}
+
+fn main() {
+    let args = Args::parse();
+    let client = MidiUdpClient::new(args.server).unwrap();
+    let midi_event = MidiEvent {
+        channel: args.channel.into(),
+        message: MidiMessage::Controller {
+            controller: args.controller.into(),
+            value: args.value.into(),
+        },
+    };
+    client.send(midi_event).unwrap();
+}
diff --git a/midi-udp-client/src/lib.rs b/midi-udp-client/src/lib.rs
@@ -0,0 +1,34 @@
+use midly::live::LiveEvent;
+pub use midly::{MidiMessage, num::u4};
+use std::net::{Ipv4Addr, ToSocketAddrs, UdpSocket};
+
+pub struct MidiUdpClient {
+    socket: UdpSocket,
+}
+
+pub struct MidiEvent {
+    pub channel: u4,
+    pub message: MidiMessage,
+}
+
+impl MidiUdpClient {
+    pub fn new<A: ToSocketAddrs>(addrs: A) -> anyhow::Result<Self> {
+        let socket = UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 0))?;
+        socket.connect(addrs)?;
+        Ok(Self { socket })
+    }
+
+    pub fn send(
+        &self,
+        MidiEvent { channel, message }: MidiEvent,
+    ) -> anyhow::Result<()> {
+        let event = LiveEvent::Midi { channel, message };
+        let mut buf = Vec::new();
+        match event.write_std(&mut buf) {
+            Ok(()) => (),
+            Err(e) => anyhow::bail!("{e}"),
+        }
+        self.socket.send(&buf)?;
+        Ok(())
+    }
+}
diff --git a/midi-udp-widgets-app/Cargo.toml b/midi-udp-widgets-app/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "caw_midi_udp_widgets_app"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+caw_widgets = { version = "0.1", path = "../widgets" }
+caw_midi_udp_client = { version = "0.1", path = "../midi-udp-client" }
+clap = { version = "4", features = ["derive"] }
diff --git a/midi-udp-widgets-app/src/main.rs b/midi-udp-widgets-app/src/main.rs
@@ -0,0 +1,61 @@
+use caw_midi_udp_client::*;
+use caw_widgets::Knob;
+use clap::{Parser, Subcommand};
+
+#[derive(Subcommand)]
+enum Command {
+    Knob {
+        #[arg(short, long)]
+        server: String,
+        #[arg(long, default_value_t = 0)]
+        channel: u8,
+        #[arg(short, long, default_value_t = 0)]
+        controller: u8,
+        #[arg(short, long)]
+        title: Option<String>,
+        #[arg(short, long, default_value_t = 0.5)]
+        initial_value: f32,
+        #[arg(long, default_value_t = 0.2)]
+        sensitivity: f32,
+    },
+}
+
+#[derive(Parser)]
+#[command(name = "caw_midi_udp_widgets_app")]
+#[command(
+    about = "App for launching widgets that communicate with a caw synthesizer by sending midi commands over UDP"
+)]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+fn main() {
+    match Cli::parse().command {
+        Command::Knob {
+            server,
+            channel,
+            controller,
+            title,
+            initial_value,
+            sensitivity,
+        } => {
+            let client = MidiUdpClient::new(server).unwrap();
+            let title = title.unwrap_or_else(|| "".to_string());
+            let mut knob =
+                Knob::new(title.as_str(), initial_value, sensitivity).unwrap();
+            loop {
+                knob.tick().unwrap();
+                client
+                    .send(MidiEvent {
+                        channel: channel.into(),
+                        message: MidiMessage::Controller {
+                            controller: controller.into(),
+                            value: knob.value_midi(),
+                        },
+                    })
+                    .unwrap();
+            }
+        }
+    }
+}
diff --git a/midi-udp/Cargo.toml b/midi-udp/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "caw_midi_udp"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0"
+caw_core = { version = "0.5", path = "../core" }
+caw_midi = { version = "0.4", path = "../midi" }
+midly = "0.5"
+log = "0.4"
+
+[dev-dependencies]
+env_logger = "0.11"
+caw_interactive = { path = "../interactive" }
+caw_modules = { path = "../modules" }
+
+[[example]]
+name = "midi_udp_controller"
diff --git a/midi-udp/examples/midi_udp_controller.rs b/midi-udp/examples/midi_udp_controller.rs
@@ -0,0 +1,36 @@
+use caw_core::*;
+use caw_interactive::{Visualization, window::Window};
+use caw_midi::MidiMessagesT;
+use caw_midi_udp::MidiLiveUdp;
+use caw_modules::*;
+
+fn sig(
+    pitch_01: Sig<impl SigT<Item = f32>>,
+    filter_01: Sig<impl SigT<Item = f32>>,
+    resonance_01: Sig<impl SigT<Item = f32>>,
+) -> Sig<impl SigT<Item = f32>> {
+    super_saw(40.0 + (pitch_01 * 200.))
+        .build()
+        .filter(low_pass::default(10_000. * filter_01).q(resonance_01))
+        .filter(chorus())
+        .filter(reverb())
+}
+
+fn main() -> anyhow::Result<()> {
+    env_logger::init();
+    let window = Window::builder()
+        .visualization(Visualization::StereoOscillographics)
+        .build();
+    let midi_live = MidiLiveUdp::new("0.0.0.0:2000")?;
+    let controllers = midi_live.channel(0).controllers();
+    window.play_stereo(
+        Stereo::new_fn(|| {
+            sig(
+                controllers.get_01(0),
+                controllers.get_01(1),
+                controllers.get_01(2),
+            )
+        }),
+        Default::default(),
+    )
+}
diff --git a/midi-udp/src/lib.rs b/midi-udp/src/lib.rs
@@ -0,0 +1,96 @@
+use caw_core::{Sig, SigT};
+use caw_midi::MidiMessages;
+use midly::{MidiMessage, live::LiveEvent, num::u4};
+use std::{
+    io,
+    net::{ToSocketAddrs, UdpSocket},
+};
+
+const BUF_SIZE: usize = 256;
+
+struct MidiEvent {
+    channel: u4,
+    message: MidiMessage,
+}
+
+pub struct MidiLiveUdp {
+    socket: UdpSocket,
+    buf: Vec<u8>,
+}
+
+impl MidiLiveUdp {
+    pub fn new<A: ToSocketAddrs>(addrs: A) -> anyhow::Result<Self> {
+        let socket = UdpSocket::bind(addrs)?;
+        socket.set_nonblocking(true)?;
+        let buf = vec![0; BUF_SIZE];
+        Ok(Self { socket, buf })
+    }
+
+    fn recv_into_buf(&mut self) -> Result<bool, io::Error> {
+        match self.socket.recv(&mut self.buf) {
+            Ok(size) => {
+                if size >= BUF_SIZE {
+                    log::warn!("UDP message too long for buffer!");
+                    Ok(false)
+                } else {
+                    Ok(true)
+                }
+            }
+            Err(error) => match error.kind() {
+                io::ErrorKind::WouldBlock => {
+                    // There is currently no datagram available.
+                    Ok(false)
+                }
+                _ => Err(error),
+            },
+        }
+    }
+
+    fn recv_midi_event(&mut self) -> Result<Option<MidiEvent>, io::Error> {
+        if self.recv_into_buf()? {
+            match LiveEvent::parse(&self.buf) {
+                Ok(LiveEvent::Midi { channel, message }) => {
+                    Ok(Some(MidiEvent { channel, message }))
+                }
+                Ok(_) => Ok(None),
+                Err(e) => {
+                    log::warn!("Failed to parse midi event: {e}");
+                    Ok(None)
+                }
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn channel(
+        mut self,
+        channel: u8,
+    ) -> Sig<impl SigT<Item = MidiMessages>> {
+        Sig::from_buf_fn(move |ctx, buf: &mut Vec<MidiMessages>| {
+            // This is called once per frame (not once per sample). This will add an imperceptible
+            // amount of latency (unless the output buffer is too large!), but reduce cpu usage.
+            buf.resize_with(ctx.num_samples, Default::default);
+            let mut midi_messages = MidiMessages::empty();
+            loop {
+                match self.recv_midi_event() {
+                    Err(e) => {
+                        log::warn!("IO error reading from UDP socket: {e}");
+                        break;
+                    }
+                    Ok(None) => break,
+                    Ok(Some(MidiEvent {
+                        channel: message_channel,
+                        message,
+                    })) => {
+                        if message_channel == channel {
+                            midi_messages.push(message);
+                        }
+                    }
+                }
+            }
+            // Only the first sample of each frame is populated with midi messages.
+            buf[0] = midi_messages;
+        })
+    }
+}
diff --git a/midi/src/lib.rs b/midi/src/lib.rs
@@ -77,9 +77,13 @@ impl<M> MidiControllers<M>
 where
     M: SigT<Item = MidiMessages>,
 {
-    pub fn get_01(&self, index: u8) -> Sig<impl SigT<Item = f32>> {
+    pub fn get_with_initial_value_01(
+        &self,
+        index: u8,
+        initial_value: f32,
+    ) -> Sig<impl SigT<Item = f32>> {
         let index: u7 = index.into();
-        let mut state = 0.0;
+        let mut state = initial_value.clamp(0., 1.);
         self.messages.clone().map_mut(move |midi_messages| {
             for midi_message in midi_messages {
                 if let MidiMessage::Controller { controller, value } =
@@ -94,6 +98,10 @@ where
         })
     }
 
+    pub fn get_01(&self, index: u8) -> Sig<impl SigT<Item = f32>> {
+        self.get_with_initial_value_01(index, 0.0)
+    }
+
     pub fn volume(&self) -> Sig<impl SigT<Item = f32>> {
         self.get_01(7)
     }
diff --git a/widgets/Cargo.toml b/widgets/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "caw_widgets"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0"
+sdl2 = { version = "0.37", features = ["ttf"] }
+line_2d = "0.5"
+lazy_static = "1.5"
+midly = "0.5"
+
+[dev-dependencies]
+env_logger = "0.11"
+caw_midi_udp_client = { path = "../midi-udp-client" }
+clap = { version = "4", features = ["derive"] }
+
+[[example]]
+name = "knob_demo"
diff --git a/widgets/examples/knob_demo.rs b/widgets/examples/knob_demo.rs
diff --git a/widgets/src/inconsolata.regular.ttf b/widgets/src/inconsolata.regular.ttf
diff --git a/widgets/src/knob.rs b/widgets/src/knob.rs
diff --git a/widgets/src/lib.rs b/widgets/src/lib.rs
