summaryrefslogtreecommitdiff
path: root/src/synth
diff options
context:
space:
mode:
Diffstat (limited to 'src/synth')
-rw-r--r--src/synth/logic.rs19
-rw-r--r--src/synth/math.rs60
-rw-r--r--src/synth/mod.rs202
-rw-r--r--src/synth/noise.rs27
-rw-r--r--src/synth/param.rs15
-rw-r--r--src/synth/rel.rs62
-rw-r--r--src/synth/saw.rs15
-rw-r--r--src/synth/sine.rs15
-rw-r--r--src/synth/square.rs15
-rw-r--r--src/synth/triangle.rs15
10 files changed, 441 insertions, 4 deletions
diff --git a/src/synth/logic.rs b/src/synth/logic.rs
index 5071d95..672cc78 100644
--- a/src/synth/logic.rs
+++ b/src/synth/logic.rs
@@ -15,11 +15,11 @@ impl Generator for IfElse {
let iftrue_buf = self.iftrue.eval(params);
let iffalse_buf = self.iffalse.eval(params);
- if (
+ if
cond_buf.rate == Rate::Control &&
iftrue_buf.rate == Rate::Control &&
iffalse_buf.rate == Rate::Control
- ) {
+ {
self.buf.set(if cond_buf.first() >= 0.5 {
iftrue_buf.first()
} else {
@@ -57,7 +57,22 @@ impl Generator for IfElse {
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct IfElseFactory;
+
+impl GeneratorFactory for IfElseFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ let cond = params.remove_param("cond", 0)?.as_gen()?;
+ let iftrue = params.remove_param("iftrue", 1)?.as_gen()?;
+ let iffalse = params.remove_param("iffalse", 2)?.as_gen()?;
+ let buf = SampleBuffer::new(cmp::max(cmp::max(cond.buffer().len(), iftrue.buffer().len()), iffalse.buffer().len()));
+ Ok(Box::new(IfElse { cond: cond, iftrue: iftrue, iffalse: iffalse, buf: buf }))
+ }
+}
+
+pub static Factory: IfElseFactory = IfElseFactory;
diff --git a/src/synth/math.rs b/src/synth/math.rs
index 8adad4b..eb1a604 100644
--- a/src/synth/math.rs
+++ b/src/synth/math.rs
@@ -20,11 +20,25 @@ impl Generator for Add {
}
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+pub struct AddFactory;
+
+impl GeneratorFactory for AddFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ Ok(Box::new(Add {
+ terms: params.get_pos_params().into_iter().map(|x| x.as_gen()).collect::<Result<Vec<_>, _>>()?,
+ buf: SampleBuffer::new(params.env.default_buffer_size),
+ }))
+ }
+}
+
+pub static FactoryAdd: AddFactory = AddFactory;
+
#[derive(Debug)]
pub struct Mul {
pub factors: Vec<GenBox>,
@@ -44,11 +58,25 @@ impl Generator for Mul {
}
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+pub struct MulFactory;
+
+impl GeneratorFactory for MulFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ Ok(Box::new(Mul {
+ factors: params.get_pos_params().into_iter().map(|x| x.as_gen()).collect::<Result<Vec<_>, _>>()?,
+ buf: SampleBuffer::new(params.env.default_buffer_size),
+ }))
+ }
+}
+
+pub static FactoryMul: MulFactory = MulFactory;
+
#[derive(Debug)]
pub struct Negate {
pub value: GenBox,
@@ -70,11 +98,27 @@ impl Generator for Negate {
}
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+pub struct NegateFactory;
+
+impl GeneratorFactory for NegateFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ let mut gen = params.remove_param("value", 0)?.as_gen()?;
+ let len = gen.buffer().len();
+ Ok(Box::new(Negate {
+ value: gen,
+ buf: SampleBuffer::new(len),
+ }))
+ }
+}
+
+pub static FactoryNegate: NegateFactory = NegateFactory;
+
#[derive(Debug)]
pub struct Reciprocate {
pub value: GenBox,
@@ -96,7 +140,23 @@ impl Generator for Reciprocate {
}
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct ReciprocateFactory;
+
+impl GeneratorFactory for ReciprocateFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ let mut gen = params.remove_param("value", 0)?.as_gen()?;
+ let len = gen.buffer().len();
+ Ok(Box::new(Reciprocate {
+ value: gen,
+ buf: SampleBuffer::new(len),
+ }))
+ }
+}
+
+pub static FactoryReciprocate: ReciprocateFactory = ReciprocateFactory;
diff --git a/src/synth/mod.rs b/src/synth/mod.rs
index 4f23a01..b22e162 100644
--- a/src/synth/mod.rs
+++ b/src/synth/mod.rs
@@ -1,5 +1,6 @@
-use std::{iter, cmp, slice, mem};
+use std::{iter, cmp, slice, mem, fmt};
use std::fmt::Debug;
+use std::error::Error;
use std::ops::{Index, IndexMut};
use std::collections::HashMap;
use super::*;
@@ -154,11 +155,191 @@ impl IndexMut<usize> for SampleBuffer {
pub trait Generator : Debug {
fn eval<'a>(&'a mut self, params: &Parameters) -> &'a SampleBuffer;
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer;
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer;
}
pub type GenBox = Box<Generator>;
+#[derive(Debug)]
+pub enum GenFactoryError {
+ MissingRequiredParam(String, usize),
+ CannotConvert(ParamKind, ParamKind),
+ BadType(ParamKind),
+}
+
+#[derive(Debug)]
+pub struct GenFactoryErrorType {
+ pub kind: GenFactoryError,
+ desc: String
+}
+
+impl GenFactoryErrorType {
+ pub fn new(kind: GenFactoryError) -> GenFactoryErrorType {
+ let mut ret = GenFactoryErrorType {
+ kind: kind,
+ desc: "".to_string(),
+ };
+
+ ret.desc = match &ret.kind {
+ &GenFactoryError::MissingRequiredParam(ref name, pos) => format!("Needed a parameter named {} or at pos {}", name, pos),
+ &GenFactoryError::CannotConvert(from, to) => format!("Cannot convert {:?} to {:?}", from, to),
+ &GenFactoryError::BadType(ty) => format!("Bad parameter type {:?}", ty),
+ };
+
+ ret
+ }
+
+ pub fn with_description(kind: GenFactoryError, desc: String) -> GenFactoryErrorType {
+ GenFactoryErrorType {
+ kind: kind,
+ desc: desc,
+ }
+ }
+}
+
+impl From<GenFactoryError> for GenFactoryErrorType {
+ fn from(e: GenFactoryError) -> GenFactoryErrorType {
+ GenFactoryErrorType::new(e)
+ }
+}
+
+impl Error for GenFactoryErrorType {
+ fn description<'a>(&'a self) -> &'a str {
+ &self.desc
+ }
+}
+
+impl fmt::Display for GenFactoryErrorType {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "{}", self.description())
+ }
+}
+
+impl Into<Box<Error>> for GenFactoryError {
+ fn into(self) -> Box<Error> {
+ Box::new(GenFactoryErrorType::new(self))
+ }
+}
+
+#[derive(Debug,PartialEq,Eq,Clone,Copy)]
+pub enum ParamKind {
+ Integer,
+ Float,
+ String,
+ Generator,
+}
+
+pub enum ParamValue {
+ Integer(isize),
+ Float(f32),
+ String(String),
+ Generator(GenBox),
+}
+
+impl ParamValue {
+ pub fn kind(&self) -> ParamKind {
+ match *self {
+ ParamValue::Integer(_) => ParamKind::Integer,
+ ParamValue::Float(_) => ParamKind::Float,
+ ParamValue::String(_) => ParamKind::String,
+ ParamValue::Generator(_) => ParamKind::Generator,
+ }
+ }
+
+ pub fn as_isize(&self) -> Result<isize, GenFactoryError> {
+ match *self {
+ ParamValue::Integer(v) => Ok(v),
+ ParamValue::Float(v) => Ok(v as isize),
+ ParamValue::String(ref v) => v.parse().map_err(|_| GenFactoryError::CannotConvert(ParamKind::String, ParamKind::Integer)),
+ ParamValue::Generator(_) => Err(GenFactoryError::CannotConvert(ParamKind::Generator, ParamKind::Integer)),
+ }
+ }
+
+ pub fn as_f32(&self) -> Result<f32, GenFactoryError> {
+ match *self {
+ ParamValue::Integer(v) => Ok(v as f32),
+ ParamValue::Float(v) => Ok(v),
+ ParamValue::String(ref v) => v.parse().map_err(|_| GenFactoryError::CannotConvert(ParamKind::String, ParamKind::Float)),
+ ParamValue::Generator(_) => Err(GenFactoryError::CannotConvert(ParamKind::Generator, ParamKind::Float)),
+ }
+ }
+
+ pub fn as_string(&self) -> Result<String, GenFactoryError> {
+ match *self {
+ ParamValue::Integer(v) => Ok(v.to_string()),
+ ParamValue::Float(v) => Ok(v.to_string()),
+ ParamValue::String(ref v) => Ok(v.clone()),
+ ParamValue::Generator(_) => Err(GenFactoryError::CannotConvert(ParamKind::Generator, ParamKind::String)),
+ }
+ }
+
+ pub fn as_gen(self) -> Result<GenBox, GenFactoryError> {
+ match self {
+ ParamValue::Integer(v) => Ok(Box::new(self::param::Param { name : "_".to_string(), default: v as f32, buf: SampleBuffer::new(1) })),
+ ParamValue::Float(v) => Ok(Box::new(self::param::Param { name : "_".to_string(), default: v, buf: SampleBuffer::new(1) })),
+ ParamValue::String(_) => Err(GenFactoryError::CannotConvert(ParamKind::String, ParamKind::Generator)),
+ ParamValue::Generator(g) => Ok(g),
+ }
+ }
+}
+
+impl<'a> From<&'a ParamValue> for ParamKind {
+ fn from(val: &'a ParamValue) -> ParamKind {
+ val.kind()
+ }
+}
+
+#[derive(Default)]
+pub struct FactoryParameters {
+ pub env: Environment,
+ pub vars: HashMap<String, ParamValue>,
+}
+
+impl FactoryParameters {
+ pub fn get_param<'a, 'b : 'a>(&'a self, name: &str, position: usize, default: &'b ParamValue) -> &'a ParamValue {
+ (
+ self.vars.get(name).or_else(||
+ self.vars.get(&position.to_string()).or(Some(default))
+ )
+ ).unwrap()
+ }
+
+ pub fn get_req_param(&self, name: &str, position: usize) -> Result<&ParamValue, GenFactoryError> {
+ match self.vars.get(name).or_else(|| self.vars.get(&position.to_string())) {
+ Some(v) => Ok(v),
+ None => Err(GenFactoryError::MissingRequiredParam(name.to_string(), position)),
+ }
+ }
+
+ pub fn remove_param(&mut self, name: &str, position: usize) -> Result<ParamValue, GenFactoryError> {
+ match self.vars.remove(name).or_else(|| self.vars.remove(&position.to_string())) {
+ Some(v) => Ok(v),
+ None => Err(GenFactoryError::MissingRequiredParam(name.to_string(), position)),
+ }
+ }
+
+ pub fn get_pos_params(&mut self) -> Vec<ParamValue> {
+ let mut ret = Vec::new();
+
+ for i in 0.. {
+ match self.vars.remove(&i.to_string()) {
+ Some(v) => ret.push(v),
+ None => return ret,
+ }
+ }
+
+ unreachable!()
+ }
+}
+
+pub trait GeneratorFactory {
+ // NB: Like above, &self is for object safety. This should have an associated type, but that
+ // would compromise object safety; for the same reason, the return of this may only be a
+ // Box<Generator>, which necessitates allocation.
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError>;
+}
+
pub mod param;
pub use self::param::Param;
pub mod math;
@@ -179,3 +360,22 @@ pub mod noise;
pub use self::noise::Noise;
//pub mod adsr;
//pub use self::adsr::ADSR;
+
+pub fn all_factories() -> HashMap<String, &'static GeneratorFactory> {
+ let mut ret = HashMap::new();
+
+ ret.insert("param".to_string(), &self::param::Factory as &GeneratorFactory);
+ ret.insert("add".to_string(), &self::math::FactoryAdd as &GeneratorFactory);
+ ret.insert("mul".to_string(), &self::math::FactoryMul as &GeneratorFactory);
+ ret.insert("negate".to_string(), &self::math::FactoryNegate as &GeneratorFactory);
+ ret.insert("reciprocate".to_string(), &self::math::FactoryReciprocate as &GeneratorFactory);
+ ret.insert("rel".to_string(), &self::rel::Factory as &GeneratorFactory);
+ ret.insert("ifelse".to_string(), &self::logic::Factory as &GeneratorFactory);
+ ret.insert("sine".to_string(), &self::sine::Factory as &GeneratorFactory);
+ ret.insert("saw".to_string(), &self::saw::Factory as &GeneratorFactory);
+ ret.insert("triangle".to_string(), &self::triangle::Factory as &GeneratorFactory);
+ ret.insert("square".to_string(), &self::square::Factory as &GeneratorFactory);
+ ret.insert("noise".to_string(), &self::noise::Factory as &GeneratorFactory);
+
+ ret
+}
diff --git a/src/synth/noise.rs b/src/synth/noise.rs
index 4d90f3b..68c120f 100644
--- a/src/synth/noise.rs
+++ b/src/synth/noise.rs
@@ -1,7 +1,8 @@
use std::mem;
use super::*;
-use ::rand::{XorShiftRng, Rng};
+use ::rand::{XorShiftRng, Rng, SeedableRng};
+use ::rand::os::OsRng;
#[derive(Debug)]
pub struct Noise {
@@ -19,8 +20,32 @@ impl Generator for Noise {
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+static mut _rand_gen: Option<OsRng> = None;
+
+pub struct NoiseFactory;
+
+impl GeneratorFactory for NoiseFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ if unsafe { &_rand_gen }.is_none() {
+ unsafe {_rand_gen = Some(OsRng::new().expect("Couldn't initialize OS random")); }
+ }
+
+ let mut seed: [u32; 4] = Default::default();
+ for i in seed.iter_mut() {
+ *i = unsafe { &mut _rand_gen }.as_mut().unwrap().next_u32();
+ }
+
+ Ok(Box::new(Noise {
+ rng: XorShiftRng::from_seed(seed),
+ buf: SampleBuffer::new(params.env.default_buffer_size),
+ }))
+ }
+}
+
+pub static Factory: NoiseFactory = NoiseFactory;
diff --git a/src/synth/param.rs b/src/synth/param.rs
index f679b56..859f789 100644
--- a/src/synth/param.rs
+++ b/src/synth/param.rs
@@ -12,7 +12,22 @@ impl Generator for Param {
self.buf.set(*params.vars.get(&self.name).unwrap_or(&self.default));
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct ParamFactory;
+
+impl GeneratorFactory for ParamFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ Ok(Box::new(Param {
+ name: params.get_req_param("name", 0)?.as_string()?,
+ default: params.get_param("default", 1, &ParamValue::Float(0.0)).as_f32()?,
+ buf: SampleBuffer::new(1),
+ }))
+ }
+}
+
+pub static Factory: ParamFactory = ParamFactory;
diff --git a/src/synth/rel.rs b/src/synth/rel.rs
index 76b6c04..bb3cf1f 100644
--- a/src/synth/rel.rs
+++ b/src/synth/rel.rs
@@ -11,6 +11,39 @@ pub enum RelOp {
Less,
}
+/* TODO
+impl<T: PartialEq<isize>> From<T> for RelOp {
+ fn from(i: T) -> RelOp {
+ match i {
+ 0 => RelOp::Greater,
+ 1 => RelOp::GreaterEqual,
+ _ => RelOp::Equal,
+ 3 => RelOp::NotEqual,
+ 4 => RelOp::LessEqual,
+ 5 => RelOp::Less,
+ }
+ }
+}
+*/
+
+impl<'a> From<&'a str> for RelOp {
+ fn from(s: &'a str) -> RelOp {
+ if s == ">" {
+ RelOp::Greater
+ } else if s == ">=" {
+ RelOp::GreaterEqual
+ } else if s == "!=" {
+ RelOp::NotEqual
+ } else if s == "<=" {
+ RelOp::LessEqual
+ } else if s == "<" {
+ RelOp::Less
+ } else {
+ RelOp::Equal
+ }
+ }
+}
+
#[derive(Debug)]
pub struct Rel {
pub left: GenBox,
@@ -72,7 +105,36 @@ impl Generator for Rel {
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct RelFactory;
+
+impl GeneratorFactory for RelFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ let op = match params.get_req_param("rel", 1)? {
+ /* TODO
+ &ParamValue::Integer(v) => v.into(),
+ &ParamValue::Float(v) => (v as isize).into(),
+ */
+ &ParamValue::Integer(_) => return Err(GenFactoryError::BadType(ParamKind::Integer)),
+ &ParamValue::Float(_) => return Err(GenFactoryError::BadType(ParamKind::Float)),
+ &ParamValue::String(ref v) => (&*v as &str).into(),
+ &ParamValue::Generator(_) => return Err(GenFactoryError::BadType(ParamKind::Generator)),
+ };
+ let left = params.remove_param("left", 0)?.as_gen()?;
+ let right = params.remove_param("right", 2)?.as_gen()?;
+ let buf = SampleBuffer::new(cmp::max(left.buffer().len(), right.buffer().len()));
+ Ok(Box::new(Rel {
+ left: left,
+ right: right,
+ op: op,
+ buf: buf,
+ }))
+ }
+}
+
+pub static Factory: RelFactory = RelFactory;
diff --git a/src/synth/saw.rs b/src/synth/saw.rs
index bfd3cb0..b85794d 100644
--- a/src/synth/saw.rs
+++ b/src/synth/saw.rs
@@ -19,7 +19,22 @@ impl Generator for Saw {
self.phase = (self.phase + pvel * (self.buf.len() as f32)) % 1.0;
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct SawFactory;
+
+impl GeneratorFactory for SawFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ Ok(Box::new(Saw {
+ freq: params.remove_param("freq", 0)?.as_gen()?,
+ phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+ buf: SampleBuffer::new(params.env.default_buffer_size),
+ }))
+ }
+}
+
+pub static Factory: SawFactory = SawFactory;
diff --git a/src/synth/sine.rs b/src/synth/sine.rs
index 90f3200..918261c 100644
--- a/src/synth/sine.rs
+++ b/src/synth/sine.rs
@@ -22,7 +22,22 @@ impl Generator for Sine {
self.phase = (self.phase + pvel * (self.buf.len() as f32)) % TAU;
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct SineFactory;
+
+impl GeneratorFactory for SineFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ Ok(Box::new(Sine {
+ freq: params.remove_param("freq", 0)?.as_gen()?,
+ phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+ buf: SampleBuffer::new(params.env.default_buffer_size),
+ }))
+ }
+}
+
+pub static Factory: SineFactory = SineFactory;
diff --git a/src/synth/square.rs b/src/synth/square.rs
index 8197110..d207562 100644
--- a/src/synth/square.rs
+++ b/src/synth/square.rs
@@ -23,7 +23,22 @@ impl Generator for Square {
self.phase = (self.phase + pvel * (self.buf.len() as f32)) % 1.0;
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct SquareFactory;
+
+impl GeneratorFactory for SquareFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ Ok(Box::new(Square {
+ freq: params.remove_param("freq", 0)?.as_gen()?,
+ phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+ buf: SampleBuffer::new(params.env.default_buffer_size),
+ }))
+ }
+}
+
+pub static Factory: SquareFactory = SquareFactory;
diff --git a/src/synth/triangle.rs b/src/synth/triangle.rs
index 5c0c69a..4f62e4c 100644
--- a/src/synth/triangle.rs
+++ b/src/synth/triangle.rs
@@ -27,7 +27,22 @@ impl Generator for Triangle {
self.phase = (self.phase + pvel * (self.buf.len() as f32)) % 1.0;
&self.buf
}
+ fn buffer<'a>(&'a self) -> &'a SampleBuffer { &self.buf }
fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
mem::replace(&mut self.buf, buf)
}
}
+
+pub struct TriangleFactory;
+
+impl GeneratorFactory for TriangleFactory {
+ fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+ Ok(Box::new(Triangle {
+ freq: params.remove_param("freq", 0)?.as_gen()?,
+ phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+ buf: SampleBuffer::new(params.env.default_buffer_size),
+ }))
+ }
+}
+
+pub static Factory: TriangleFactory = TriangleFactory;
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-04-05 11:59:42 +0000