Rename "sv" to "cell"

Author: gridbugs

bevy/src/lib.rs

@@ -1,19 +1,19 @@
 use bevy::{input::keyboard::KeyboardInput, prelude::*, window::PrimaryWindow};
 use caw_computer_keyboard::Keyboard;
-use caw_core::{Sig, SigVar, sig_var};
+use caw_core::{Sig, Variable, variable};
 
 #[derive(Resource, Clone)]
 pub struct BevyInput {
-    pub mouse_x: Sig<SigVar<f32>>,
-    pub mouse_y: Sig<SigVar<f32>>,
-    pub keyboard: Keyboard<Sig<SigVar<bool>>>,
+    pub mouse_x: Sig<Variable<f32>>,
+    pub mouse_y: Sig<Variable<f32>>,
+    pub keyboard: Keyboard<Sig<Variable<bool>>>,
 }
 
 impl Default for BevyInput {
     fn default() -> Self {
-        let keyboard = Keyboard::new(|_| sig_var(false));
-        let mouse_x = sig_var(0.5);
-        let mouse_y = sig_var(0.5);
+        let keyboard = Keyboard::new(|_| variable(false));
+        let mouse_x = variable(0.5);
+        let mouse_y = variable(0.5);
         Self {
             keyboard,
             mouse_x,
@@ -88,7 +88,7 @@ fn get_key<K>(key_code: KeyCode, keyboard: &Keyboard<K>) -> Option<&K> {
 
 fn update_key_state(
     input: &KeyboardInput,
-    keyboard: &Keyboard<Sig<SigVar<bool>>>,
+    keyboard: &Keyboard<Sig<Variable<bool>>>,
 ) {
     get_key(input.key_code, keyboard)
         .iter()
@@ -104,8 +104,8 @@ fn update_key_state(
 
 fn update_mouse_position(
     window: &Window,
-    mouse_x: &Sig<SigVar<f32>>,
-    mouse_y: &Sig<SigVar<f32>>,
+    mouse_x: &Sig<Variable<f32>>,
+    mouse_y: &Sig<Variable<f32>>,
 ) {
     if let Some(position) = window.cursor_position() {
         let window_size = window.size();

caw/examples/live_example.rs

@@ -3,7 +3,7 @@ use std::thread;
 
 fn main() {
     env_logger::init();
-    let volume = sv_default();
+    let volume = cell_default();
     let out: LiveStereoOut = live_stereo_viz_udp(oscilloscope::Config {
         ..Default::default()
     })
@@ -14,16 +14,18 @@ fn main() {
         .axis_label_x("cutoff_hz")
         .axis_label_y("resonance")
         .build();
-    let cutoff_hz = sv(cutoff_hz);
-    let res = sv(res * 2.);
-    let clock = sv(periodic_trig_s(tempo_s.clone())
-        .build()
-        .viz_blink("clock".to_string(), Default::default()));
+    let cutoff_hz = cell(cutoff_hz);
+    let res = cell(res * 2.);
+    let clock = cell(
+        periodic_trig_s(tempo_s.clone())
+            .build()
+            .viz_blink("clock".to_string(), Default::default()),
+    );
     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 (drum_bits, drum_space) = num_keys_bits_7_with_space("drums").build();
-    let length = 8;
+    let length = 16;
     let drum_bits_loop = value_looper(drum_bits, clock.clone(), drum_space)
         .persist_with_name("drums")
         .length(length)

core/src/cell.rs

@@ -0,0 +1,198 @@
+use crate::{
+    sig::{
+        Buf, Sig, SigBoxed, SigCtx, SigSampleIntoBufT, SigShared, SigT,
+        sig_boxed, sig_shared,
+    },
+    stereo::{Channel, Stereo, StereoPair},
+};
+use std::sync::{Arc, RwLock};
+
+/// Private inner type of the `Cell_` type.
+struct Unshared<T: Clone> {
+    sig_boxed: Arc<RwLock<SigBoxed<T>>>,
+    buf: Vec<T>,
+}
+
+impl<T: Clone> Clone for Unshared<T> {
+    fn clone(&self) -> Self {
+        Self {
+            sig_boxed: Arc::clone(&self.sig_boxed),
+            buf: Vec::new(),
+        }
+    }
+}
+
+impl<T: Clone> Unshared<T> {
+    fn new<S>(sig: S) -> Self
+    where
+        S: SigT<Item = T> + Sync + Send + 'static,
+    {
+        Unshared {
+            sig_boxed: Arc::new(RwLock::new(sig_boxed(sig).0)),
+            buf: Vec::new(),
+        }
+    }
+
+    fn set<S>(&self, sig: S)
+    where
+        S: SigT<Item = T> + Sync + Send + 'static,
+    {
+        *self.sig_boxed.write().unwrap() = sig_boxed(sig).0;
+    }
+}
+
+impl<T: Clone> SigT for Unshared<T> {
+    type Item = T;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        let mut unlocked = self.sig_boxed.write().unwrap();
+        unlocked.sample_into_buf(ctx, &mut self.buf);
+        &self.buf
+    }
+}
+
+impl<T: Clone> SigSampleIntoBufT for Unshared<T> {
+    type Item = T;
+
+    fn sample_into_buf(&mut self, ctx: &SigCtx, buf: &mut Vec<Self::Item>) {
+        self.sig_boxed.write().unwrap().sample_into_buf(ctx, buf);
+    }
+
+    fn sample_into_slice(
+        &mut self,
+        ctx: &SigCtx,
+        stride: usize,
+        offset: usize,
+        out: &mut [Self::Item],
+    ) {
+        self.sig_boxed
+            .write()
+            .unwrap()
+            .sample_into_slice(ctx, stride, offset, out);
+    }
+}
+
+pub fn cell_<S>(sig: S) -> Sig<Cell_<S::Item>>
+where
+    S: SigT + Sync + Send + 'static,
+{
+    Sig(Cell_::new(sig))
+}
+
+#[derive(Clone)]
+pub struct Cell_<T: Clone>(Sig<SigShared<Unshared<T>>>);
+
+impl<T: Clone> SigT for Cell_<T> {
+    type Item = T;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        self.0.sample(ctx)
+    }
+}
+
+impl<T: Clone> Cell_<T> {
+    pub fn new<S>(sig: S) -> Self
+    where
+        S: SigT<Item = T> + Sync + Send + 'static,
+    {
+        Self(sig_shared(Unshared::new(sig)))
+    }
+
+    pub fn set<S>(&self, sig: S)
+    where
+        S: SigT<Item = T> + Sync + Send + 'static,
+    {
+        self.0.0.with_inner_mut(|unshared| unshared.set(sig));
+    }
+}
+
+impl<T: Clone> Sig<Cell_<T>> {
+    pub fn set<S>(&self, sig: S)
+    where
+        S: SigT<Item = T> + Sync + Send + 'static,
+    {
+        self.0.set(sig);
+    }
+}
+
+impl<T: Clone> SigSampleIntoBufT for Cell_<T> {
+    type Item = T;
+
+    fn sample_into_buf(&mut self, ctx: &SigCtx, buf: &mut Vec<Self::Item>) {
+        self.0.sample_into_buf(ctx, buf);
+    }
+
+    fn sample_into_slice(
+        &mut self,
+        ctx: &SigCtx,
+        stride: usize,
+        offset: usize,
+        out: &mut [Self::Item],
+    ) {
+        self.0.sample_into_slice(ctx, stride, offset, out);
+    }
+}
+
+/// A container for a signal yielding a type `T` whose contentents (a signal) can be changed to a
+/// different signal later. The type of the signal is erased (`T` is the type _yielded_ by the
+/// signal) so signals of different types may be placed into the same cell. Call its `set` method
+/// to update the signal contained in the cell.
+pub type Cell<T> = Sig<Cell_<T>>;
+pub type CellF32 = Cell<f32>;
+
+pub fn cell<T>(
+    initial_sig: impl SigT<Item = T> + Sync + Send + 'static,
+) -> Cell<T>
+where
+    T: Clone,
+{
+    cell_(initial_sig)
+}
+
+pub fn cell_f32(
+    initial_sig: impl SigT<Item = f32> + Sync + Send + 'static,
+) -> CellF32 {
+    cell_(initial_sig)
+}
+
+/// Create a new signal cell initialized with a constant signal yielding the default value of the
+/// type `T`.
+pub fn cell_default<T>() -> Cell<T>
+where
+    T: SigT<Item = T> + Clone + Default + Sync + Send + 'static,
+{
+    cell(T::default())
+}
+
+impl<T> Stereo<Cell<T>, Cell<T>>
+where
+    T: Clone,
+{
+    pub fn set<F, S>(&self, mut f: F)
+    where
+        S: SigT<Item = T> + Sync + Send + 'static,
+        F: FnMut() -> S,
+    {
+        self.as_ref().with(|s| s.set(f()));
+    }
+
+    pub fn set_channel<F, S>(&self, mut f: F)
+    where
+        S: SigT<Item = T> + Sync + Send + 'static,
+        F: FnMut(Channel) -> S,
+    {
+        self.as_ref().with_channel(|channel, s| s.set(f(channel)));
+    }
+}
+
+impl Stereo<Cell<f32>, Cell<f32>> {
+    pub fn with_volume<V>(self, volume: V) -> Self
+    where
+        V: SigT<Item = f32> + Sync + Send + 'static,
+    {
+        let out = StereoPair::new_fn(|| cell(0.));
+        let volume = sig_shared(volume);
+        self.set_channel(|channel| out.get(channel).clone() * volume.clone());
+        out
+    }
+}

core/src/lib.rs

@@ -3,65 +3,11 @@ mod sig;
 pub mod sig_ops;
 pub use sig::{
     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,
+    Sig, SigAbs, SigBoxed, SigConst, SigCtx, SigSampleIntoBufT, SigShared,
+    SigT, Triggerable, Variable, Zip, Zip3, Zip4, sig_boxed,
+    sig_option_first_some, sig_shared, variable,
 };
+pub mod cell;
+pub use cell::{Cell, CellF32, cell, cell_default, cell_f32};
 pub mod stereo;
 pub use stereo::{Channel, Stereo, StereoPair};
-
-pub type SV<T> = Sig<SigBoxedVar<T>>;
-pub type SVF32 = SV<f32>;
-
-pub fn sv<T>(initial_sig: impl SigT<Item = T> + Sync + Send + 'static) -> SV<T>
-where
-    T: Clone,
-{
-    sig_boxed_var(initial_sig)
-}
-
-pub fn svf32(
-    initial_sig: impl SigT<Item = f32> + Sync + Send + 'static,
-) -> SV<f32> {
-    sig_boxed_var(initial_sig)
-}
-
-pub fn sv_default<T>() -> SV<T>
-where
-    T: SigT<Item = T> + Clone + Default + Sync + Send + 'static,
-{
-    sv(T::default())
-}
-
-impl<T> Stereo<SV<T>, SV<T>>
-where
-    T: Clone,
-{
-    pub fn set<F, S>(&self, mut f: F)
-    where
-        S: SigT<Item = T> + Sync + Send + 'static,
-        F: FnMut() -> S,
-    {
-        self.as_ref().with(|s| s.set(f()));
-    }
-
-    pub fn set_channel<F, S>(&self, mut f: F)
-    where
-        S: SigT<Item = T> + Sync + Send + 'static,
-        F: FnMut(Channel) -> S,
-    {
-        self.as_ref().with_channel(|channel, s| s.set(f(channel)));
-    }
-}
-
-impl Stereo<SV<f32>, SV<f32>> {
-    pub fn with_volume<V>(self, volume: V) -> Self
-    where
-        V: SigT<Item = f32> + Sync + Send + 'static,
-    {
-        let out = StereoPair::new_fn(|| sv(0.));
-        let volume = sig_shared(volume);
-        self.set_channel(|channel| out.get(channel).clone() * volume.clone());
-        out
-    }
-}