Struct ParamBlock 

pub struct ParamBlock {
    pub params: [Param; 8],
    pub count: usize,
}

A fixed-size block of parameters for a node. Sized to fit common DSP nodes without heap allocation.

Fields

params: [Param; 8]

count: usize

Implementations

impl ParamBlock

pub fn new() -> ParamBlock

pub fn add(&mut self, value: f32) -> usize

pub fn get(&self, idx: usize) -> &Param

Examples found in repository

examples/simple_gain.rs (line 33)

    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 28)

    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 28)

    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();
        }
    }

pub fn get_mut(&mut self, idx: usize) -> &mut Param

pub fn tick_all(&mut self)

Tick all active params by one sample.

Examples found in repository

examples/simple_gain.rs (line 38)

    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 34)

    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 40)

    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();
        }
    }

Trait Implementations

impl Clone for ParamBlock

fn clone(&self) -> ParamBlock

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParamBlock

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for ParamBlock

fn default() -> ParamBlock

Returns the “default value” for a type.

impl Copy for ParamBlock