Molyxide

lib.rs (28270B)

---

 use nih_plug::prelude::*;
 use std::sync::Arc;
 
 // --- Enums ---
 
 #[derive(Enum, PartialEq, Clone, Copy)]
 pub enum WaveformSelection {
     #[name = "Sawtooth"]
     Saw,
     #[name = "Square"]
     Square,
     #[name = "Saw + Square"]
     Both,
 }
 
 #[derive(Enum, PartialEq, Clone, Copy)]
 pub enum ResonatorMode {
     #[name = "Low Pass"]
     LowPass,
     #[name = "Band Pass"]
     BandPass,
     #[name = "High Pass"]
     HighPass,
 }
 
 #[derive(Enum, PartialEq, Clone, Copy)]
 pub enum FilterAlgorithm {
     #[name = "Biquad (Standard)"]
     Biquad,
     #[name = "ZDF SVF (Analog-style)"]
     ZdfSvf,
 }
 
 #[derive(Enum, PartialEq, Clone, Copy)]
 pub enum FinalDecayMode {
     #[name = "Lock (No Release)"]
     Lock,
     #[name = "Manual (Release On)"]
     Manual,
 }
 
 // --- DSP Modules ---
 
 /// ZDF SVF (Topology Preserving Transform)
 struct ZdfSvf {
     s1: f32,
     s2: f32,
 }
 
 impl ZdfSvf {
     fn new() -> Self {
         Self { s1: 0.0, s2: 0.0 }
     }
     fn process(&mut self, input: f32, mode: ResonatorMode, freq: f32, emph: f32, sr: f32) -> f32 {
         let q = (0.5 + emph * 9.5).max(0.01);
         let g = (std::f32::consts::PI * freq / sr).tan();
         let k = 1.0 / q;
         let a1 = 1.0 / (1.0 + g * (g + k));
         let a2 = g * a1;
         let a3 = g * a2;
         let m_v3 = input - self.s2;
         let v1 = a1 * self.s1 + a2 * m_v3;
         let v2 = self.s2 + a2 * self.s1 + a3 * m_v3;
         self.s1 = 2.0 * v1 - self.s1;
         self.s2 = 2.0 * v2 - self.s2;
         match mode {
             ResonatorMode::LowPass => v2,
             ResonatorMode::BandPass => v1,
             ResonatorMode::HighPass => input - k * v1 - v2,
         }
     }
 }
 
 /// ZDF Ladder Filter (24dB/oct)
 /// Moog スタイルの 4-pole ローパスフィルター
 struct LadderFilter {
     s: [f32; 4],
 }
 
 impl LadderFilter {
     fn new() -> Self {
         Self { s: [0.0; 4] }
     }
     fn process(&mut self, input: f32, cutoff: f32, resonance: f32, sr: f32) -> f32 {
         let g = (std::f32::consts::PI * cutoff / sr).tan();
         let k = 4.0 * resonance.clamp(0.0, 0.99); // 自励振を避けるため微調整
 
         // 1-pole 係数
         let a = 1.0 / (1.0 + g);
 
         // フィードバック補正
         let g_pow4 = g * g * g * g;
         let sigma = g_pow4 * a * a * a * a;
         let gamma = 1.0 / (1.0 + k * sigma);
 
         // 内部状態からのフィードバック
         let input_fb = (input
             - k * (self.s[0] * a
                 + self.s[1] * a * a
                 + self.s[2] * a * a * a
                 + self.s[3] * a * a * a * a))
             * gamma;
 
         // 4段の 1-pole フィルターの直列処理
         let mut vin = input_fb;
         for i in 0..4 {
             let v = (vin - self.s[i]) * g * a;
             let out = v + self.s[i];
             self.s[i] = out + v;
             vin = out;
         }
 
         vin // 4段目の出力
     }
 }
 
 // --- Parameters ---
 
 #[derive(Params)]
 pub struct MixerParams {
     #[id = "m_tune"]
     pub master_tune: FloatParam,
     #[id = "mix_dir"]
     pub direct: FloatParam,
     #[id = "mix_mode"]
     pub mode: FloatParam,
     #[id = "mix_res"]
     pub resonator: FloatParam,
     #[id = "mix_vcf"]
     pub vcf: FloatParam,
 }
 
 #[derive(Params)]
 pub struct OscParams {
     #[id = "l_wave"]
     pub lower_waveshape: EnumParam<WaveformSelection>,
     #[id = "u_wave"]
     pub upper_waveshape: EnumParam<WaveformSelection>,
     #[id = "l_pw"]
     pub lower_pw: FloatParam,
     #[id = "u_pw"]
     pub upper_pw: FloatParam,
     #[id = "l_mix"]
     pub lower_mix: FloatParam,
     #[id = "u_mix"]
     pub upper_mix: FloatParam,
     #[id = "rank_a_tune"]
     pub rank_a_tune: FloatParam,
     #[id = "rank_b_beat"]
     pub rank_b_beat: FloatParam,
     #[id = "pwm_rate"]
     pub pwm_rate: FloatParam,
     #[id = "pwm_amt"]
     pub pwm_amt: FloatParam,
     #[id = "fm_rate"]
     pub fm_rate: FloatParam,
     #[id = "fm_amt"]
     pub fm_amt: FloatParam,
 }
 
 #[derive(Params)]
 pub struct ResonatorParams {
     #[id = "res_on"]
     pub enabled: BoolParam,
     #[id = "res_mode"]
     pub mode: EnumParam<ResonatorMode>,
     #[id = "res_l_cf"]
     pub low_cf: FloatParam,
     #[id = "res_l_emph"]
     pub low_emph: FloatParam,
     #[id = "res_l_gain"]
     pub low_gain: FloatParam,
     #[id = "res_m_cf"]
     pub mid_cf: FloatParam,
     #[id = "res_m_emph"]
     pub mid_emph: FloatParam,
     #[id = "res_m_gain"]
     pub mid_gain: FloatParam,
     #[id = "res_h_cf"]
     pub high_cf: FloatParam,
     #[id = "res_h_emph"]
     pub high_emph: FloatParam,
     #[id = "res_h_gain"]
     pub high_gain: FloatParam,
 }
 
 #[derive(Params)]
 pub struct VcfParams {
     #[id = "vcf_on"]
     pub enabled: BoolParam,
     #[id = "vcf_cutoff"]
     pub cutoff: FloatParam,
     #[id = "vcf_emph"]
     pub emphasis: FloatParam,
     #[id = "vcf_kb"]
     pub kb_track: FloatParam,
     #[id = "vcf_glide"]
     pub kb_glide: FloatParam,
     #[id = "vcf_lfo_r"]
     pub lfo_rate: FloatParam,
     #[id = "vcf_lfo_a"]
     pub lfo_amt: FloatParam,
     #[id = "vcf_lfo_sh"]
     pub lfo_sh: FloatParam,
     #[id = "vcf_env_a"]
     pub attack: FloatParam,
     #[id = "vcf_env_d"]
     pub decay: FloatParam,
     #[id = "vcf_env_s"]
     pub sustain: FloatParam,
     #[id = "vcf_env_amt"]
     pub env_amt: FloatParam,
 }
 
 #[derive(Params)]
 pub struct AmpParams {
     #[id = "amp_a"]
     pub attack: FloatParam,
     #[id = "amp_s"]
     pub sustain: FloatParam,
     #[id = "amp_dr"]
     pub decay_release: FloatParam,
     #[id = "amp_vel"]
     pub velocity: FloatParam,
     #[id = "amp_f_dec"]
     pub final_decay: EnumParam<FinalDecayMode>,
 }
 
 #[derive(Params)]
 struct MolyxideParams {
     #[nested(group = "1. Mixer & Tune")]
     pub mixer: MixerParams,
     #[nested(group = "2. Oscillators")]
     pub osc: OscParams,
     #[nested(group = "3. Resonator")]
     pub res: ResonatorParams,
     #[nested(group = "4. VCF (Master Filter)")]
     pub vcf: VcfParams,
     #[nested(group = "5. Loudness (Per-Voice)")]
     pub amp: AmpParams,
     #[id = "gain"]
     pub gain: FloatParam,
 }
 
 impl Default for MolyxideParams {
     fn default() -> Self {
         Self {
             mixer: MixerParams {
                 master_tune: FloatParam::new(
                     "Master Tune",
                     0.0,
                     FloatRange::Linear {
                         min: -200.0,
                         max: 200.0,
                     },
                 ),
                 direct: FloatParam::new(
                     "Direct Level",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 mode: FloatParam::new("Mode Level", 0.0, FloatRange::Linear { min: 0.0, max: 1.0 }),
                 resonator: FloatParam::new(
                     "Resonator Level",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 vcf: FloatParam::new("VCF Level", 0.5, FloatRange::Linear { min: 0.0, max: 1.0 }),
             },
             osc: OscParams {
                 lower_waveshape: EnumParam::new("Lower Waveshape", WaveformSelection::Saw),
                 upper_waveshape: EnumParam::new("Upper Waveshape", WaveformSelection::Square),
                 lower_pw: FloatParam::new(
                     "Lower PW",
                     0.5,
                     FloatRange::Linear {
                         min: 0.05,
                         max: 0.5,
                     },
                 ),
                 upper_pw: FloatParam::new(
                     "Upper PW",
                     0.2,
                     FloatRange::Linear {
                         min: 0.05,
                         max: 0.5,
                     },
                 ),
                 lower_mix: FloatParam::new(
                     "Lower Rank Mix",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 upper_mix: FloatParam::new(
                     "Upper Rank Mix",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 rank_a_tune: FloatParam::new(
                     "Rank A Tune",
                     0.0,
                     FloatRange::Linear {
                         min: -600.0,
                         max: 600.0,
                     },
                 ),
                 rank_b_beat: FloatParam::new(
                     "Rank B Beat",
                     0.0,
                     FloatRange::Linear {
                         min: -50.0,
                         max: 50.0,
                     },
                 ),
                 pwm_rate: FloatParam::new(
                     "PWM Rate",
                     0.5,
                     FloatRange::Skewed {
                         min: 0.05,
                         max: 25.0,
                         factor: FloatRange::skew_factor(-0.5),
                     },
                 ),
                 pwm_amt: FloatParam::new(
                     "PWM Amount",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 fm_rate: FloatParam::new(
                     "FM Rate",
                     6.0,
                     FloatRange::Skewed {
                         min: 0.05,
                         max: 25.0,
                         factor: FloatRange::skew_factor(-0.5),
                     },
                 ),
                 fm_amt: FloatParam::new(
                     "FM Amount",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
             },
             res: ResonatorParams {
                 enabled: BoolParam::new("Resonator Enabled", true),
                 mode: EnumParam::new("Pass Mode", ResonatorMode::LowPass),
                 low_cf: FloatParam::new(
                     "Low CF",
                     200.0,
                     FloatRange::Skewed {
                         min: 20.0,
                         max: 20000.0,
                         factor: FloatRange::skew_factor(-0.9),
                     },
                 ),
                 low_emph: FloatParam::new(
                     "Low Emphasis",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 low_gain: FloatParam::new(
                     "Low Gain",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 mid_cf: FloatParam::new(
                     "Mid CF",
                     1000.0,
                     FloatRange::Skewed {
                         min: 20.0,
                         max: 20000.0,
                         factor: FloatRange::skew_factor(-0.9),
                     },
                 ),
                 mid_emph: FloatParam::new(
                     "Mid Emphasis",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 mid_gain: FloatParam::new(
                     "Mid Gain",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 high_cf: FloatParam::new(
                     "High CF",
                     5000.0,
                     FloatRange::Skewed {
                         min: 20.0,
                         max: 20000.0,
                         factor: FloatRange::skew_factor(-0.9),
                     },
                 ),
                 high_emph: FloatParam::new(
                     "High Emphasis",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 high_gain: FloatParam::new(
                     "High Gain",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
             },
             vcf: VcfParams {
                 enabled: BoolParam::new("VCF Enabled", true),
                 cutoff: FloatParam::new(
                     "VCF Cutoff",
                     20000.0,
                     FloatRange::Skewed {
                         min: 20.0,
                         max: 20000.0,
                         factor: FloatRange::skew_factor(-0.9),
                     },
                 ),
                 emphasis: FloatParam::new(
                     "VCF Emphasis",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 kb_track: FloatParam::new(
                     "Keyboard Track",
                     1.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 kb_glide: FloatParam::new(
                     "Keyboard Glide",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 lfo_rate: FloatParam::new(
                     "VCF LFO Rate",
                     6.0,
                     FloatRange::Skewed {
                         min: 0.05,
                         max: 25.0,
                         factor: FloatRange::skew_factor(-0.5),
                     },
                 ),
                 lfo_amt: FloatParam::new(
                     "VCF LFO Amount",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 lfo_sh: FloatParam::new(
                     "VCF S&H Amount",
                     0.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 attack: FloatParam::new(
                     "VCF Attack",
                     0.01,
                     FloatRange::Skewed {
                         min: 0.01,
                         max: 10.0,
                         factor: FloatRange::skew_factor(-0.8),
                     },
                 ),
                 decay: FloatParam::new(
                     "VCF Decay",
                     0.1,
                     FloatRange::Skewed {
                         min: 0.01,
                         max: 10.0,
                         factor: FloatRange::skew_factor(-0.8),
                     },
                 ),
                 sustain: FloatParam::new(
                     "VCF Sustain",
                     1.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 env_amt: FloatParam::new(
                     "VCF Envelope Amount",
                     0.0,
                     FloatRange::Linear {
                         min: -1.0,
                         max: 1.0,
                     },
                 ),
             },
             amp: AmpParams {
                 attack: FloatParam::new(
                     "Amp Attack",
                     0.01,
                     FloatRange::Skewed {
                         min: 0.01,
                         max: 10.0,
                         factor: FloatRange::skew_factor(-0.8),
                     },
                 ),
                 sustain: FloatParam::new(
                     "Amp Sustain",
                     1.0,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 decay_release: FloatParam::new(
                     "Amp Decay/Release",
                     0.1,
                     FloatRange::Skewed {
                         min: 0.01,
                         max: 10.0,
                         factor: FloatRange::skew_factor(-0.8),
                     },
                 ),
                 velocity: FloatParam::new(
                     "Keyboard Dynamics",
                     0.5,
                     FloatRange::Linear { min: 0.0, max: 1.0 },
                 ),
                 final_decay: EnumParam::new("Final Decay", FinalDecayMode::Manual),
             },
             gain: FloatParam::new(
                 "Gain",
                 util::db_to_gain(0.0),
                 FloatRange::Linear { min: 0.0, max: 1.0 },
             ),
         }
     }
 }
 
 // --- TOG (Top Octave Generator) ---
 
 struct TopOctaveGenerator {
     phases: [f64; 12],
     wrap_counts: [u64; 12],
 }
 
 impl TopOctaveGenerator {
     fn new() -> Self {
         Self {
             phases: [0.0; 12],
             wrap_counts: [0; 12],
         }
     }
     fn process(&mut self, sample_rate: f32, frequencies: &[f32; 12]) {
         for i in 0..12 {
             self.phases[i] += frequencies[i] as f64 / sample_rate as f64;
             if self.phases[i] >= 1.0 {
                 self.phases[i] -= 1.0;
                 self.wrap_counts[i] = self.wrap_counts[i].wrapping_add(1);
             }
         }
     }
 }
 
 // --- Poly Chip ---
 
 const NUM_CHIPS: usize = 71;
 const BASE_NOTE: u8 = 29; // F1
 
 struct PolyChip {
     note: u8,
     tog_index: usize,
     division: f64,
     gate: bool,
     velocity: f32,
     samples_since_on: u32,
     samples_since_off: u32,
     release_start_level: f32,
 }
 
 impl PolyChip {
     fn new(note: u8) -> Self {
         let tog_index = (note % 12) as usize;
         let division = 2.0f64.powi((108 + (tog_index as i32) - (note as i32)) / 12);
         Self {
             note,
             tog_index,
             division,
             gate: false,
             velocity: 0.0,
             samples_since_on: 0,
             samples_since_off: 0,
             release_start_level: 0.0,
         }
     }
     fn get_envelope(&self, params: &AmpParams, sr: f32) -> f32 {
         let a = params.attack.value();
         let dr = params.decay_release.value();
         let s = params.sustain.value();
         if self.gate {
             let t = self.samples_since_on as f32 / sr;
             if t < a {
                 t / a.max(0.0001)
             } else {
                 1.0 - ((t - a) / dr.max(0.0001)).clamp(0.0, 1.0) * (1.0 - s)
             }
         } else {
             let t = self.samples_since_off as f32 / sr;
             if params.final_decay.value() == FinalDecayMode::Manual {
                 self.release_start_level * (1.0 - (t / dr.max(0.0001)).clamp(0.0, 1.0))
             } else {
                 0.0
             }
         }
     }
     fn process(
         &mut self,
         t_a: f64,
         w_a: u64,
         t_b: f64,
         w_b: u64,
         params: &MolyxideParams,
         sr: f32,
         pwm: f32,
     ) -> f32 {
         let env = self.get_envelope(&params.amp, sr);
         if !self.gate && env <= 0.0 {
             return 0.0;
         }
         let (ws, base_pw, mix) = if self.note < 49 {
             (
                 params.osc.lower_waveshape.value(),
                 params.osc.lower_pw.value(),
                 params.osc.lower_mix.value(),
             )
         } else {
             (
                 params.osc.upper_waveshape.value(),
                 params.osc.upper_pw.value(),
                 params.osc.upper_mix.value(),
             )
         };
         let p_a = ((w_a as f64 + t_a) / self.division).fract();
         let sig_a = (p_a * 2.0 - 1.0) as f32;
         let p_b = ((w_b as f64 + t_b) / self.division).fract();
         let sig_b = if p_b
             < (base_pw as f64 + pwm as f64 * params.osc.pwm_amt.value() as f64 * 0.4)
                 .clamp(0.05, 0.95)
         {
             1.0
         } else {
             -1.0
         };
         let raw = match ws {
             WaveformSelection::Saw => sig_a,
             WaveformSelection::Square => sig_b,
             WaveformSelection::Both => sig_a * mix + sig_b * (1.0 - mix),
         };
         if self.gate {
             self.samples_since_on = self.samples_since_on.wrapping_add(1);
         } else {
             self.samples_since_off = self.samples_since_off.wrapping_add(1);
         }
         raw * env * (1.0 - (1.0 - self.velocity) * params.amp.velocity.value())
     }
 }
 
 // --- Main Plugin ---
 
 struct Molyxide {
     params: Arc<MolyxideParams>,
     sample_rate: f32,
     tog_a: TopOctaveGenerator,
     tog_b: TopOctaveGenerator,
     chips: Vec<PolyChip>,
     fm_phase: f32,
     pwm_phase: f32,
     res_low: ZdfSvf,
     res_mid: ZdfSvf,
     res_high: ZdfSvf,
     vcf: LadderFilter,
     vcf_samples_on: u32,
     vcf_last_note_id: u8,
 }
 
 impl Default for Molyxide {
     fn default() -> Self {
         let mut chips = Vec::with_capacity(NUM_CHIPS);
         for i in 0..NUM_CHIPS {
             chips.push(PolyChip::new(BASE_NOTE + i as u8));
         }
         Self {
             params: Arc::new(MolyxideParams::default()),
             sample_rate: 44100.0,
             tog_a: TopOctaveGenerator::new(),
             tog_b: TopOctaveGenerator::new(),
             chips,
             fm_phase: 0.0,
             pwm_phase: 0.0,
             res_low: ZdfSvf::new(),
             res_mid: ZdfSvf::new(),
             res_high: ZdfSvf::new(),
             vcf: LadderFilter::new(),
             vcf_samples_on: 0,
             vcf_last_note_id: 0,
         }
     }
 }
 
 impl Plugin for Molyxide {
     const NAME: &'static str = "Molyxide";
     const VENDOR: &'static str = "Minerva_Juppiter";
     const URL: &'static str = env!("CARGO_PKG_HOMEPAGE");
     const EMAIL: &'static str = "contact@minervajuppiter.net";
     const VERSION: &'static str = env!("CARGO_PKG_VERSION");
     const AUDIO_IO_LAYOUTS: &'static [AudioIOLayout] = &[AudioIOLayout {
         main_input_channels: NonZeroU32::new(2),
         main_output_channels: NonZeroU32::new(2),
         aux_input_ports: &[],
         aux_output_ports: &[],
         names: PortNames::const_default(),
     }];
     const MIDI_INPUT: MidiConfig = MidiConfig::Basic;
     const MIDI_OUTPUT: MidiConfig = MidiConfig::None;
     const SAMPLE_ACCURATE_AUTOMATION: bool = true;
     type SysExMessage = ();
     type BackgroundTask = ();
 
     fn params(&self) -> Arc<dyn Params> {
         self.params.clone()
     }
     fn initialize(
         &mut self,
         _: &AudioIOLayout,
         bc: &BufferConfig,
         _: &mut impl InitContext<Self>,
     ) -> bool {
         self.sample_rate = bc.sample_rate;
         true
     }
     fn process(
         &mut self,
         buffer: &mut Buffer,
         _: &mut AuxiliaryBuffers,
         context: &mut impl ProcessContext<Self>,
     ) -> ProcessStatus {
         let mut next_event = context.next_event();
         let sr = self.sample_rate;
         for (sample_id, channel_samples) in buffer.iter_samples().enumerate() {
             while let Some(event) = next_event {
                 if event.timing() > sample_id as u32 {
                     break;
                 }
                 match event {
                     NoteEvent::NoteOn { note, velocity, .. } => {
                         if let Some(c) = self.chips.iter_mut().find(|c| c.note == note) {
                             c.gate = true;
                             c.velocity = velocity;
                             c.samples_since_on = 0;
                             c.samples_since_off = 0;
                             // VCF Contour リセット
                             self.vcf_samples_on = 0;
                             self.vcf_last_note_id = note;
                         }
                     }
                     NoteEvent::NoteOff { note, .. } => {
                         if let Some(c) = self.chips.iter_mut().find(|c| c.note == note) {
                             if c.gate {
                                 c.gate = false;
                                 c.samples_since_off = 0;
                                 c.release_start_level = c.get_envelope(&self.params.amp, sr);
                             }
                         }
                     }
                     _ => (),
                 }
                 next_event = context.next_event();
             }
 
             self.fm_phase += self.params.osc.fm_rate.value() / sr;
             if self.fm_phase >= 1.0 {
                 self.fm_phase -= 1.0;
             }
             let fm_lfo = (self.fm_phase * 2.0 * std::f32::consts::PI).sin();
             self.pwm_phase += self.params.osc.pwm_rate.value() / sr;
             if self.pwm_phase >= 1.0 {
                 self.pwm_phase -= 1.0;
             }
             let pwm_lfo = (self.pwm_phase * 2.0 * std::f32::consts::PI).sin();
 
             let tune = self.params.mixer.master_tune.value()
                 + fm_lfo * self.params.osc.fm_amt.value() * 50.0;
             let mut freqs_a = [0.0f32; 12];
             let mut freqs_b = [0.0f32; 12];
             for i in 0..12 {
                 let base = util::midi_note_to_freq(108 + i as u8);
                 freqs_a[i] = base * 2.0f32.powf(tune / 1200.0);
                 freqs_b[i] = freqs_a[i] * 2.0f32.powf(self.params.osc.rank_b_beat.value() / 1200.0);
             }
             self.tog_a.process(sr, &freqs_a);
             self.tog_b.process(sr, &freqs_b);
 
             let mut mixed = 0.0;
             for c in &mut self.chips {
                 mixed += c.process(
                     self.tog_a.phases[c.tog_index],
                     self.tog_a.wrap_counts[c.tog_index],
                     self.tog_b.phases[c.tog_index],
                     self.tog_b.wrap_counts[c.tog_index],
                     &self.params,
                     sr,
                     pwm_lfo,
                 );
             }
 
             // Resonator Path
             let mut res_out = 0.0;
             if self.params.res.enabled.value() {
                 let mode = self.params.res.mode.value();
                 res_out = self.res_low.process(
                     mixed,
                     mode,
                     self.params.res.low_cf.value(),
                     self.params.res.low_emph.value(),
                     sr,
                 ) * self.params.res.low_gain.value()
                     + self.res_mid.process(
                         mixed,
                         mode,
                         self.params.res.mid_cf.value(),
                         self.params.res.mid_emph.value(),
                         sr,
                     ) * self.params.res.mid_gain.value()
                     + self.res_high.process(
                         mixed,
                         mode,
                         self.params.res.high_cf.value(),
                         self.params.res.high_emph.value(),
                         sr,
                     ) * self.params.res.high_gain.value();
             }
 
             // VCF Path
             let mut vcf_out = 0.0;
             if self.params.vcf.enabled.value() {
                 // VCF Envelope (Contour)
                 let t = self.vcf_samples_on as f32 / sr;
                 let v_a = self.params.vcf.attack.value();
                 let v_d = self.params.vcf.decay.value();
                 let v_s = self.params.vcf.sustain.value();
                 let v_env = if t < v_a {
                     t / v_a.max(0.0001)
                 } else {
                     1.0 - ((t - v_a) / v_d.max(0.0001)).clamp(0.0, 1.0) * (1.0 - v_s)
                 };
 
                 // Cutoff calculation with Envelope and Keyboard Tracking
                 let kb_offset =
                     (self.vcf_last_note_id as f32 - 60.0) / 12.0 * self.params.vcf.kb_track.value();
                 let cutoff = self.params.vcf.cutoff.value()
                     * 2.0f32.powf(kb_offset + v_env * self.params.vcf.env_amt.value() * 4.0);
 
                 vcf_out = self.vcf.process(
                     mixed,
                     cutoff.clamp(20.0, 20000.0),
                     self.params.vcf.emphasis.value(),
                     sr,
                 );
                 self.vcf_samples_on = self.vcf_samples_on.wrapping_add(1);
             }
 
             let direct = mixed * self.params.mixer.direct.value();
             let res_path = res_out * self.params.mixer.resonator.value();
             let vcf_path = vcf_out * self.params.mixer.vcf.value();
 
             let output = (direct + res_path + vcf_path) * 0.02 * self.params.gain.value();
             for sample in channel_samples {
                 *sample = output;
             }
         }
         ProcessStatus::Normal
     }
     fn reset(&mut self) {}
 }
 
 impl ClapPlugin for Molyxide {
     const CLAP_ID: &'static str = "net.minervajuppiter.Molyxide";
     const CLAP_DESCRIPTION: Option<&'static str> = Some("A Simple Polyphonic Synthesizer");
     const CLAP_MANUAL_URL: Option<&'static str> = Some(Self::URL);
     const CLAP_SUPPORT_URL: Option<&'static str> = None;
     const CLAP_FEATURES: &'static [ClapFeature] = &[ClapFeature::Synthesizer, ClapFeature::Stereo];
 }
 
 nih_export_clap!(Molyxide);