ruffbox_synth 0.14.0

A beatbox-oriented synthesizer library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use crate::building_blocks::{
    EnvelopeSegmentInfo, Modulator, MonoEffect, MonoSource, SampleBuffer, SynthParameterLabel,
    SynthParameterValue, envelopes::source_env::MultiPointEnvelope,
};

/// more complex, configurable envelope
#[derive(Clone)]
pub struct MultiPointEffectEnvelope<const BUFSIZE: usize> {
    inner_env: MultiPointEnvelope<BUFSIZE>,
}

impl<const BUFSIZE: usize> MultiPointEffectEnvelope<BUFSIZE> {
    pub fn new(segment_infos: Vec<EnvelopeSegmentInfo>, loop_env: bool, samplerate: f32) -> Self {
        MultiPointEffectEnvelope {
            inner_env: MultiPointEnvelope::new(segment_infos, loop_env, samplerate),
        }
    }
    pub fn empty(samplerate: f32) -> Self {
        MultiPointEffectEnvelope {
            inner_env: MultiPointEnvelope::empty(samplerate),
        }
    }
}

impl<const BUFSIZE: usize> MonoEffect<BUFSIZE> for MultiPointEffectEnvelope<BUFSIZE> {
    fn finish(&mut self) {
        self.inner_env.finish();
    }

    fn is_finished(&self) -> bool {
        self.inner_env.is_finished()
    }

    fn set_modulator(
        &mut self,
        label: SynthParameterLabel,
        init: f32,
        modulator: Modulator<BUFSIZE>,
    ) {
        self.inner_env.set_modulator(label, init, modulator);
    }

    /// multi-point envelopes can only be set as a whole,
    /// the parameter is just passed on to the inner envelope ...
    fn set_parameter(&mut self, par: SynthParameterLabel, value: &SynthParameterValue) {
        self.inner_env.set_parameter(par, value);
    }

    fn process_block(
        &mut self,
        block: [f32; BUFSIZE],
        start_sample: usize,
        bufs: &[SampleBuffer],
    ) -> [f32; BUFSIZE] {
        let mut out: [f32; BUFSIZE] = [0.0; BUFSIZE];
        let env = self.inner_env.get_next_block(start_sample, bufs);
        for i in start_sample..BUFSIZE {
            out[i] = block[i] * env[i];
        }
        out
    }
}