rill_core_dsp/generators/
wavetable.rs

1use crate::algorithm::{Algorithm, AlgorithmCategory, AlgorithmMetadata};
2use crate::generators::{Generator, InterpolatedReader};
3use crate::vector::prelude::*;
4use rill_core::traits::{ActionContext, ProcessResult};
5use rill_core::Transcendental;
6
7/// Wavetable oscillator built on [`InterpolatedReader`].
8///
9/// The compile-time constant `SIZE` determines table resolution but the
10/// underlying storage is heap-allocated, sharing the same interpolation
11/// engine with [`SamplePlayer`](crate::generators::SamplePlayer).
12pub struct WavetableOscillator<T: Transcendental, const SIZE: usize> {
13    reader: InterpolatedReader<T>,
14    frequency: f32,
15    amplitude: ScalarVector1<T>,
16    sample_rate: f32,
17}
18
19impl<T: Transcendental, const SIZE: usize> WavetableOscillator<T, SIZE> {
20    /// Create from an explicit table.
21    pub fn new(table: [T; SIZE], frequency: f32) -> Self {
22        let mut reader = InterpolatedReader::new(table.to_vec());
23        reader.set_wrap(true);
24        let mut osc = Self {
25            reader,
26            frequency,
27            amplitude: ScalarVector1::splat(T::from_f32(1.0)),
28            sample_rate: 44100.0,
29        };
30        osc.update_rate();
31        osc
32    }
33
34    /// Create a sine wavetable.
35    pub fn sine(frequency: f32) -> Self {
36        let mut table = [T::ZERO; SIZE];
37        for i in 0..SIZE {
38            let phase = (i as f32 / SIZE as f32) * 2.0 * core::f32::consts::PI;
39            table[i] = T::from_f32(phase.sin());
40        }
41        Self::new(table, frequency)
42    }
43
44    /// Create a sawtooth wavetable.
45    pub fn saw(frequency: f32) -> Self {
46        let mut table = [T::ZERO; SIZE];
47        for i in 0..SIZE {
48            table[i] = T::from_f32(2.0 * i as f32 / SIZE as f32 - 1.0);
49        }
50        Self::new(table, frequency)
51    }
52
53    /// Replace the wavetable data.
54    pub fn set_table(&mut self, table: [T; SIZE]) {
55        self.reader.set_buffer(table.to_vec());
56    }
57
58    fn update_rate(&mut self) {
59        let rate = self.frequency as f64 * SIZE as f64 / self.sample_rate as f64;
60        self.reader.set_rate(rate);
61    }
62}
63
64impl<T: Transcendental, const SIZE: usize> Algorithm<T> for WavetableOscillator<T, SIZE> {
65    fn init(&mut self, sample_rate: f32) {
66        self.sample_rate = sample_rate;
67        self.update_rate();
68        self.reader.set_position(0.0);
69    }
70
71    fn reset(&mut self) {
72        self.reader.set_position(0.0);
73    }
74
75    fn process(
76        &mut self,
77        _input: Option<&[T]>,
78        output: &mut [T],
79        _ctx: &ActionContext,
80    ) -> ProcessResult<()> {
81        let amp = self.amplitude.extract(0);
82        self.reader.render_block(output);
83        if amp != T::from_f32(1.0) {
84            for s in output.iter_mut() {
85                *s = *s * amp;
86            }
87        }
88        Ok(())
89    }
90
91    fn metadata(&self) -> AlgorithmMetadata {
92        AlgorithmMetadata {
93            name: "Wavetable Oscillator",
94            category: AlgorithmCategory::Generator,
95            description: "Wavetable oscillator with linear / cubic interpolation".into(),
96            author: "Rill",
97            version: env!("CARGO_PKG_VERSION"),
98        }
99    }
100}
101
102impl<T: Transcendental, const SIZE: usize> Generator<T> for WavetableOscillator<T, SIZE> {
103    fn phase(&self) -> T {
104        let pos = self.reader.position();
105        let len = SIZE as f64;
106        T::from_f64((pos % len) / len)
107    }
108
109    fn set_phase(&mut self, phase: T) {
110        let p = phase.to_f64().clamp(0.0, 1.0);
111        self.reader.set_position(p * SIZE as f64);
112    }
113
114    fn reset_phase(&mut self) {
115        self.reader.set_position(0.0);
116    }
117
118    fn frequency(&self) -> f32 {
119        self.frequency
120    }
121
122    fn set_frequency(&mut self, freq: f32) {
123        self.frequency = freq;
124        self.update_rate();
125    }
126
127    fn amplitude(&self) -> T {
128        self.amplitude.extract(0)
129    }
130
131    fn set_amplitude(&mut self, amp: T) {
132        self.amplitude = ScalarVector1::splat(amp.clamp(T::ZERO, T::from_f32(1.0)));
133    }
134}
rill_core_dsp/generators/wavetable.rs

rill_core_dsp/generators/
wavetable.rs
