Method events

crates/firewheel-nodes/src/spatial_basic.rs:274–323

(&mut self, info: &ProcInfo, events: &mut ProcEvents, _extra: &mut ProcExtra)

        self.gain_l.reset_to_target();
        self.gain_r.reset_to_target();
        self.distance_attenuator.reset();
    }
}

impl AudioNodeProcessor for Processor {
    fn events(&mut self, info: &ProcInfo, events: &mut ProcEvents, _extra: &mut ProcExtra) {
        let mut updated = false;
        for mut patch in events.drain_patches::<SpatialBasicNode>() {
            match &mut patch {
                SpatialBasicNodePatch::Offset(offset)
                    if !(offset.x.is_finite() && offset.y.is_finite() && offset.z.is_finite()) =>
                {
                    *offset = Vec3::default();
                }
                SpatialBasicNodePatch::PanningThreshold(threshold) => {
                    *threshold = threshold.clamp(0.0, 1.0);
                }
                SpatialBasicNodePatch::SmoothSeconds(seconds) => {
                    self.gain_l.set_smooth_seconds(*seconds, info.sample_rate);
                    self.gain_r.set_smooth_seconds(*seconds, info.sample_rate);
                    self.distance_attenuator
                        .set_smooth_seconds(*seconds, info.sample_rate);
                }
                SpatialBasicNodePatch::MinGain(g) => {
                    *g = g.clamp(0.0, 1.0);
                }
                SpatialBasicNodePatch::CoeffUpdateFactor(f) => {
                    self.distance_attenuator.set_coeff_update_factor(*f);
                }
                _ => {}
            }

            self.params.apply(patch);
            updated = true;
        }

        if updated {
            let computed_values = self.params.compute_values();

            self.gain_l.set_value(computed_values.gain_l);
            self.gain_r.set_value(computed_values.gain_r);

            self.distance_attenuator.compute_values(
                computed_values.distance,
                &self.params.distance_attenuation,
                self.params.muffle_cutoff_hz,
                self.params.min_gain,
            );

            if self.prev_input_settled {
                // The previous block's input settled at zero, so no need to smooth.
                self.reset();
            }