Struct bevy_fundsp::prelude::hacker::hacker32::prelude::MultiPass

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

Pass through inputs unchanged.

Implementations

impl<N, T> MultiPass<N, T>where
    N: Size<T>,
    T: Float,

pub fn new() -> MultiPass<N, T>

Trait Implementations

impl<N, T> AudioNode for MultiPass<N, T>where
    N: Size<T>,
    T: Float,

const ID: u64 = 0u64

Unique ID for hashing.

type Sample = T

Sample type for input and output.

type Inputs = N

Input arity.

type Outputs = N

Output arity.

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

Process one sample.

fn process(
    &mut self,
    size: usize,
    input: &[&[<MultiPass<N, T> as AudioNode>::Sample]],
    output: &mut [&mut [<MultiPass<N, T> as AudioNode>::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. The default implementation is a fallback that calls into tick.

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

Route constants, latencies and frequency responses at frequency Hz from inputs to outputs. Return output signal. Default implementation marks all outputs unknown.

fn reset(&mut self, _sample_rate: Option<f64>)

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. The sample rate can be set optionally. The default sample rate is 44.1 kHz. The default implementation does nothing.

fn set_hash(&mut self, _hash: u64)

Set node pseudorandom phase hash. Override this to use the hash. This is called from ping. It should not be called by users. The default implementation does nothing.

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

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.

fn set(&mut self, _parameter: i64, _value: f64)

Set parameter value recursively. The default implementation does nothing.

fn get(&self, _parameter: i64) -> Option<f64>

Query parameter value recursively. The first matching parameter is returned. The default implementation returns None.

fn inputs(&self) -> usize

Number of inputs.

fn outputs(&self) -> usize

Number of outputs.

fn response(&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(&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(&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 can depend on the sample rate and is allowed to change after reset.

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<N, T> Default for MultiPass<N, T>where
    N: Default,
    T: Default,

fn default() -> MultiPass<N, T>

Returns the “default value” for a type.