Struct NodeInputs 

pub struct NodeInputs<'a> {
    pub raw: &'a [Option<&'a [f32; 64]>; 8],
}

Ergonomic wrapper around the raw input buffer array.

Fields

raw: &'a [Option<&'a [f32; 64]>; 8]

Implementations

impl<'a> NodeInputs<'a>

pub fn get(&self, slot: usize) -> &[f32; 64]

Examples found in repository

examples/simple_gain.rs (line 30)

    fn process(
        &mut self,
        inputs: &NodeInputs,
        output: &mut NodeOutput,
        params: &mut ParamBlock,
        _sample_rate: f32,
    ) {
        // Get input buffer (or silence if not connected)
        let input = inputs.get(0);

        // Get current gain value (smoothed automatically)
        let gain = params.get(0).current;

        // Process each sample
        for (i, out) in output.iter_mut().enumerate() {
            *out = input[i] * gain;
            params.tick_all(); // Advance parameter smoothing
        }
    }

examples/tremolo.rs (line 26)

    fn process(
        &mut self,
        inputs: &NodeInputs,
        output: &mut NodeOutput,
        params: &mut ParamBlock,
        sample_rate: f32,
    ) {
        let input = inputs.get(0);
        for (i, out) in output.iter_mut().enumerate() {
            let rate  = params.get(0).current;
            let depth = params.get(1).current;
            // LFO: 1.0 at phase=0, dips to (1-depth) at phase=0.5
            let lfo = 1.0 - depth * 0.5 * (1.0 - (self.phase * std::f32::consts::TAU).cos());
            *out = input[i] * lfo;
            self.phase = (self.phase + rate / sample_rate).fract();
            params.tick_all();
        }
    }

examples/bitcrusher.rs (line 26)

    fn process(
        &mut self,
        inputs: &NodeInputs,
        output: &mut NodeOutput,
        params: &mut ParamBlock,
        _sample_rate: f32,
    ) {
        let input = inputs.get(0);
        for (i, out) in output.iter_mut().enumerate() {
            let bits  = params.get(0).current.clamp(1.0, 16.0);
            let crush = params.get(1).current.clamp(1.0, 32.0);

            // Sample-rate reduction
            self.counter += 1.0;
            if self.counter >= crush {
                self.counter = 0.0;
                // Bit quantization
                let levels = (2.0f32).powf(bits);
                self.held_sample = (input[i] * levels).round() / levels;
            }
            *out = self.held_sample;
            params.tick_all();
        }
    }