Struct LFO 

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

LFO генератор (Low Frequency Oscillator)

Генерирует низкочастотные сигналы для модуляции параметров. Частотный диапазон: 0.01 Hz - 100 Hz.

Режимы работы

• Биполярный: выходной сигнал в диапазоне [-1, 1]
• Униполярный: выходной сигнал в диапазоне [0, 1]

Пример

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

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

// Создаём LFO для модуляции частоты фильтра
let mut lfo = LFO::<f32>::new(
    5.0,              // 5 Hz
    Waveform::Sine,
    true              // биполярный режим (-1..1)
);
lfo.init(44100.0);

// Генерируем модуляционный сигнал
let mut output = [0.0_f32];
lfo.process(None, &mut output, &ctx).unwrap();
let modulation = output[0];

Implementations

impl<T: Transcendental> LFO<T>

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

Создать новый LFO

Arguments

• frequency - частота в Hz (0.01 - 100)
• waveform - форма волны
• bipolar - true для биполярного режима (-1..1), false для униполярного (0..1)

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

Создать LFO с фазовым смещением

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

Установить биполярный режим

Arguments

• bipolar - true: выход в [-1, 1], false: выход в [0, 1]

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

Установить смещение фазы (0..1)

Позволяет сдвинуть фазу LFO относительно опорной точки. Полезно для создания стерео эффектов или синхронизации нескольких LFO.

pub fn phase_offset(&self) -> T

Получить текущее смещение фазы

pub fn is_bipolar(&self) -> bool

Проверить, работает ли LFO в биполярном режиме

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

Синхронизировать с внешним clock

Arguments

• reset - если true, сбросить фазу в значение phase_offset

pub fn modulate(&mut self) -> T

Получить значение для модуляции (текущий семпл)

pub fn reset(&mut self)

Сбросить LFO в начальное состояние

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], _ctx: &ActionContext<'_>, ) -> ProcessResult<()>

Process one block of audio.

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: Transcendental> Generator<T> for LFO<T>

fn phase(&self) -> T

Получить текущую фазу (0.0 - 1.0)

fn set_phase(&mut self, phase: T)

Установить фазу

fn frequency(&self) -> f32

Получить частоту в Hz

fn set_frequency(&mut self, freq: f32)

Установить частоту

fn amplitude(&self) -> T

Получить амплитуду

fn set_amplitude(&mut self, amp: T)

Установить амплитуду

fn reset_phase(&mut self)

Сбросить фазу в 0

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

fn sync(&mut self, reset: bool)

Синхронизировать с внешним тактовым сигналом

fn periods(&self) -> u32

Получить количество периодов с последнего сброса

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