Struct LFO 

pub struct LFO<T: Transcendental> { /* private fields */ }

LFO (Low Frequency Oscillator)

Generates low-frequency signals for parameter modulation. Frequency range: 0.01 Hz - 100 Hz.

Operating modes

• Bipolar: output in range [-1, 1]
• Unipolar: output in range [0, 1]

Example

use rill_core::time::ClockTick;
use rill_core::traits::ActionContext;
use rill_core_dsp::generators::*;
use rill_core::traits::algorithm::Algorithm;

let tick = ClockTick::default();
let ctx = ActionContext::new(&tick);

// Create LFO for filter frequency modulation
let mut lfo = LFO::<f32>::new(
    5.0,              // 5 Hz
    Waveform::Sine,
    true              // bipolar mode (-1..1)
);
lfo.init(44100.0);

// Generate modulation signal
let mut output = [0.0_f32];
lfo.process(None, &mut output).unwrap();
let modulation = output[0];

Implementations

impl<T: Transcendental> LFO<T>

pub fn new(frequency: f32, waveform: Waveform, bipolar: bool) -> Self

Create a new LFO

Arguments

• frequency - frequency in Hz (0.01 - 100)
• waveform - waveform shape
• bipolar - true for bipolar (-1..1), false for unipolar (0..1)

pub fn with_phase_offset(self, offset: T) -> Self

Create an LFO with phase offset

pub fn set_bipolar(&mut self, bipolar: bool)

Set bipolar mode

Arguments

• bipolar - true: output in [-1, 1], false: output in [0, 1]

pub fn set_phase_offset(&mut self, offset: T)

Set phase offset (0..1)

Shifts the LFO phase relative to the reference point. Useful for stereo effects or synchronizing multiple LFOs.

pub fn phase_offset(&self) -> T

Get current phase offset

pub fn is_bipolar(&self) -> bool

Check if LFO is in bipolar mode

pub fn sync(&mut self, reset: bool)

Sync with external clock

Arguments

• reset - if true, reset phase to phase_offset value

pub fn modulate(&mut self) -> T

Get modulation value (current sample)

pub fn reset(&mut self)

Reset LFO to initial state

Trait Implementations

impl<T: Transcendental> Algorithm<T> for LFO<T>

fn init(&mut self, sample_rate: f32)

Initialise the algorithm with a sample rate.

fn reset(&mut self)

Reset the algorithm to its initial state.

fn process( &mut self, _input: Option<&[T]>, output: &mut [T], ) -> ProcessResult<()>

Process one block of signal.

fn metadata(&self) -> AlgorithmMetadata

Descriptive metadata (defaults to empty).

fn apply_command(&mut self, _value: T)

Receive a real-time command value from the control path.

impl<T: Clone + Transcendental> Clone for LFO<T>

fn clone(&self) -> LFO<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Transcendental> Copy for LFO<T>

impl<T: Transcendental> Generator<T> for LFO<T>

fn phase(&self) -> T

Get current phase (0.0 - 1.0)

fn set_phase(&mut self, phase: T)

Set phase

fn frequency(&self) -> f32

Get frequency in Hz

fn set_frequency(&mut self, freq: f32)

Set frequency

fn amplitude(&self) -> T

Get amplitude

fn set_amplitude(&mut self, amp: T)

Set amplitude

fn reset_phase(&mut self)

Reset phase to 0

impl<T: Transcendental> SyncableGenerator<T> for LFO<T>

fn sync(&mut self, reset: bool)

Sync with external clock signal

fn periods(&self) -> u32

Get number of periods since last reset