WIP

core/src/generation/parsed_to_render.rs

@@ -275,8 +275,9 @@ pub fn parsed_to_render(
             }
             #[cfg(feature = "app")]
             WavType::OggVorbis {
-                cli,
-                mut output_dir,
+                ..
+                //cli,
+                // mut output_dir,
             } => {
                 unimplemented!()
                 // let stereo_waveform = render(&basis, &nf, &mut parsed_composition.defs)?;

core/src/manager/render_manager.rs

@@ -136,6 +136,33 @@ impl RenderManager {
         }
     }
 
+    pub fn init_wasm_with_channel(
+        settings: Option<RenderManagerSettings>,
+        sender: Sender<bool>,
+    ) -> Self {
+        if !cfg!(test) {
+            if let Some(s) = settings {
+                Settings::init(s.sample_rate, s.buffer_size);
+            } else {
+                Settings::init_default();
+            };
+        }
+        Self {
+            visualization: Visualization {
+                channel: None,
+                normalizer: Normalizer::default(),
+            },
+            renders: [None, None],
+            past_volume: 0.8,
+            current_volume: 0.8,
+            render_idx: 0,
+            _read_idx: 0,
+            kill_channel: Some(sender),
+            once: false,
+            paused: false,
+        }
+    }
+
     pub fn play(&mut self) {
         self.paused = false;
     }
@@ -145,7 +172,8 @@ impl RenderManager {
     }
 
     pub fn update_volume(&mut self, volume: f32) {
-        self.current_volume = f32::powf(volume, 2.0)
+        // self.current_volume = f32::powf(volume, 2.0)
+        self.current_volume = volume;
     }
 
     fn ramp_to_current_volume(&mut self, buffer_size: usize) -> Vec<f32> {
@@ -319,7 +347,10 @@ mod render_manager_tests {
     }
 
     fn render_voices_mock() -> Vec<RenderVoice> {
-        vec![RenderVoice::init(&[RenderOp::init_silent_with_length(1.0)])]
+        vec![RenderVoice::init(
+            &[RenderOp::init_silent_with_length(1.0)],
+            false,
+        )]
     }
 
     #[test]

instrument/src/lib.rs

@@ -17,7 +17,9 @@ mod test;
 
 pub use self::{
     oscillator::{Basis, Oscillator},
-    renderable::render_voice::{renderables_to_render_voices, RenderVoice},
+    renderable::render_voice::{
+        renderables_to_render_voices, renderables_to_render_voices_loopable, RenderVoice,
+    },
     renderable::RenderOp,
     stereo_waveform::{Normalize, StereoWaveform},
 };

instrument/src/renderable/mod.rs

@@ -397,6 +397,32 @@ pub fn nf_to_vec_renderable(
     Ok(result)
 }
 
+pub fn nf_to_vec_renderable_loopable(
+    composition: &NormalForm,
+    defs: &mut Defs<Term>,
+    basis: &Basis,
+    looped: bool,
+) -> Result<Vec<Vec<RenderOp>>, Error> {
+    let mut normal_form = NormalForm::init();
+    composition.apply_to_normal_form(&mut normal_form, defs)?;
+
+    #[cfg(feature = "app")]
+    let iter = normal_form.operations.par_iter();
+    #[cfg(feature = "wasm")]
+    let iter = normal_form.operations.iter();
+
+    let settings = Settings::global();
+
+    let result: Vec<Vec<RenderOp>> = iter
+        .enumerate()
+        .map(|(voice, vec_point_op)| {
+            create_render_ops(voice, vec_point_op, basis, settings.sample_rate, !looped)
+        })
+        .collect();
+
+    Ok(result)
+}
+
 fn create_render_ops(
     voice: usize,
     vec_point_op: &[PointOp],

instrument/src/renderable/render_voice.rs

@@ -2,23 +2,24 @@ use crate::renderable::{Offset, RenderOp, Renderable};
 use crate::{Oscillator, StereoWaveform};
 #[cfg(feature = "app")]
 use rayon::prelude::*;
-use weresocool_shared::Settings;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct RenderVoice {
     pub sample_index: usize,
     pub op_index: usize,
     pub ops: Vec<RenderOp>,
     pub oscillator: Oscillator,
+    pub looped: bool,
 }
 
 impl RenderVoice {
-    pub fn init(ops: &[RenderOp]) -> Self {
+    pub fn init(ops: &[RenderOp], looped: bool) -> Self {
         Self {
             sample_index: 0,
             op_index: 0,
             ops: ops.to_owned(),
             oscillator: Oscillator::init(),
+            looped,
         }
     }
 
@@ -35,7 +36,7 @@ impl RenderVoice {
     ) -> Option<Vec<RenderOp>> {
         let mut result = result.unwrap_or_default();
 
-        if Settings::global().loop_play && self.op_index >= self.ops.len() {
+        if self.looped && self.op_index >= self.ops.len() {
             self.op_index = 0;
         }
 
@@ -96,6 +97,18 @@ pub fn renderables_to_render_voices(renderables: Vec<Vec<RenderOp>>) -> Vec<Rend
     let iter = renderables.par_iter();
     #[cfg(feature = "wasm")]
     let iter = renderables.iter();
-    iter.map(|voice| RenderVoice::init(voice))
+    iter.map(|voice| RenderVoice::init(voice, false))
+        .collect::<Vec<RenderVoice>>()
+}
+
+pub fn renderables_to_render_voices_loopable(
+    renderables: Vec<Vec<RenderOp>>,
+    looped: bool,
+) -> Vec<RenderVoice> {
+    #[cfg(feature = "app")]
+    let iter = renderables.par_iter();
+    #[cfg(feature = "wasm")]
+    let iter = renderables.iter();
+    iter.map(|voice| RenderVoice::init(voice, looped))
         .collect::<Vec<RenderVoice>>()
 }

parser/Cargo.toml

@@ -9,15 +9,15 @@ license = "GPL-3.0"
 resolver="2"
 
 [build-dependencies.lalrpop]
-version = "0.19.12"
+version = "0.20.0"
 features = ["lexer"]
 
 [dependencies]
 weresocool_ast = { path = "../ast", version = "^1.0.47", default_features=false, optional=true }
 weresocool_error = { path = "../error", version = "^1.0.47", default_features=false, optional=true }
 weresocool_shared = { path = "../shared", version = "^1.0.47" }
 scop = { path = "../scop", version = "^1.0.47" }
-lalrpop-util = { version="0.19.12", features=["lexer"]}
+lalrpop-util = { version="0.20.0", features=["lexer"]}
 regex = "1.5.4"
 colored = "2.0.0"
 num-rational = "0.4.1"