Add space inputs to some widgets

Author: gridbugs

caw/examples/live_example.rs

@@ -9,8 +9,8 @@ fn main() {
     })
     .with_volume(volume.clone());
     volume.set(knob("volume").initial_value_01(0.5).build());
-    let tempo_s = sv(knob("tempo s").build() * 0.5);
-    let (cutoff_hz, res) = xy("lpf")
+    let tempo_s = knob("tempo s").build();
+    let (cutoff_hz, res, lpf_space) = xy_with_space("lpf")
         .axis_label_x("cutoff_hz")
         .axis_label_y("resonance")
         .build();
@@ -19,36 +19,40 @@ fn main() {
     let clock = sv(periodic_trig_s(tempo_s.clone())
         .build()
         .viz_blink("clock".to_string(), Default::default()));
-    let ck = computer_keyboard("keys").start_note(note::B_0).build_();
-    let space_button = ck.space_button().shared();
-    let key_events = ck.key_events().shared();
+    let keyboard = computer_keyboard("keys").start_note(note::B_1).build_();
+    let space_button = keyboard.space_button().shared();
+    let key_events = keyboard.key_events().shared();
+    let length = 16;
     out.set_channel(|channel| {
         let voice = key_events.clone().mono_voice();
         let (note, gate) = key_looper(
             voice.gated_note(),
             clock.clone(),
             space_button.clone(),
-            8,
+            length,
         )
         .ungated();
+        let cutoff_hz = value_looper(
+            cutoff_hz.clone(),
+            clock.clone(),
+            lpf_space.clone(),
+            length,
+        );
         let env = adsr(gate)
             .key_press_trig(clock.clone())
-            .a(tempo_s.clone() / 24.)
-            .r(tempo_s.clone() / 2.)
-            .s(0.25)
-            .d(tempo_s.clone() / 2.)
+            .a(tempo_s.clone() * knob("attack").build())
+            .r(tempo_s.clone() * knob("release").build())
+            .s(knob("sustain").build())
+            .d(tempo_s.clone() * knob("decay").build())
             .build()
             .exp_01(1.)
             .shared();
-        let voice = (super_saw(note.freq_hz()).build() * env.clone())
-            .filter(
-                low_pass::default(
-                    10. + (env.clone() * cutoff_hz.clone() * 15000.),
-                )
+        let voice = (super_saw(note.freq_hz()).build() * env.clone()).filter(
+            low_pass::default(10. + (env.clone() * cutoff_hz * 15000.))
                 .q(res.clone()),
-            )
-            .viz_oscilloscope_stereo("voice", channel, Default::default());
+        );
         voice
+            .viz_oscilloscope_stereo("voice", channel, Default::default())
             .filter(
                 chorus()
                     .lfo_rate_hz(0.1)

core/src/lib.rs

@@ -2,10 +2,10 @@ mod arith;
 mod sig;
 pub mod sig_ops;
 pub use sig::{
-    Buf, Const, ConstBuf, Filter, GateToTrigRisingEdge, Sig, SigAbs, SigBoxed,
-    SigBoxedVar, SigConst, SigCtx, SigSampleIntoBufT, SigShared, SigT, SigVar,
-    Triggerable, Zip, Zip3, Zip4, sig_boxed, sig_boxed_var,
-    sig_option_first_some, sig_shared, sig_var,
+    Buf, Const, ConstBuf, Filter, GateToTrigRisingEdge, IsNegative, IsPositive,
+    Sig, SigAbs, SigBoxed, SigBoxedVar, SigConst, SigCtx, SigSampleIntoBufT,
+    SigShared, SigT, SigVar, Triggerable, Zip, Zip3, Zip4, sig_boxed,
+    sig_boxed_var, sig_option_first_some, sig_shared, sig_var,
 };
 pub mod stereo;
 pub use stereo::{Channel, Stereo, StereoPair};

core/src/sig.rs

@@ -824,12 +824,12 @@ where
         Sig(SigAbs(self.0))
     }
 
-    pub fn is_positive(self) -> Sig<impl SigT<Item = bool>> {
-        self.map(|x| x > 0.0)
+    pub fn is_positive(self) -> Sig<IsPositive<S>> {
+        Sig(IsPositive(self.0))
     }
 
-    pub fn is_negative(self) -> Sig<impl SigT<Item = bool>> {
-        self.map(|x| x < 0.0)
+    pub fn is_negative(self) -> Sig<IsNegative<S>> {
+        Sig(IsNegative(self.0))
     }
 }
 
@@ -959,6 +959,13 @@ where
             ret
         })
     }
+
+    pub fn or<O>(self, other: O) -> Sig<impl SigT<Item = bool>>
+    where
+        O: SigT<Item = bool>,
+    {
+        self.zip(other).map(|(s, o)| s || o)
+    }
 }
 
 /// A counting gate, which is a gate which implements a counter each time it transitions to "on".
@@ -1336,6 +1343,36 @@ where
     }
 }
 
+pub struct IsPositive<S>(S)
+where
+    S: SigT<Item = f32>;
+
+impl<S> SigT for IsPositive<S>
+where
+    S: SigT<Item = f32>,
+{
+    type Item = bool;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        MapBuf::new(self.0.sample(ctx), |x| x > 0.0)
+    }
+}
+
+pub struct IsNegative<S>(S)
+where
+    S: SigT<Item = f32>;
+
+impl<S> SigT for IsNegative<S>
+where
+    S: SigT<Item = f32>,
+{
+    type Item = bool;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        MapBuf::new(self.0.sample(ctx), |x| x < 0.0)
+    }
+}
+
 /// For signals yielding `f32`, this trait provides a general way of defining filters.
 pub trait Filter {
     /// The type of the item of the input signal to this filter.

midi-udp-widgets-app-lib/examples/midi_udp_widgets_app_lib_demo.rs

@@ -8,7 +8,7 @@ fn sig() -> Sig<impl SigT<Item = f32>> {
         adsr_linear_01(button("env gate").build().gate_to_trig_rising_edge())
             .release_s(0.5)
             .build();
-    let (chorus_depth_01, chorus_lfo_rate_01) = xy("chorus").build().unzip();
+    let (chorus_depth_01, chorus_lfo_rate_01) = xy("chorus").build();
     super_saw(60.)
         .build()
         .filter(

midi-udp-widgets-app-lib/src/knob.rs

@@ -2,27 +2,33 @@ use crate::{
     midi,
     widget::{ByTitle, MidiController01Udp, Widget},
 };
-use caw_core::{Sig, SigShared};
+use caw_core::{IsPositive, Sig, SigShared};
 use caw_midi::MidiMessagesT;
 use lazy_static::lazy_static;
 
+pub type KnobWithSpace = (
+    Sig<SigShared<MidiController01Udp>>,
+    Sig<SigShared<IsPositive<MidiController01Udp>>>,
+);
+
 lazy_static! {
     // Used to prevent multiple windows from opening at the same time with the same name. Note that
     // when using with evcxr this seems to get cleared when a cell is recomputed, but this is still
     // valuable in the context of stereo signals, where a function is evaluated once for the left
     // channel and once for the right channel. In such a case, this prevents each knob openned by
     // that function from being openned twice.
-    static ref BY_TITLE: ByTitle<Sig<SigShared<MidiController01Udp>>> = Default::default();
+    static ref BY_TITLE: ByTitle<KnobWithSpace> = Default::default();
 }
 
-fn new_knob(
+fn new_knob_with_space(
     title: String,
     initial_value_01: f32,
     sensitivity: f32,
-) -> Sig<SigShared<MidiController01Udp>> {
+) -> KnobWithSpace {
     BY_TITLE.get_or_insert(title.as_str(), || {
         let channel = midi::alloc_channel();
         let controller = midi::alloc_controller(channel);
+        let space_controller = midi::alloc_controller(channel);
         let widget = Widget::new(
             title.clone(),
             channel,
@@ -31,18 +37,31 @@ fn new_knob(
                 format!("--controller={}", controller),
                 format!("--initial-value={}", initial_value_01),
                 format!("--sensitivity={}", sensitivity),
+                format!("--space-controller={}", space_controller),
             ],
         )
         .unwrap();
-        widget
-            .channel()
-            .controllers()
+        let controllers = widget.channel().controllers();
+        let value = controllers
             .get_with_initial_value_01(controller.into(), initial_value_01)
-            .shared()
+            .shared();
+        let space = controllers
+            .get_with_initial_value_01(space_controller.into(), 0.0)
+            .is_positive()
+            .shared();
+        (value, space)
     })
 }
 
-mod knob_builder {
+fn new_knob(
+    title: String,
+    initial_value_01: f32,
+    sensitivity: f32,
+) -> Sig<SigShared<MidiController01Udp>> {
+    new_knob_with_space(title, initial_value_01, sensitivity).0
+}
+
+mod builder {
     use super::*;
     use caw_builder_proc_macros::builder;
     use caw_core::{Sig, SigShared};
@@ -53,7 +72,7 @@ mod knob_builder {
         #[generic_setter_type_name = "X"]
         #[build_fn = "new_knob"]
         #[build_ty = "Sig<SigShared<MidiController01Udp>>"]
-        pub struct Props {
+        pub struct KnobProps {
             title: String,
             #[default = 0.5]
             initial_value_01: f32,
@@ -62,9 +81,28 @@ mod knob_builder {
         }
     }
 
-    pub fn knob(title: impl Into<String>) -> Props {
+    pub fn knob(title: impl Into<String>) -> KnobProps {
         knob_(title.into())
     }
+
+    builder! {
+        #[constructor = "knob_with_space_"]
+        #[constructor_doc = "A visual knob in a new window"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "new_knob_with_space"]
+        #[build_ty = "KnobWithSpace"]
+        pub struct KnobWithSpaceProps {
+            title: String,
+            #[default = 0.5]
+            initial_value_01: f32,
+            #[default = 0.2]
+            sensitivity: f32,
+        }
+    }
+
+    pub fn knob_with_space(title: impl Into<String>) -> KnobWithSpaceProps {
+        knob_with_space_(title.into())
+    }
 }
 
-pub use knob_builder::knob;
+pub use builder::{knob, knob_with_space};

midi-udp-widgets-app-lib/src/lib.rs

@@ -2,10 +2,10 @@ pub mod button;
 pub use button::button;
 
 pub mod knob;
-pub use knob::knob;
+pub use knob::{knob, knob_with_space};
 
 pub mod xy;
-pub use xy::xy;
+pub use xy::{xy, xy_with_space};
 
 pub mod computer_keyboard;
 pub use computer_keyboard::computer_keyboard;