Struct bevy_fundsp::prelude::hacker::Rez

pub struct Rez<T, F, N> { /* private fields */ }

Implementations

impl<T, F, N> Rez<T, F, N>where T: Float, F: Real, N: Size<T>,

pub fn new(bandpass: F, cutoff: F, q: F) -> Rez<T, F, N>

Create new resonant filter. The bandpass mode selector is 0 for a lowpass and 1 for a bandpass.

pub fn set_cutoff_q(&mut self, cutoff: F, q: F)

Trait Implementations

impl<T, F, N> AudioNode for Rez<T, F, N>where T: Float, F: Real, N: Size<T>,

const ID: u64 = 75u64

Unique ID for hashing.

type Sample = T

Sample type for input and output.

type Inputs = N

Input arity.

type Outputs = UInt<UTerm, B1>

Output arity.

type Setting = (F, F)

Setting type. Settings are parameters that do not have a dedicated input. This is the unit type if there are no settings.

fn set(&mut self, _: (F, F))

Apply setting.

fn reset(&mut self)

Reset the input state of the component to an initial state where it has not processed any samples. In other words, reset time to zero.

fn set_sample_rate(&mut self, sample_rate: f64)

Set the sample rate of the unit. The default sample rate is 44100 Hz. The unit is allowed to reset its state here in response to sample rate changes. If the sample rate stays unchanged, then the goal is to maintain current state.

fn tick( &mut self, input: &NumericArray<<Rez<T, F, N> as AudioNode>::Sample, <Rez<T, F, N> as AudioNode>::Inputs> ) -> NumericArray<<Rez<T, F, N> as AudioNode>::Sample, <Rez<T, F, N> as AudioNode>::Outputs>

Process one sample.

fn route( &mut self, input: &TinyVec<[Signal; 64]>, _frequency: f64 ) -> TinyVec<[Signal; 64]>

Route constants, latencies and frequency responses at frequency Hz from inputs to outputs. Return output signal.

fn process( &mut self, size: usize, input: &[&[Self::Sample]], output: &mut [&mut [Self::Sample]] )

Process up to 64 (MAX_BUFFER_SIZE) samples. The number of input and output buffers must match the number of inputs and outputs, respectively. All input and output buffers must be at least as large as size. If size is zero then this is a no-op, which is permitted.

fn set_hash(&mut self, hash: u64)

Set node pseudorandom phase hash. This is called from ping (only). It should not be called by users.

fn ping(&mut self, probe: bool, hash: AttoHash) -> AttoHash

Ping contained AudioNodes to obtain a deterministic pseudorandom hash. The local hash includes children, too. Leaf nodes should not need to override this. If probe is true, then this is a probe for computing the network hash and set_hash should not be called yet. To set a custom hash for a graph, call this method with ping set to false and hash initialized with the custom hash.

fn allocate(&mut self)

Preallocate all needed memory, including buffers for block processing.

fn inputs(&self) -> usize

Number of inputs.

fn outputs(&self) -> usize

Number of outputs.

fn response(&mut self, output: usize, frequency: f64) -> Option<Complex<f64>>

Evaluate frequency response of output at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn response_db(&mut self, output: usize, frequency: f64) -> Option<f64>

Evaluate frequency response of output in dB at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn latency(&mut self) -> Option<f64>

Causal latency in (fractional) samples. After a reset, we can discard this many samples from the output to avoid incurring a pre-delay. The latency may depend on the sample rate.

fn get_mono(&mut self) -> Self::Sample

Retrieve the next mono sample from a generator. The node must have no inputs and 1 or 2 outputs. If there are two outputs, average the channels.

fn get_stereo(&mut self) -> (Self::Sample, Self::Sample)

Retrieve the next stereo sample (left, right) from a generator. The node must have no inputs and 1 or 2 outputs. If there is just one output, duplicate it.

fn filter_mono(&mut self, x: Self::Sample) -> Self::Sample

Filter the next mono sample x. The node must have exactly 1 input and 1 output.

fn filter_stereo( &mut self, x: Self::Sample, y: Self::Sample ) -> (Self::Sample, Self::Sample)

Filter the next stereo sample (x, y). The node must have exactly 2 inputs and 2 outputs.

impl<T, F, N> Clone for Rez<T, F, N>where T: Clone, F: Clone, N: Clone,

fn clone(&self) -> Rez<T, F, N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, F, N> Default for Rez<T, F, N>where T: Default, F: Default, N: Default,

fn default() -> Rez<T, F, N>

Returns the “default value” for a type.