Start providing Sig alternatives to FrameSig

Author: gridbugs

computer-keyboard/Cargo.toml

@@ -12,3 +12,4 @@ edition = "2021"
 [dependencies]
 caw_keyboard = { version = "0.3", path = "../keyboard" }
 caw_core = { version = "0.4", path = "../core" }
+itertools = "0.14"

computer-keyboard/src/lib.rs

@@ -1,5 +1,6 @@
-use caw_core::{FrameSig, FrameSigT};
+use caw_core::{Buf, FrameSig, FrameSigT, Sig, SigT};
 use caw_keyboard::{KeyEvent, KeyEvents, Note};
+use itertools::izip;
 
 #[derive(Debug, Clone, Copy)]
 pub enum Key {
@@ -313,6 +314,45 @@ fn opinionated_note_by_key(start_note: Note) -> Vec<(Key, Note)> {
         .collect::<Vec<_>>()
 }
 
+pub fn opinionated_key_events_<S>(
+    keyboard: &Keyboard<S>,
+    start_note: Note,
+) -> Sig<impl SigT<Item = KeyEvents>>
+where
+    S: SigT<Item = bool> + Clone,
+{
+    let note_by_key = opinionated_note_by_key(start_note);
+    let mut key_events_by_key = note_by_key
+        .into_iter()
+        .map(|(key, note)| {
+            let mut pressed_state = false;
+            Sig(keyboard.get(key)).map_mut(move |pressed| {
+                if pressed == pressed_state {
+                    None
+                } else {
+                    pressed_state = pressed;
+                    Some(KeyEvent {
+                        note,
+                        pressed,
+                        velocity_01: 1.0,
+                    })
+                }
+            })
+        })
+        .collect::<Vec<_>>();
+    Sig::from_buf_fn(move |ctx, buf: &mut Vec<KeyEvents>| {
+        buf.clear();
+        buf.resize_with(ctx.num_samples, KeyEvents::empty);
+        for key_events in &mut key_events_by_key {
+            for (out, key_event_opt) in
+                izip! { buf.iter_mut(), key_events.sample(ctx).iter() }
+            {
+                out.extend(key_event_opt);
+            }
+        }
+    })
+}
+
 pub fn opinionated_key_events<S>(
     keyboard: &Keyboard<S>,
     start_note: Note,
@@ -354,6 +394,18 @@ where
     })
 }
 
+impl<K> Keyboard<K>
+where
+    K: SigT<Item = bool> + Clone,
+{
+    pub fn opinionated_key_events_(
+        self,
+        start_note: Note,
+    ) -> Sig<impl SigT<Item = KeyEvents>> {
+        opinionated_key_events_(&self, start_note)
+    }
+}
+
 impl<K> Keyboard<K>
 where
     K: FrameSigT<Item = bool> + Clone,

core/src/lib.rs

@@ -8,8 +8,8 @@ pub use frame_sig::{
     FrameSigT, FrameSigVar, Triggerable,
 };
 pub use sig::{
-    sig_shared, Buf, ConstBuf, Filter, GateToTrigRisingEdge, Sig, SigAbs,
-    SigBoxed, SigCtx, SigSampleIntoBufT, SigShared, SigT,
+    sig_shared, sig_var, Buf, ConstBuf, Filter, GateToTrigRisingEdge, Sig,
+    SigAbs, SigBoxed, SigCtx, SigSampleIntoBufT, SigShared, SigT, SigVar,
 };
 pub mod stereo;
 pub use stereo::{Channel, Stereo, StereoPair};

core/src/sig.rs

@@ -840,7 +840,7 @@ where
 pub struct SigBufFn<F, T>
 where
     F: FnMut(&SigCtx, &mut Vec<T>),
-    T: Clone + Default,
+    T: Clone,
 {
     f: F,
     buf: Vec<T>,
@@ -849,12 +849,11 @@ where
 impl<F, T> SigT for SigBufFn<F, T>
 where
     F: FnMut(&SigCtx, &mut Vec<T>),
-    T: Clone + Default,
+    T: Clone,
 {
     type Item = T;
 
     fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
-        self.buf.resize_with(ctx.num_samples, Default::default);
         (self.f)(ctx, &mut self.buf);
         &self.buf
     }
@@ -863,9 +862,46 @@ where
 impl<F, T> Sig<SigBufFn<F, T>>
 where
     F: FnMut(&SigCtx, &mut Vec<T>),
-    T: Clone + Default,
+    T: Clone,
 {
     pub fn from_buf_fn(f: F) -> Self {
         Self(SigBufFn { f, buf: Vec::new() })
     }
 }
+
+#[derive(Default)]
+pub struct SigVar<T>(Arc<RwLock<T>>);
+
+impl<T> SigVar<T> {
+    pub fn new(value: T) -> Self {
+        Self(Arc::new(RwLock::new(value)))
+    }
+
+    pub fn set(&self, value: T) {
+        *self.0.write().unwrap() = value;
+    }
+}
+
+pub fn sig_var<T: Clone>(value: T) -> Sig<SigVar<T>> {
+    Sig(SigVar::new(value))
+}
+
+impl<T> Clone for SigVar<T> {
+    fn clone(&self) -> Self {
+        Self(Arc::clone(&self.0))
+    }
+}
+
+impl<T> SigT for SigVar<T>
+where
+    T: Clone,
+{
+    type Item = T;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        ConstBuf {
+            count: ctx.num_samples,
+            value: self.0.read().unwrap().clone(),
+        }
+    }
+}

interactive/examples/keyboard_and_mouse_interactive.rs

@@ -1,15 +1,23 @@
 use caw_core::*;
-use caw_interactive::{Input, MouseButton, Visualization, Window};
-use caw_keyboard::{IntoNoteFreqHz, KeyEventsT, MonoVoice, Note};
+use caw_interactive::{Input_, MouseButton, Visualization, Window};
+use caw_keyboard::{IntoNoteFreqHz_, KeyEventsT_, MonoVoice_, Note};
 use caw_modules::*;
 
-fn sig(input: Input, channel: Channel) -> Sig<impl SigT<Item = f32> + Send> {
-    let MonoVoice {
+fn sig(input: Input_, channel: Channel) -> Sig<impl SigT<Item = f32> + Send> {
+    let MonoVoice_ {
         note,
         key_down_gate,
         key_press_trig,
         ..
-    } = input.keyboard.opinionated_key_events(Note::B0).mono_voice();
+    } = input
+        .keyboard
+        .opinionated_key_events_(Note::B0)
+        .debug(|x| {
+            if !x.is_empty() {
+                //println!("{:?}", x);
+            }
+        })
+        .mono_voice();
     let key_press_trig = key_press_trig.shared();
     let key_down_gate = key_down_gate | input.mouse.button(MouseButton::Left);
     let env = adsr_linear_01(key_down_gate)
@@ -47,7 +55,7 @@ fn main() -> anyhow::Result<()> {
         .line_width(2)
         .scale(4.)
         .build();
-    let input = window.input();
+    let input = window.input_();
     window.play_stereo(
         Stereo::new_fn_channel(|channel| sig(input.clone(), channel)),
         Default::default(),

interactive/examples/keyboard_and_mouse_polyphonic_interactive.rs

@@ -1,17 +1,17 @@
 use caw_core::*;
-use caw_interactive::{Input, Visualization, Window};
-use caw_keyboard::{IntoNoteFreqHz, KeyEventsT, MonoVoice, Note};
+use caw_interactive::{Input_, Visualization, Window};
+use caw_keyboard::{IntoNoteFreqHz_, KeyEventsT_, MonoVoice_, Note};
 use caw_modules::*;
 
-fn sig(input: Input, ch: Channel) -> Sig<impl SigT<Item = f32> + Send> {
+fn sig(input: Input_, ch: Channel) -> Sig<impl SigT<Item = f32> + Send> {
     input
         .clone()
         .keyboard
-        .opinionated_key_events(Note::B2)
+        .opinionated_key_events_(Note::B2)
         .poly_voices(12)
         .into_iter()
         .map(
-            move |MonoVoice {
+            move |MonoVoice_ {
                       note,
                       key_down_gate,
                       key_press_trig,
@@ -64,7 +64,7 @@ fn main() -> anyhow::Result<()> {
         .scale(0.7)
         .stride(2)
         .build();
-    let input = window.input();
+    let input = window.input_();
     window.play_stereo(
         Stereo::new_fn_channel(|ch| sig(input.clone(), ch)),
         Default::default(),

interactive/examples/midi_file_interactive.rs

@@ -1,21 +1,21 @@
 use caw_core::*;
-use caw_interactive::{Input, MouseButton, Visualization, Window};
-use caw_keyboard::{IntoNoteFreqHz, KeyEventsT, MonoVoice};
+use caw_interactive::{Input_, MouseButton, Visualization, Window};
+use caw_keyboard::{IntoNoteFreqHz_, KeyEventsT_, MonoVoice_};
 use caw_midi_file::*;
 use caw_modules::*;
 use clap::Parser;
 
 fn sig(
-    input: Input,
-    midi_messages: FrameSig<impl FrameSigT<Item = MidiMessages>>,
+    input: Input_,
+    midi_messages: Sig<impl SigT<Item = MidiMessages>>,
     channel: Channel,
 ) -> Sig<impl SigT<Item = f32>> {
     midi_messages
         .key_events()
         .poly_voices(48)
         .into_iter()
         .map(
-            |MonoVoice {
+            |MonoVoice_ {
                  note,
                  key_down_gate,
                  key_press_trig,
@@ -56,14 +56,15 @@ fn main() -> anyhow::Result<()> {
     env_logger::init();
     let args = Args::parse();
     let midi_file = MidiFile::read(args.name)?;
-    let midi_messages = midi_file.track(0, 1.0)?.into_midi_messages(0).shared();
+    let midi_messages =
+        midi_file.track(0, 1.0)?.into_midi_messages_(0).shared();
     let window = Window::builder()
         .sane_default()
         .visualization(Visualization::StereoOscillographics)
         .line_width(2)
         .fade(true)
         .build();
-    let input = window.input();
+    let input = window.input_();
     window.play_stereo(
         Stereo::new_fn_channel(|channel| {
             sig(input.clone(), midi_messages.clone(), channel)

interactive/examples/midi_live_interactive_chorus.rs

@@ -1,26 +1,26 @@
 use caw_core::*;
 use caw_interactive::{Input, Visualization, Window};
-use caw_keyboard::{IntoNoteFreqHz, KeyEvents, KeyEventsT, MonoVoice, Note};
+use caw_keyboard::{IntoNoteFreqHz_, KeyEvents, KeyEventsT_, MonoVoice_, Note};
 use caw_midi::*;
 use caw_midi_live::*;
 use caw_modules::*;
 use clap::{Parser, Subcommand};
 
 fn sig(
     input: Input,
-    key_events: FrameSig<impl FrameSigT<Item = KeyEvents>>,
-    _pitch_bend_freq_mult: FrameSig<FrameSigShared<impl FrameSigT<Item = f32>>>,
-    controllers: MidiControllers<impl FrameSigT<Item = MidiMessages>>,
+    key_events: Sig<impl SigT<Item = KeyEvents>>,
+    _pitch_bend_freq_mult: Sig<SigShared<impl SigT<Item = f32>>>,
+    controllers: MidiControllers_<impl SigT<Item = MidiMessages>>,
     channel: Channel,
 ) -> Sig<impl SigT<Item = f32>> {
     input
         .keyboard
-        .opinionated_key_events(Note::B0)
-        .merge(FrameSig(key_events))
+        .opinionated_key_events_(Note::B0)
+        .merge(Sig(key_events))
         .poly_voices(48)
         .into_iter()
         .map(
-            |MonoVoice {
+            |MonoVoice_ {
                  note,
                  key_down_gate,
                  key_press_trig,
@@ -86,9 +86,7 @@ enum Commands {
     },
 }
 
-fn run(
-    midi_events: FrameSig<impl FrameSigT<Item = MidiMessages>>,
-) -> anyhow::Result<()> {
+fn run(midi_events: Sig<impl SigT<Item = MidiMessages>>) -> anyhow::Result<()> {
     let window = Window::builder()
         .sane_default()
         .visualization(Visualization::StereoOscillographics)
@@ -127,7 +125,7 @@ fn main() -> anyhow::Result<()> {
         }
         Commands::Play { midi_port } => {
             let connection = midi_live.connect(midi_port)?;
-            run(connection.channel(0))?;
+            run(connection.channel_(0))?;
         }
     }
     Ok(())