@devaloop/devalang 0.0.1-alpha.14 → 0.0.1-alpha.16

package/rust/core/audio/mod.rs

@@ -1,6 +1,7 @@
-pub mod engine;
-pub mod interpreter;
-pub mod loader;
-pub mod player;
-pub mod renderer;
-pub mod evaluator;
+pub mod engine;
+pub mod evaluator;
+pub mod interpreter;
+pub mod loader;
+pub mod player;
+pub mod renderer;
+pub mod special;

package/rust/core/audio/player.rs

@@ -1,64 +1,64 @@
-use rodio::{ Decoder, OutputStream, OutputStreamHandle, Sink, Source };
-use std::{ fs::File, io::BufReader };
-
-pub struct AudioPlayer {
-    _stream: OutputStream,
-    handle: OutputStreamHandle,
-    sink: Sink,
-    last_path: Option<String>,
-}
-
-impl AudioPlayer {
-    pub fn new() -> Self {
-        let (stream, handle) = OutputStream::try_default().unwrap();
-        let sink = Sink::try_new(&handle).unwrap();
-
-        Self {
-            _stream: stream,
-            handle,
-            sink,
-            last_path: None,
-        }
-    }
-
-    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
-        if let Ok(file) = File::open(path) {
-            let reader = BufReader::new(file);
-            match Decoder::new(reader) {
-                Ok(decoder) => Some(decoder.convert_samples()),
-                Err(e) => {
-                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
-                    None
-                }
-            }
-        } else {
-            eprintln!("❌ Could not open audio file: {}", path);
-            None
-        }
-    }
-
-    pub fn play_file_once(&mut self, path: &str) {
-        self.sink.stop();
-        self.sink = Sink::try_new(&self.handle).unwrap();
-        self.sink.set_volume(1.0);
-
-        if let Some(source) = self.load_source(path) {
-            self.sink.append(source);
-            self.last_path = Some(path.to_string());
-        } else {
-            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
-        }
-    }
-
-    pub fn replay_last(&mut self) {
-        if let Some(path) = self.last_path.clone() {
-            self.play_file_once(&path);
-        } else {
-            eprintln!("⚠️ No previous audio to replay.");
-        }
-    }
-
-    pub fn wait_until_end(&self) {
-        self.sink.sleep_until_end();
-    }
-}
+use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
+use std::{fs::File, io::BufReader};
+
+pub struct AudioPlayer {
+    _stream: OutputStream,
+    handle: OutputStreamHandle,
+    sink: Sink,
+    last_path: Option<String>,
+}
+
+impl AudioPlayer {
+    pub fn new() -> Self {
+        let (stream, handle) = OutputStream::try_default().unwrap();
+        let sink = Sink::try_new(&handle).unwrap();
+
+        Self {
+            _stream: stream,
+            handle,
+            sink,
+            last_path: None,
+        }
+    }
+
+    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
+        if let Ok(file) = File::open(path) {
+            let reader = BufReader::new(file);
+            match Decoder::new(reader) {
+                Ok(decoder) => Some(decoder.convert_samples()),
+                Err(e) => {
+                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
+                    None
+                }
+            }
+        } else {
+            eprintln!("❌ Could not open audio file: {}", path);
+            None
+        }
+    }
+
+    pub fn play_file_once(&mut self, path: &str) {
+        self.sink.stop();
+        self.sink = Sink::try_new(&self.handle).unwrap();
+        self.sink.set_volume(1.0);
+
+        if let Some(source) = self.load_source(path) {
+            self.sink.append(source);
+            self.last_path = Some(path.to_string());
+        } else {
+            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
+        }
+    }
+
+    pub fn replay_last(&mut self) {
+        if let Some(path) = self.last_path.clone() {
+            self.play_file_once(&path);
+        } else {
+            eprintln!("⚠️ No previous audio to replay.");
+        }
+    }
+
+    pub fn wait_until_end(&self) {
+        self.sink.sleep_until_end();
+    }
+}

package/rust/core/audio/renderer.rs

@@ -1,53 +1,56 @@
-use std::collections::HashMap;
-use crate::{
-    core::{
-        audio::{ engine::AudioEngine, interpreter::driver::run_audio_program },
-        parser::statement::Statement,
-        store::global::GlobalStore,
-    },
-    utils::logger::{ LogLevel, Logger },
-};
-
-pub fn render_audio_with_modules(
-    modules: HashMap<String, Vec<Statement>>,
-    output_dir: &str,
-    global_store: &mut GlobalStore
-) -> HashMap<String, AudioEngine> {
-    let mut result = HashMap::new();
-
-    for (module_name, statements) in modules {
-        let mut global_max_end_time: f32 = 0.0;
-        let mut audio_engine = AudioEngine::new(module_name.clone());
-
-        // Apply global variables to the initial engine
-        if let Some(module) = global_store.get_module(&module_name) {
-            // interprete statements to fill the audio buffer
-            let (module_max_end_time, cursor_time) = run_audio_program(
-                &statements,
-                &mut audio_engine,
-                module_name.clone(),
-                output_dir.to_string(),
-                module.variable_table.clone(),
-                module.function_table.clone(),
-                global_store
-            );
-
-            // Verify if the buffer is silent (all samples are zero)
-            if audio_engine.buffer.iter().all(|&s| s == 0) {
-                let logger = Logger::new();
-                logger.log_message(
-                    LogLevel::Warning,
-                    &format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name)
-                );
-            }
-
-            // Determines the maximum end time for the module
-            global_max_end_time = global_max_end_time.max(module_max_end_time);
-            audio_engine.set_duration(global_max_end_time);
-
-            result.insert(module_name, audio_engine);
-        }
-    }
-
-    result
-}
+use crate::{
+    core::{
+        audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
+        parser::statement::Statement,
+        store::global::GlobalStore,
+    },
+    utils::logger::{LogLevel, Logger},
+};
+use std::collections::HashMap;
+
+pub fn render_audio_with_modules(
+    modules: HashMap<String, Vec<Statement>>,
+    output_dir: &str,
+    global_store: &mut GlobalStore,
+) -> HashMap<String, AudioEngine> {
+    let mut result = HashMap::new();
+
+    for (module_name, statements) in modules {
+        let mut global_max_end_time: f32 = 0.0;
+        let mut audio_engine = AudioEngine::new(module_name.clone());
+
+        // Apply global variables to the initial engine
+        if let Some(module) = global_store.get_module(&module_name) {
+            // interprete statements to fill the audio buffer
+            let (module_max_end_time, _cursor_time) = run_audio_program(
+                &statements,
+                &mut audio_engine,
+                module_name.clone(),
+                output_dir.to_string(),
+                module.variable_table.clone(),
+                module.function_table.clone(),
+                global_store,
+            );
+
+            // Verify if the buffer is silent (all samples are zero)
+            if audio_engine.buffer.iter().all(|&s| s == 0) {
+                let logger = Logger::new();
+                logger.log_message(
+                    LogLevel::Warning,
+                    &format!(
+                        "Module '{}' ignored: silent buffer (no non-zero samples)",
+                        module_name
+                    ),
+                );
+            }
+
+            // Determines the maximum end time for the module
+            global_max_end_time = global_max_end_time.max(module_max_end_time);
+            audio_engine.set_duration(global_max_end_time);
+
+            result.insert(module_name, audio_engine);
+        }
+    }
+
+    result
+}

package/rust/core/audio/special/easing.rs

@@ -0,0 +1,189 @@
+use crate::core::store::variable::VariableTable;
+
+// Basic easing functions operating on t in [0,1]
+fn easing_value(func: &str, t: f32) -> Option<f32> {
+    let x = t.clamp(0.0, 1.0);
+    match func {
+        "linear" => Some(x),
+        "easeInQuad" => Some(x * x),
+        "easeOutQuad" => Some(x * (2.0 - x)),
+        "easeInOutQuad" => {
+            if x < 0.5 {
+                Some(2.0 * x * x)
+            } else {
+                Some(-1.0 + (4.0 - 2.0 * x) * x)
+            }
+        }
+        // Cubic
+        "easeInCubic" => Some(x * x * x),
+        "easeOutCubic" => Some(1.0 - (1.0 - x).powi(3)),
+        "easeInOutCubic" => {
+            if x < 0.5 {
+                Some(4.0 * x * x * x)
+            } else {
+                Some(1.0 - (-2.0 * x + 2.0).powi(3) / 2.0)
+            }
+        }
+        // Quartic
+        "easeInQuart" => Some(x.powi(4)),
+        "easeOutQuart" => Some(1.0 - (1.0 - x).powi(4)),
+        "easeInOutQuart" => {
+            if x < 0.5 {
+                Some(8.0 * x.powi(4))
+            } else {
+                Some(1.0 - (-2.0 * x + 2.0).powi(4) / 2.0)
+            }
+        }
+        // Exponential
+        "easeInExpo" => Some(if x <= 0.0 {
+            0.0
+        } else {
+            2.0_f32.powf(10.0 * x - 10.0)
+        }),
+        "easeOutExpo" => Some(if x >= 1.0 {
+            1.0
+        } else {
+            1.0 - 2.0_f32.powf(-10.0 * x)
+        }),
+        "easeInOutExpo" => Some(if x <= 0.0 {
+            0.0
+        } else if x >= 1.0 {
+            1.0
+        } else if x < 0.5 {
+            2.0_f32.powf(20.0 * x - 10.0) / 2.0
+        } else {
+            (2.0 - 2.0_f32.powf(-20.0 * x + 10.0)) / 2.0
+        }),
+        // Back (overshoot c ~ 1.70158)
+        "easeInBack" => {
+            let c = 1.70158;
+            Some((c + 1.0) * x * x * x - c * x * x)
+        }
+        "easeOutBack" => {
+            let c = 1.70158;
+            let y = 1.0 - x;
+            Some(1.0 - ((c + 1.0) * y * y * y - c * y * y))
+        }
+        "easeInOutBack" => {
+            let c1 = 1.70158;
+            let c2 = c1 * 1.525;
+            let x2 = x * 2.0;
+            if x2 < 1.0 {
+                Some((x2 * x2 * ((c2 + 1.0) * x2 - c2)) / 2.0)
+            } else {
+                let x2 = x2 - 2.0;
+                Some((x2 * x2 * ((c2 + 1.0) * x2 + c2)) / 2.0 + 1.0)
+            }
+        }
+        // Elastic
+        "easeInElastic" => {
+            if x == 0.0 {
+                Some(0.0)
+            } else if x == 1.0 {
+                Some(1.0)
+            } else {
+                let c = 2.0 * std::f32::consts::PI / 3.0;
+                Some(-(2.0_f32.powf(10.0 * x - 10.0)) * ((x * 10.0 - 10.75) * c).sin())
+            }
+        }
+        "easeOutElastic" => {
+            if x == 0.0 {
+                Some(0.0)
+            } else if x == 1.0 {
+                Some(1.0)
+            } else {
+                let c = 2.0 * std::f32::consts::PI / 3.0;
+                Some(2.0_f32.powf(-10.0 * x) * ((x * 10.0 - 0.75) * c).sin() + 1.0)
+            }
+        }
+        "easeInOutElastic" => {
+            if x == 0.0 {
+                Some(0.0)
+            } else if x == 1.0 {
+                Some(1.0)
+            } else {
+                let c = 2.0 * std::f32::consts::PI / 4.5;
+                if x < 0.5 {
+                    Some(-(2.0_f32.powf(20.0 * x - 10.0)) * ((20.0 * x - 11.125) * c).sin() / 2.0)
+                } else {
+                    Some(
+                        2.0_f32.powf(-20.0 * x + 10.0) * ((20.0 * x - 11.125) * c).sin() / 2.0
+                            + 1.0,
+                    )
+                }
+            }
+        }
+        // Bounce helpers
+        "easeInBounce" => Some(1.0 - bounce_out(1.0 - x)),
+        "easeOutBounce" => Some(bounce_out(x)),
+        "easeInOutBounce" => Some(if x < 0.5 {
+            (1.0 - bounce_out(1.0 - 2.0 * x)) / 2.0
+        } else {
+            (1.0 + bounce_out(2.0 * x - 1.0)) / 2.0
+        }),
+        _ => None,
+    }
+}
+
+fn bounce_out(x: f32) -> f32 {
+    let n1 = 7.5625;
+    let d1 = 2.75;
+    if x < 1.0 / d1 {
+        n1 * x * x
+    } else if x < 2.0 / d1 {
+        let x = x - 1.5 / d1;
+        n1 * x * x + 0.75
+    } else if x < 2.5 / d1 {
+        let x = x - 2.25 / d1;
+        n1 * x * x + 0.9375
+    } else {
+        let x = x - 2.625 / d1;
+        n1 * x * x + 0.984375
+    }
+}
+
+// Find and evaluate the first $easing.<fn>(...) occurrence in the string.
+// Accepts a single argument expression producing t in [0,1].
+pub fn find_and_eval_first_easing_call<EvalFn>(
+    s: &str,
+    eval: EvalFn,
+    vars: &VariableTable,
+    bpm: f32,
+    beat: f32,
+) -> Option<String>
+where
+    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
+{
+    let start = s.find("$easing.")?;
+    let open_rel = s[start..].find('(')?;
+    let open = start + open_rel;
+    let func = &s[start + 9..open];
+
+    // Find matching close parenthesis
+    let mut depth: i32 = 0;
+    let mut close_abs: Option<usize> = None;
+    for (i, ch) in s[open..].char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth == 0 {
+                    close_abs = Some(open + i);
+                    break;
+                }
+            }
+            _ => {}
+        }
+    }
+    let close = close_abs?;
+
+    let inner = &s[open + 1..close];
+    let t = eval(inner, vars, bpm, beat)?;
+    let result = easing_value(func, t)?;
+
+    let mut replaced = String::new();
+    replaced.push_str(&s[..start]);
+    replaced.push_str(&result.to_string());
+    replaced.push_str(&s[close + 1..]);
+    Some(replaced)
+}

package/rust/core/audio/special/env.rs

@@ -0,0 +1,43 @@
+use crate::core::store::variable::VariableTable;
+use std::sync::OnceLock;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static SESSION_SEED: OnceLock<f32> = OnceLock::new();
+
+pub fn get_session_seed() -> f32 {
+    *SESSION_SEED.get_or_init(|| {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default();
+        // Build a stable 0..1 seed from nanos
+        let nanos = now.subsec_nanos();
+        ((nanos as f32) / 1_000_000_000.0).clamp(0.0, 1.0)
+    })
+}
+
+// Resolve special environment variables like $env.bpm, $env.beat, $env.position
+// For now, $env.position is treated as an alias of beat.
+pub fn resolve_env_atom(atom: &str, bpm: f32, beat: f32) -> Option<f32> {
+    match atom {
+        "$env.bpm" => Some(bpm),
+        "$env.beat" => Some(beat),
+        "$env.position" => Some(beat),
+        // Optional seed for deterministic randomness
+        "$env.seed" => Some(get_session_seed()),
+        _ => None,
+    }
+}
+
+// Utility: resolve an identifier or numeric literal to f32 using the variable table
+pub fn resolve_atom_or_var(atom: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+    if let Some(v) = resolve_env_atom(atom, bpm, beat) {
+        return Some(v);
+    }
+    if let Ok(n) = atom.parse::<f32>() {
+        return Some(n);
+    }
+    if let Some(crate::core::shared::value::Value::Number(n)) = vars.get(atom) {
+        return Some(*n);
+    }
+    None
+}

package/rust/core/audio/special/math.rs

@@ -0,0 +1,102 @@
+use crate::core::store::variable::VariableTable;
+
+// Parse comma-separated arguments at top level (no nested parentheses split)
+fn parse_top_level_args(s: &str) -> Vec<&str> {
+    let mut args = Vec::new();
+    let mut depth = 0i32;
+    let mut start = 0usize;
+    for (i, ch) in s.char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => depth -= 1,
+            ',' if depth == 0 => {
+                args.push(s[start..i].trim());
+                start = i + 1;
+            }
+            _ => {}
+        }
+    }
+    let last = s[start..].trim();
+    if !last.is_empty() {
+        args.push(last);
+    }
+    args
+}
+
+fn eval_math_func(func: &str, args: &[f32], fallback_seed: f32) -> Option<f32> {
+    match func {
+        "sin" => args.get(0).copied().map(f32::sin),
+        "cos" => args.get(0).copied().map(f32::cos),
+        "random" => {
+            // deterministic pseudo-random based on provided seed or a fallback session seed
+            let seed = args.get(0).copied().unwrap_or(fallback_seed);
+            let x = (seed * 12.9898).sin() * 43758.5453;
+            Some((x.fract() * 2.0 - 1.0).clamp(-1.0, 1.0))
+        }
+        "lerp" => {
+            if args.len() >= 3 {
+                Some(args[0] + (args[1] - args[0]) * args[2])
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+// Find and evaluate the first $math.<fn>(...) occurrence in the string, replacing it with a number.
+// Supports multi-argument functions by splitting on top-level commas.
+pub fn find_and_eval_first_math_call<EvalFn>(
+    s: &str,
+    eval: EvalFn,
+    vars: &VariableTable,
+    bpm: f32,
+    beat: f32,
+) -> Option<String>
+where
+    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
+{
+    let start = s.find("$math.")?;
+    let open_rel = s[start..].find('(')?;
+    let open = start + open_rel;
+    let func = &s[start + 6..open];
+
+    // Find matching close parenthesis, handling nesting
+    let mut depth: i32 = 0;
+    let mut close_abs: Option<usize> = None;
+    for (i, ch) in s[open..].char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth == 0 {
+                    close_abs = Some(open + i);
+                    break;
+                }
+            }
+            _ => {}
+        }
+    }
+    let close = close_abs?;
+
+    let inner = &s[open + 1..close];
+    let raw_args = parse_top_level_args(inner);
+    let mut args: Vec<f32> = Vec::with_capacity(raw_args.len());
+    for a in raw_args {
+        if let Some(v) = eval(a, vars, bpm, beat) {
+            args.push(v);
+        } else {
+            return None;
+        }
+    }
+
+    // If no explicit seed is provided, use $env.seed via fallback
+    let fallback_seed = eval("$env.seed", vars, bpm, beat).unwrap_or(0.0);
+    let result = eval_math_func(func, &args, fallback_seed)?;
+
+    let mut replaced = String::new();
+    replaced.push_str(&s[..start]);
+    replaced.push_str(&result.to_string());
+    replaced.push_str(&s[close + 1..]);
+    Some(replaced)
+}

package/rust/core/audio/special/mod.rs

@@ -0,0 +1,9 @@
+pub mod easing;
+pub mod env;
+pub mod math;
+pub mod modulator;
+
+pub use easing::find_and_eval_first_easing_call;
+pub use env::resolve_env_atom;
+pub use math::find_and_eval_first_math_call;
+pub use modulator::find_and_eval_first_mod_call;