parser appears to work (oh my)

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;