Struct ParamBlock 

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

A fixed-size block of parameters for a node.

Stores up to 8 parameters without heap allocation. Most DSP nodes need 1-4 parameters (gain, frequency, resonance, etc.), so 8 is sufficient for the vast majority of cases.

Example

use aether_core::param::ParamBlock;

let mut params = ParamBlock::new();

// Add parameters
let gain_idx = params.add(0.75);      // Gain: 0.75
let cutoff_idx = params.add(1000.0);  // Cutoff: 1000 Hz
let res_idx = params.add(0.5);        // Resonance: 0.5

assert_eq!(params.count, 3);

// Access parameters
let gain = params.get(gain_idx);
assert_eq!(gain.current, 0.75);

// Modify parameters
params.get_mut(cutoff_idx).set_target(2000.0, 480);

// Tick all parameters
params.tick_all();

Capacity

If you need more than 8 parameters, consider:

• Splitting into multiple nodes
• Using a custom parameter storage system
• Increasing the array size (requires modifying the constant)

See Also

• Param - Individual parameter

Fields

params: [Param; 8]

count: usize

Implementations

impl ParamBlock

pub fn new() -> Self

Creates a new empty parameter block.

Initializes with zero parameters. Use add to add parameters.

Example

use aether_core::param::ParamBlock;

let params = ParamBlock::new();
assert_eq!(params.count, 0);

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

Adds a parameter with the given initial value.

Arguments

• value - Initial parameter value

Returns

The parameter’s index (0-7), used to access it later.

Panics

Panics if the block is full (8 parameters already added).

Example

use aether_core::param::ParamBlock;

let mut params = ParamBlock::new();

let gain_idx = params.add(0.5);
let freq_idx = params.add(440.0);

assert_eq!(gain_idx, 0);
assert_eq!(freq_idx, 1);
assert_eq!(params.count, 2);

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

Gets an immutable reference to a parameter.

Arguments

• idx - Parameter index (0-7)

Returns

Reference to the parameter.

Panics

Panics if idx is out of bounds.

Example

use aether_core::param::ParamBlock;

let mut params = ParamBlock::new();
let gain_idx = params.add(0.75);

let gain = params.get(gain_idx);
assert_eq!(gain.current, 0.75);

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

Gets a mutable reference to a parameter.

Arguments

• idx - Parameter index (0-7)

Returns

Mutable reference to the parameter.

Panics

Panics if idx is out of bounds.

Example

use aether_core::param::ParamBlock;

let mut params = ParamBlock::new();
let cutoff_idx = params.add(1000.0);

// Schedule a ramp
params.get_mut(cutoff_idx).set_target(2000.0, 480);

pub fn tick_all(&mut self)

Tick all active params by one sample.

Advances all parameters in the block by one sample. Call this once per sample in your node’s process() function.

Example

use aether_core::param::ParamBlock;
use aether_core::BUFFER_SIZE;

let mut params = ParamBlock::new();
let gain_idx = params.add(0.0);
params.get_mut(gain_idx).set_target(1.0, BUFFER_SIZE as u32);

// Tick through buffer
for _ in 0..BUFFER_SIZE {
    let gain_value = params.get(gain_idx).current;
    // Use gain_value for processing...
    params.tick_all();
}

assert_eq!(params.get(gain_idx).current, 1.0);

Performance

This function is highly optimized:

• Inlined for zero call overhead
• Only ticks active parameters (count)
• Each tick is branch-free when not ramping

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

Formats the value using the given formatter.

impl Default for ParamBlock

fn default() -> Self

Returns the “default value” for a type.

impl Copy for ParamBlock