Struct surgeosc_super::SurgeSuperOscillator

pub struct SurgeSuperOscillator {

    pub drift: f32,
    pub master_osc: *mut f32,
    pub out: OscillatorOut,
    pub blitter: AbstractBlitter,
    pub params: SSOParamArrayRT,
    pub osc_params: OscillatorParamArrayRT,
    pub li_hpf: LipolPs,
    pub li_dc: LipolPs,
    pub li_integratormult: LipolPs,
    pub fm_phase: Align16<[f32; 68]>,
    pub first_run: bool,
    pub dc: f32,
    pub dc_uni: A1d<f32>,
    pub elapsed_time: A1d<f32>,
    pub last_level: A1d<f32>,
    pub pwidth: A1d<f32>,
    pub pwidth2: A1d<f32>,
    pub pitch: f32,
    pub fm_depth: Lag<f32>,
    pub integrator_mult: Lag<f32>,
    pub l_pw: Lag<f32>,
    pub l_pw2: Lag<f32>,
    pub l_shape: Lag<f32>,
    pub l_sub: Lag<f32>,
    pub l_sync: Lag<f32>,
    pub fm_delay: i32,
    pub fm_mul_inv: f32,
    pub coeff_b0: f32,
    pub coeff_b1: f32,
    pub coeff_a1: f32,
    pub tables: TablesHandle,
    pub tuner: TunerHandle,
    pub srunit: SampleRateHandle,
}

Fields

drift: f32

master_osc: *mut f32

out: OscillatorOut

blitter: AbstractBlitter

params: SSOParamArrayRT

osc_params: OscillatorParamArrayRT

li_hpf: LipolPs

li_dc: LipolPs

li_integratormult: LipolPs

fm_phase: Align16<[f32; 68]>

first_run: bool

dc: f32

dc_uni: A1d<f32>

elapsed_time: A1d<f32>

last_level: A1d<f32>

pwidth: A1d<f32>

pwidth2: A1d<f32>

pitch: f32

fm_depth: Lag<f32>

integrator_mult: Lag<f32>

l_pw: Lag<f32>

l_pw2: Lag<f32>

l_shape: Lag<f32>

l_sub: Lag<f32>

l_sync: Lag<f32>

fm_delay: i32

fm_mul_inv: f32

coeff_b0: f32

coeff_b1: f32

coeff_a1: f32

tables: TablesHandle

tuner: TunerHandle

srunit: SampleRateHandle

Implementations

impl SurgeSuperOscillator

pub fn update_lagvals(&mut self, is_init: bool)

impl SurgeSuperOscillator

pub fn get_delay(&self, fm: bool, ipos: u32) -> u32

Delay is the number of samples ahead of bufpos that oscstate implies at current pitch. Basically the ‘integer part’ of the position.

pub fn get_g(
    &mut self,
    voice: usize,
    wf: f32,
    sub: f32,
    stereo: bool
) -> (f32, f32)

impl SurgeSuperOscillator

pub fn get_t(&self, sync: f64, detune: f64) -> (f32, f32)

impl SurgeSuperOscillator

pub fn convolve_mono(
    &mut self,
    g: f32,
    delay: usize,
    m: usize,
    lipol128: __m128
)

impl SurgeSuperOscillator

pub fn convolve_stereo(
    &mut self,
    g: f32,
    g_r: f32,
    delay: usize,
    m: usize,
    lipol128: __m128
)

impl SurgeSuperOscillator

pub fn do_block(&mut self, cfg: SSOBlockCfg<'_>)

impl SurgeSuperOscillator

pub fn process_block_fm(&mut self, cfg: &OscillatorProcessBlockCfg)

impl SurgeSuperOscillator

pub fn maybe_handle_wrap(&mut self, stereo: bool)

| each block overlap FIRipol_N samples into | the next (due to impulses not being wrapped | around the block edges copy the overlapping | samples to the new block position only | needed if the new bufpos == 0

impl SurgeSuperOscillator

pub fn process_block_nofm(&mut self, cfg: &OscillatorProcessBlockCfg)

impl SurgeSuperOscillator

pub fn get_character(&mut self) -> CharacterMode

pub fn set_rate_all(&mut self, rate: f32)

pub fn clear_tracking(&mut self)

pub fn set_coeff_by_character(&mut self, mode: CharacterMode)

impl SurgeSuperOscillator

pub fn new(
    tuner: TunerHandle,
    tables: TablesHandle,
    srunit: SampleRateHandle
) -> Self

impl SurgeSuperOscillator

pub fn temposync(&self, p: SSOParam) -> bool

pub fn pvalf(&self, p: SSOParam) -> f32

pub fn pvali(&self, p: SSOParam) -> i32

pub fn pvalf_extended(&self, p: SSOParam) -> f32

Trait Implementations

impl AllowDisplay for SurgeSuperOscillator

fn allow_display(&self) -> bool

impl AssignFM for SurgeSuperOscillator

fn assign_fm(&mut self, _master_osc: *mut f32)

impl AssocParam for SurgeSuperOscillator

type ParamType = SSOParam

impl Convolute for SurgeSuperOscillator

fn convolute(&mut self, cfg: ConvolutionCfg)

| I’ve carefully documented the non-fm | non-sync case here. The other cases are | similar. See the comment above. Remeber, | this function exists to calculate the next | impulse in our digital sequence, which | occurs at time ‘oscstate’ convolve it into | our output stream, and advance out phase | state space by the amount just covered.

type ConvoluteArgs = ConvolutionCfg

impl Debug for SurgeSuperOscillator

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

Formats the value using the given formatter.

impl HandleStreamingMismatches for SurgeSuperOscillator

fn handle_streaming_mismatches(
    &mut self,
    _streaming_revision: i32,
    _current_synth_streaming_revision: i32
)

impl Init for SurgeSuperOscillator

fn init(&mut self)

impl Named for SurgeSuperOscillator

const NAME: &'static str

impl OscillatorParamAccess for SurgeSuperOscillator

fn osc_params_const(&self, name: OscillatorParam) -> &OscillatorParamRT

fn osc_params(&mut self, name: OscillatorParam) -> &mut OscillatorParamRT

impl OscillatorProcess for SurgeSuperOscillator

fn process_block(&mut self, cfg: OscillatorProcessBlockCfg)

impl OscillatorStereoOut for SurgeSuperOscillator

fn out_l(&mut self) -> *mut f32

fn out_r(&mut self) -> *mut f32

impl SetPitch for SurgeSuperOscillator

fn set_pitch(&mut self, pitch: f32, is_display: bool)

impl Oscillator for SurgeSuperOscillator