package ugen
- Alphabetic
- Public
- Protected
Type Members
- final case class A2K(in: GE) extends SingleOut with ControlRated with Product with Serializable
A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling.
- final case class APF(rate: MaybeRate, in: GE, freq: GE = 440.0f, radius: GE = 0.8f) extends SingleOut with Product with Serializable
- final case class AllpassC(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable
All pass delay line with cubic interpolation.
All pass delay line with cubic interpolation.
- in
The input signal.
- maxDelayTime
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- final case class AllpassL(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable
All pass delay line with linear interpolation.
All pass delay line with linear interpolation.
- in
The input signal.
- maxDelayTime
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- final case class AllpassN(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable
All pass delay line with no interpolation.
All pass delay line with no interpolation.
- in
The input signal.
- maxDelayTime
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- final case class AmpComp(rate: Rate, freq: GE = 261.626f, root: GE = 261.626f, expon: GE = 0.3333f) extends SingleOut with Product with Serializable
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
Implements the formula:
(root / freq).pow(exp)
Higher frequencies are normally perceived as louder, therefore
AmpComp
outputs lower values for them. For example, with default parameters, the pitch C4 (frequency 262 Hz) produces the base factor of 1.0, whereas a pitch one octave up, C5 (or 523 Hz) produces a factor of 0.793719 (an attenuation of -2 dB).An alternative is
AmpCompA
that better models the bell-shaped equal loudness contours of the hearing system. Especially note that the output of this UGen can become very high for frequencies much lower than theroot
parameter.- freq
the frequency in Hertz for which to determine the compensation factor
- root
the base frequency corresponding to a compensation factor of 1.0
- expon
the exponent determines how steep the compensation curve decreases for increasing frequencies. In general, the louder a signal is played, the shallower the equal loudness contours become.
- See also
- final case class AmpCompA(rate: Rate, freq: GE = 1000.0f, root: GE = 0.0f, minAmp: GE = 0.32f, rootAmp: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency. It uses the A-weighting curve that is based on the Fletcher-Munson curve for rather low volume sounds (40 phon).
Only the
freq
parameter can be modulated, the other parameters are read at initialization time only.- freq
the frequency in Hertz for which to determine the compensation factor
- root
the root frequency in Hertz, relative to which the curve is calculated. This is usually lowest expected frequency. (init-time only)
- minAmp
amplitude at the minimum point of the curve. This is the factor output when
freq
is approx. 2512 Hz. (init-time only)- rootAmp
amplitude at the root frequency of the curve. This is the factor output when
freq == root
. (init-time only)
- See also
- final case class Amplitude(rate: MaybeRate, in: GE, attack: GE = 0.01f, release: GE = 0.01f) extends SingleOut with Product with Serializable
An amplitude follower UGen.
An amplitude follower UGen. Tracks and reports the peak amplitude of its input signal.
- in
input signal to be analyzed
- attack
60 dB convergence time in for following attacks, in seconds
- release
60 dB convergence time in for following decays, in seconds
- See also
- final case class ArrayMax(rate: Rate, in: GE) extends MultiOut with Product with Serializable
A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.
- final case class ArrayMin(rate: Rate, in: GE) extends MultiOut with Product with Serializable
A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.
- final case class AudioControl(values: IndexedSeq[Float], ctrlName: Option[String]) extends MultiOut with AudioRated with Product with Serializable
- final case class AudioControlProxy(values: IndexedSeq[Float], name: Option[String]) extends ControlProxyLike with AudioRated with Product with Serializable
- final case class BAllPass(in: GE, freq: GE = 500.0f, rq: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable
An all pass filter UGen.
An all pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
cutoff frequency.
- rq
the reciprocal of Q, hence bandwidth / cutoffFreq.
- final case class BBandPass(in: GE, freq: GE = 500.0f, bw: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable
An band pass filter UGen.
An band pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
center frequency.
- bw
the bandwidth in octaves between -3 dB frequencies
- final case class BBandStop(in: GE, freq: GE = 500.0f, bw: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable
An band stop (reject) filter UGen.
An band stop (reject) filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
center frequency.
- bw
the bandwidth in octaves between -3 dB frequencies
- final case class BHiPass(in: GE, freq: GE = 500.0f, rq: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable
A 2nd order (12db per oct roll-off) resonant high pass filter UGen.
A 2nd order (12db per oct roll-off) resonant high pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
cutoff frequency.
- rq
the reciprocal of Q, hence bandwidth / cutoffFreq.
- final case class BHiShelf(in: GE, freq: GE = 500.0f, rs: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable
A high shelf equalizer UGen.
A high shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
cutoff frequency.
- rs
the reciprocal of the slope S (Shell boost/cut slope). When
S = 1
, the shelf slope is as steep as it can be and remain monotonically increasing or decreasing gain with frequency. The shelf slope, in dB/octave, remains proportional to S for all other values for a fixed freq/sample-rate andgain
.- gain
boost/cut at the cutoff frequency (in decibels).
- final case class BLowPass(in: GE, freq: GE = 500.0f, rq: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable
A 2nd order (12db per oct roll-off) resonant low pass filter UGen.
A 2nd order (12db per oct roll-off) resonant low pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
cutoff frequency.
- rq
the reciprocal of Q, hence bandwidth / cutoffFreq.
- final case class BLowShelf(in: GE, freq: GE = 500.0f, rs: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable
A low shelf equalizer UGen.
A low shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
cutoff frequency.
- rs
the reciprocal of the slope S (Shell boost/cut slope). When
S = 1
, the shelf slope is as steep as it can be and remain monotonically increasing or decreasing gain with frequency. The shelf slope, in dB/octave, remains proportional to S for all other values for a fixed freq/sample-rate andgain
.- gain
boost/cut at the cutoff frequency (in decibels).
- final case class BPF(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f) extends SingleOut with Product with Serializable
A second order band pass filter UGen.
A second order band pass filter UGen.
- in
input signal to be filtered
- freq
center frequency in Hertz
- rq
reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter.
- final case class BPZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
a special fixed band-pass filter UGen.
- final case class BPeakEQ(in: GE, freq: GE = 500.0f, rq: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable
An parametric equalizer UGen.
An parametric equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
- in
input signal to be processed.
- freq
center frequency.
- rq
the reciprocal of Q, hence bandwidth / cutoffFreq.
- gain
boost/cut at the center frequency (in decibels).
- final case class BRF(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f) extends SingleOut with Product with Serializable
A second order band reject (notch) filter UGen.
A second order band reject (notch) filter UGen.
- in
input signal to be filtered
- freq
center frequency in Hertz
- rq
reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter. Too high values for
rq
may blow the filter up!
- final case class BRZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
a special fixed band-reject filter UGen.
- final case class Balance2(rate: Rate, inL: GE, inR: GE, pos: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable
An equal power two channel balancing UGen.
An equal power two channel balancing UGen. It takes a left and right input signal and attenuates them according to the
pos
value, producing again a stereophonic output.- inL
The left input signal
- inR
The right input signal
- pos
The balance position from
-1
(left only, right muted) to+1
(right only, left muted). The curve follows an equal power law, such thatleft.squared + right.squared == 1
, e.g. at the middle position0
, both channels are multiplied with factorsqrt(0.5) = 0.707 = -3 dB
.
- final case class Ball(rate: MaybeRate, in: GE, g: GE = 1.0f, damp: GE = 0.0f, friction: GE = 0.01f) extends SingleOut with Product with Serializable
- final case class BeatTrack(chain: GE, lock: GE = 0.0f) extends SingleOut with ControlRated with IsIndividual with Product with Serializable
An autocorrelation based beat tracker UGen.
An autocorrelation based beat tracker UGen.
The underlying model assumes 4/4, but it should work on any isochronous beat structure, though there are biases to 100-120 bpm; a fast 7/8 may not be tracked in that sense. There are four control-rate outputs, being ticks at quarter, eighth and sixteenth level from the determined beat, and the current detected tempo. Note that the sixteenth note output won't necessarily make much sense if the music being tracked has swing; it is provided just as a convenience.
This beat tracker determines the beat, biased to the mid-tempo range by weighting functions. It does not determine the measure level, only a tactus. It is also slow reacting, using a 6 second temporal window for its autocorrelation maneuvres. Don't expect human musician level predictive tracking.
On the other hand, it is tireless, relatively general (though obviously best at transient 4/4 heavy material without much expressive tempo variation), and can form the basis of computer processing that is decidedly faster than human.
Warning: This UGen only works properly at 44.1 or 48.0 kHz.
- chain
the output (buffer) of an FFT UGen which transforms the audio input to track. The expected size of FFT is 1024 for 44100 and 48000 sampling rate, and 2048 for double those. No other sampling rates are supported.
- lock
If this argument is greater than 0.5, the tracker will lock at its current periodicity and continue from the current phase. Whilst it updates the model's phase and period, this is not reflected in the output until lock goes back below 0.5. Can be control-rate modulated.
- final case class BeatTrack2(bus: GE, numChannels: GE, winSize: GE = 2, phaseSpacing: GE = 0.02f, lock: GE = 0, weighting: GE = -2.1f) extends MultiOut with ControlRated with IsIndividual with Product with Serializable
A template matching beat tracker UGen.
A template matching beat tracker UGen. This beat tracker is based on exhaustively testing particular template patterns against feature streams; the testing takes place every 0.5 seconds. The two basic templates are a straight (groove=0) and a swung triplet (groove=1) pattern of 16th notes; this pattern is tried out at scaling factors corresponding to the tempi from 60 to 180 bpm. This is the cross-correlation method of beat tracking. A majority vote is taken on the best tempo detected, but this must be confirmed by a consistency check after a phase estimate. Such a consistency check helps to avoid wild fluctuating estimates, but is at the expense of an additional half second delay. The latency of the beat tracker with default settings is thus at least 2.5 seconds; because of block-based amortisation of calculation, it is actually around 2.8 seconds latency for a 2.0 second temporal window.
This beat tracker is designed to be flexible for user needs; you can try out different window sizes, tempo weights and combinations of features. However, there are no guarantees on stability and effectiveness, and you will need to explore such parameters for a particular situation.
The UGen has six outputs corresponding to beat-tick, eighth-tick, groove-tick, tempo, phase, and groove. Warning: it reads from input control bus instead of taking a regular control input signal as its first argument!
- bus
index of a control bus to read from. the number of channels of that bus are expected to match the
numChannels
argument. To track a particular audio signal, analyse it first intonumChannels
features, that is onset-detection-triggers, as generated byOnsets
, and write the trigger-output to this control bus.- numChannels
(scalar) How many features (ie how many control bus channels) are provided (init-time only)
- winSize
(scalar) Size of the temporal window desired (2.0 to 3.0 seconds models the human temporal window). You might use longer values for stability of estimate at the expense of reactiveness.
- phaseSpacing
(scalar) Relates to how many different phases to test. At the default of 0.02 seconds, 50 different phases spaced by those 0.02 seconds would be tried out for 60bpm; 16 would be trialed for 180 bpm. Larger phaseSpacing means more tests and more CPU cost.
- lock
If this argument is greater than 0.5, the tracker will lock at its current periodicity and continue from the current phase. Whilst it updates the model's phase and period, this is not reflected in the output until lock goes back below 0.5. Can be control-rate modulated.
- weighting
(scalar) Use (-2.5) for flat weighting of tempi, (-1.5) for compensation weighting based on the number of events tested (because different periods allow different numbers of events within the temporal window). If an integer from 0 upwards is given, this is specifying the id of a buffer containing 120 frames which represent individual tempo weights; tempi go from 60 to 179 bpm in steps of one bpm, so you make sure the buffer has 120 frames.
- final case class BiPanB2(rate: Rate, inA: GE, inB: GE, azimuth: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable
A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal.
A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal. ambisonic B-format. It places the two input channels at opposite poles of the 2D (W, X, Y) Ambisonics field. It is equivalent to:
PanB2(_, inA, azimuth, level) + PanB2(_, inB, azimuth + 1, level)
- inA
the first (monophonic) input signal, which will appear opposite to the first second signal
- inB
the second (monophonic) input signal, which will appear opposite to the first input signal
- abstract class BinaryOpUGen extends SingleOut
- final case class Blip(rate: Rate, freq: GE = 440.0f, numHarm: GE = 200) extends SingleOut with Product with Serializable
Band Limited ImPulse generator UGen.
Band Limited ImPulse generator UGen. All harmonics have equal amplitude. This is the equivalent of 'buzz' in Music-N languages. It is capable of cross-fading during a control period block if the number of harmonics changes, avoiding audible pops.
- freq
Fundamental frequency in Hertz
- numHarm
Number of harmonics. This will be automatically limited to avoid aliasing.
- See also
- final case class BrownNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable
A noise generator UGen whose spectrum falls off in power by 6 dB per octave.
A noise generator UGen whose spectrum falls off in power by 6 dB per octave. The values produced by this UGen lie between
-1
and+1
, the RMS is approx. -4.8 dB (the same as white noise).- mul
Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel
mul
argument will cause the generation of multiple independent noise generators.
- final case class BufAllpassC(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
All pass delay line with cubic interpolation which uses a buffer for its internal memory.
All pass delay line with cubic interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- See also
- final case class BufAllpassL(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
All pass delay line with linear interpolation which uses a buffer for its internal memory.
All pass delay line with linear interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- See also
- final case class BufAllpassN(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
All pass delay line with no interpolation which uses a buffer for its internal memory.
All pass delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- See also
- final case class BufChannels(rate: Rate, buf: GE) extends SingleOut with Product with Serializable
Returns the current number of channels of the buffer at the provided index.
Returns the current number of channels of the buffer at the provided index.
- buf
Buffer id.
- See also
- final case class BufCombC(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
Comb delay line with cubic interpolation which uses a buffer for its internal memory.
Comb delay line with cubic interpolation which uses a buffer for its internal memory.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower. Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- final case class BufCombL(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
Comb delay line with linear interpolation which uses a buffer for its internal memory.
Comb delay line with linear interpolation which uses a buffer for its internal memory.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower. Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- final case class BufCombN(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
Comb delay line with no interpolation which uses a buffer for its internal memory.
Comb delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- final case class BufDelayC(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
Simple delay line with cubic interpolation which uses a buffer for its internal memory.
Simple delay line with cubic interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- final case class BufDelayL(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
Simple delay line with linear interpolation which uses a buffer for its internal memory.
Simple delay line with linear interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- final case class BufDelayN(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
Simple delay line with no interpolation which uses a buffer for its internal memory.
Simple delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
- buf
Buffer id.
- in
The input signal.
- delayTime
Delay time in seconds.
- final case class BufDur(rate: Rate, buf: GE) extends SingleOut with Product with Serializable
Returns the current duration of the buffer at the provided index.
Returns the current duration of the buffer at the provided index.
- buf
Buffer id.
- See also
- final case class BufFrames(rate: Rate, buf: GE) extends SingleOut with Product with Serializable
Returns the number of allocated frames of the buffer at the provided index.
Returns the number of allocated frames of the buffer at the provided index.
- buf
Buffer id.
- See also
- final case class BufMax(rate: Rate, buf: GE, gate: GE = 1) extends MultiOut with IsIndividual with Product with Serializable
A UGen that finds the largest value in a buffer, providing both the value and the index.
A UGen that finds the largest value in a buffer, providing both the value and the index.
This is a third-party UGen (MCLDUGens).
- buf
identifier of the buffer containing the values to analyze. It treats multi-channel buffers as monophonic, and indices will refer to the de-interleaved frames and channels.
- gate
when closed (zero), holds the last output value.
- final case class BufMin(rate: Rate, buf: GE, gate: GE = 1) extends MultiOut with IsIndividual with Product with Serializable
A UGen that finds the smallest value in a buffer, providing both the value and the index.
A UGen that finds the smallest value in a buffer, providing both the value and the index.
This is a third-party UGen (MCLDUGens).
- buf
identifier of the buffer containing the values to analyze. It treats multi-channel buffers as monophonic, and indices will refer to the de-interleaved frames and channels.
- gate
when closed (zero), holds the last output value.
- final case class BufRateScale(rate: Rate, buf: GE) extends SingleOut with Product with Serializable
Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.
Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.
buffer sample rate / server sample rate
- buf
Buffer id.
- See also
- final case class BufRd(rate: Rate, numChannels: Int, buf: GE, index: GE = 0.0f, loop: GE = 1, interp: GE = 2) extends MultiOut with IsIndividual with HasDoneFlag with Product with Serializable
A UGen which reads the content of a buffer, using an index pointer.
A UGen which reads the content of a buffer, using an index pointer.
Warning: if the supplied
buf
refers to a buffer whose number of channels differs fromnumChannels
, the UGen will fail silently.An alternative to
BufRd
isPlayBuf
. WhilePlayBuf
plays through the buffer by itself,BufRd
only moves its read point by the index input and therefore has no pitch input.PlayBuf
uses cubic interpolation, whileBufRd
has variable interpolation.PlayBuf
can determine the end of the buffer and issue a done-action.- numChannels
number of channels that the buffer will be. Since this is an integer constant, a change in the number of channels must be reflected by creating different SynthDefs.
- buf
the identifier of the buffer to use
- index
audio rate frame-index into the buffer. Can be fractional.
- loop
1 to enable looping, 0 to disable looping. this can be modulated.
- interp
1 for no interpolation, 2 for linear, and 4 for cubic interpolation. (init-time only)
- final case class BufSampleRate(rate: Rate, buf: GE) extends SingleOut with Product with Serializable
Returns the buffer's current sample rate.
- final case class BufSamples(rate: Rate, buf: GE) extends SingleOut with Product with Serializable
Returns the current number of allocated samples in the Buffer at the provided index.
Returns the current number of allocated samples in the Buffer at the provided index. A sample is not the same as a frame (compare with BufFrames ); a frame includes the samples in each channel of the buffer. Only for a mono buffer are samples the same as frames.
samples = frames * numChannels
- buf
Buffer id.
- See also
- final case class BufWr(rate: Rate, in: GE, buf: GE, index: GE = 0.0f, loop: GE = 1) extends SingleOut with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable
A UGen that writes a signal to a buffer, using an index pointer.
A UGen that writes a signal to a buffer, using an index pointer.
Warning: if the supplied
buf
refers to a buffer whose number of channels differs from those of the input signal, the UGen will fail silently.An alternative to
BufWr
isRecordBuf
. WhileRecordBuf
advances the index into the buffer by itself,BufWr
only moves its write point by the index input, making it possible to adjust the writing speed or to access the buffer in a non-linear way.RecordBuf
can determine the end of the buffer and issue a done-action.- in
input signal to record
- buf
the identifier of the buffer to use
- index
audio rate frame-index into the buffer.
- loop
1 to enable looping, 0 to disable looping. this can be modulated.
- final case class COsc(rate: Rate, buf: GE, freq: GE = 440.0f, beats: GE = 0.5f) extends SingleOut with IsIndividual with Product with Serializable
- final case class ChannelIndices(in: GE) extends SingleOut with ScalarRated with Product with Serializable
A graph element that produces an integer sequence from zero until the number-of-channels of the input element.
A graph element that produces an integer sequence from zero until the number-of-channels of the input element.
Examples
// cross-faded select play { val sines: GE = Seq.fill(4)(SinOsc.ar(ExpRand(200, 2000))) val index = MouseX.kr(lo = 0, hi = NumChannels(sines) - 1) val indices = ChannelIndices(sines) indices.poll(0, "indices") val select = 1 - (indices absdif index).min(1) val sig = Mix(sines * select) sig * 0.2 }
- in
the element whose indices to produce
- See also
- final case class ChannelProxy(elem: GE, index: Int) extends GE.Lazy with Product with Serializable
A helper graph element that selects a particular output channel of another element.
A helper graph element that selects a particular output channel of another element. The index is an
Integer
and thus cannot be determined at graph expansion time. If this is desired, theSelect
UGen can be used.Usually the graph element operator
\
(backlash) can be used instead of explicitly writingChannelProxy
. Thuselem \ index
is equivalent toChannelProxy(elem, index)
. UGens with a fixed number of outputs often have auxiliary methods to access the channels in meaningful way, e.g.Pitch
has methodfreq
andhasFreq
, which are equivalent topitch \ 0
andpitch \ 1
.Because ScalaCollider allows late-expanding graph elements, we have no direct way to get some array of a UGen's outputs.
Examples
// frequency of a pitch estimator play { val sin = SinOsc.ar(MouseX.kr(10, 10000, warp = 1)) val pch = Pitch.kr(sin) val freq = pch \ 0 // same as pch.freq freq.poll(label = "freq") () }
- elem
a multi-channel element from which to select a channel.
- index
channel index starting at zero. It automatically wraps around the actual number of channels the input
elem
expands to.
- See also
- final case class ChannelRangeProxy(elem: GE, from: Int, until: Int, step: Int) extends GE.Lazy with Product with Serializable
A helper graph element that selects a particular range of output channel of another element.
A helper graph element that selects a particular range of output channel of another element. The range is specified with integers and thus cannot be determined at graph expansion time. If this is desired, the
Select
UGen can be used.Usually the graph element operator
out
along with a standard ScalaRange
argument can be used instead of explicitly writingChannelRangeProxy
. Thuselem out (0 until 4)
selects the first four channels and is equivalent toChannelRangeProxy(elem, from = 0, until = 4, step = 1)
.Behind the scene,
ChannelProxy
instances are created, thusChannelRangeProxy(x, a, b)
is the same as(a until b).map(ChannelProxy(x, _)): GE
.Because ScalaCollider allows late-expanding graph elements, we have no direct way to get some array of a UGen's outputs.
- elem
a multi-channel element from which to select channels.
- from
the first index (inclusive) of the channel range, counting from zero.
- until
the end index (exclusive) of the channel range, counting from zero.
- step
the increment from index to index in the range. A value of one means all channels from
from
untiluntil
will be selected. A value of two means, every second channel will be skipped. A negative value can be used to count down from high to low indices.
- final case class CheckBadValues(rate: Rate, in: GE, id: GE = 0, post: GE = 2) extends SingleOut with HasSideEffect with Product with Serializable
A UGen to test for infinity, not-a-number (NaN), and denormal numbers.
A UGen to test for infinity, not-a-number (NaN), and denormal numbers. Its output is as follows: 0 = a normal float, 1 = NaN, 2 = infinity, and 3 = a denormal. According to the post settings it will print the information to the console along with a given identifier.
- in
the signal to be tested
- id
an identifier showing up with the values in the console
- post
One of three post modes: 0 = no posting; 1 = post a line for every bad value; 2 = post a line only when the floating-point classification changes (e.g., normal -> NaN and vice versa)
- final case class CircleRamp(rate: MaybeRate, in: GE, dur: GE = 0.1f, lo: GE = -180, hi: GE = 180) extends SingleOut with Product with Serializable
This is a UGen like
Ramp
, but it always takes the shortest way around a defined circle, wrapping values where appropriate.This is a UGen like
Ramp
, but it always takes the shortest way around a defined circle, wrapping values where appropriate. This can be useful when smoothing panning signals for speaker rings, for instance in Vector Base Amplitude Panning.This is a third-party UGen (VBAPUGens).
- in
The signal to be smoothed.
- dur
Ramp duration in seconds
- lo
The lower wrap value
- hi
The upper wrap value
- final class ClassGenerator extends AnyRef
- final case class ClearBuf(buf: GE) extends SingleOut with ScalarRated with HasSideEffect with IsIndividual with Product with Serializable
A scalar (init-time) UGen that fills the contents of a buffer with zeroes.
- final case class Clip(rate: Rate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins.
A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins. This is similar to the
clip2
binary operator but permits both a lower range valuelo
and an upper range valuehi
.Mathematically, this is equivalent to
in.max(lo).min(hi)
.Be aware that there seems to be an initialization bug. The following crashes, indicating that
Clip.ar
outputs a zero initially:{{ play { val bar = Integrator.ar(DC.ar(0), coeff = 0.999) val foo = Clip.ar(bar, lo = 1.0, hi = 44100.0) // .max(1.0) val sum = RunningSum.ar(DC.ar(0), length = foo) sum.poll(1, "sum") () } }}
- in
input signal to constrain
- lo
lower margin of clipping
- hi
upper margin of clipping
- final case class ClipNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable
A noise generator UGen whose values are either
-1
or+1
(before being multiplied bymul
).A noise generator UGen whose values are either
-1
or+1
(before being multiplied bymul
). This produces the maximum energy (an RMS of 0 dB) for the least peak to peak amplitude.- mul
Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel
mul
argument will cause the generation of multiple independent noise generators.
- final case class CoinGate(rate: MaybeRate, in: GE, prob: GE = 0.5f) extends SingleOut with IsIndividual with Product with Serializable
A UGen that randomly filters an input trigger signal.
A UGen that randomly filters an input trigger signal. When a trigger arrives, it may pass with a probability given by the
prob
argument.- in
the input triggers to filter
- prob
the probability between zero (no trigger passed) and 1 (all triggers passed)
- Note
The argument order is different from its sclang counterpart.
- See also
- final case class CombC(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable
Comb delay line with cubic interpolation.
Comb delay line with cubic interpolation.
- in
The input signal.
- maxDelayTime
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- final case class CombL(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable
Comb delay line with linear interpolation.
Comb delay line with linear interpolation.
- in
The input signal.
- maxDelayTime
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- final case class CombN(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable
Comb delay line with no interpolation.
Comb delay line with no interpolation.
- in
The input signal.
- maxDelayTime
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
- delayTime
Delay time in seconds.
- decayTime
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
- final case class Compander(rate: Rate, in: GE, ctrl: GE, thresh: GE = 0.5f, ratioBelow: GE = 1.0f, ratioAbove: GE = 1.0f, attack: GE = 0.01f, release: GE = 0.1f) extends SingleOut with Product with Serializable
A compressor, expander, limiter, gate and ducking UGen.
A compressor, expander, limiter, gate and ducking UGen. This dynamic processor uses a hard-knee characteristic. All of the thresholds and ratios are given as direct values, not in decibels!
- in
The signal to be compressed / expanded / gated.
- ctrl
The signal whose amplitude controls the processor. Often the same as in, but one may wish to apply equalization or delay to it to change the compressor character (side-chaining), or even feed a completely different signal, for instance in a ducking application.
- thresh
Control signal amplitude threshold, which determines the break point between slopeBelow and slopeAbove. Usually 0..1. The control signal amplitude is calculated using RMS.
- ratioBelow
Slope of the amplitude curve below the threshold. If this slope > 1.0, the amplitude will drop off more quickly the softer the control signal gets; when the control signal is close to 0 amplitude, the output should be exactly zero -- hence, noise gating. Values < 1.0 are possible, but it means that a very low-level control signal will cause the input signal to be amplified, which would raise the noise floor.
- ratioAbove
Slope of the amplitude curve above the threshold. Values < 1.0 achieve compression (louder signals are attenuated); > 1.0, you get expansion (louder signals are made even louder). For 3:1 compression, you would use a value of 1/3 here.
- attack
The amount of time it takes for the amplitude adjustment to kick in fully. This is usually pretty small, not much more than 10 milliseconds (the default value). I often set it as low as 2 milliseconds (0.002).
- release
The amount of time for the amplitude adjustment to be released. Usually a bit longer than attack; if both times are too short, you can get some (possibly unwanted) artifacts.
- See also
- final case class ComplexRes(rate: Rate, in: GE, freq: GE = 440.0f, decay: GE = 0.2f) extends SingleOut with Product with Serializable
A resonating filter UGen which can be modulated in its resonating frequency at audio rate.
A resonating filter UGen which can be modulated in its resonating frequency at audio rate.
Implements the filter structure found in Julian Parker and Till Bovermann (2013): Dynamic FM synthesis using a network of complex resonator filters
This is a third-party UGen (DEINDUGens).
- in
input signal to be filtered
- freq
resonating frequency in Hz, can be modulated at audio rate
- decay
decay time in seconds
- final case class Constant(value: Float) extends UGenIn with ScalarRated with Product with Serializable
A scalar constant used as an input to a UGen.
A scalar constant used as an input to a UGen. These constants are stored in a separate table of the synth graph.
- final case class Control(rate: Rate, values: IndexedSeq[Float], ctrlName: Option[String]) extends MultiOut with Product with Serializable
- final case class ControlDur() extends SingleOut with ScalarRated with Product with Serializable
A UGen that reports the server's current control period in seconds.
A UGen that reports the server's current control period in seconds. This is equivalent to the reciprocal of
ControlRate
- See also
- final class ControlFactory extends ControlFactoryLike
- trait ControlFactoryLike extends AnyRef
- final case class ControlProxy(rate: Rate, values: IndexedSeq[Float], name: Option[String]) extends ControlProxyLike with Product with Serializable
- final class ControlProxyFactory extends AnyVal
- trait ControlProxyLike extends GE
- final case class ControlRate() extends SingleOut with ScalarRated with Product with Serializable
A UGen that reports the server's current control rate.
A UGen that reports the server's current control rate. This is equivalent to the reciprocal of
ControlDur
- See also
- final case class ControlUGenOutProxy(source: ControlProxyLike, outputIndex: Int) extends UGenIn with Product with Serializable
A ControlOutProxy is similar to a UGenOutProxy in that it denotes an output channel of a control UGen.
A ControlOutProxy is similar to a UGenOutProxy in that it denotes an output channel of a control UGen. However it refers to a control-proxy instead of a real control ugen, since the proxies are synthesized into actual ugens only at the end of a synth graph creation, in order to clump several controls together. ControlOutProxy instance are typically returned from the ControlProxyFactory class, that is, using the package implicits, from calls such as "myControl".kr.
- final case class ControlValues(seq: IndexedSeq[Float]) extends Product with Serializable
- final case class Convolution(rate: Rate, in: GE, kernel: GE, frameSize: GE) extends SingleOut with IsIndividual with Product with Serializable
A UGen that performs a convolution with an continuously changing kernel.
A UGen that performs a convolution with an continuously changing kernel. If the kernel is static or must only change occasionally,
Convolution2
will be a more CPU friendly alternative. The process introduces a delay offrameSize - blockSize
.- in
first operand of the convolution
- kernel
second operand of the convolution
- frameSize
convolution size in sample frames, which is half of the FFT size. Must be a power of two. There is maximum frame-size of 16384 (if exceeded, the server may crash). (init-time only)
- final case class Convolution2(rate: Rate, in: GE, kernel: GE, trig: GE = 1, frameSize: GE) extends SingleOut with IsIndividual with Product with Serializable
A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal.
A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal. The delay caused by the convolution when the kernel is a dirac impulse is equal to
frameSize - controlBlockSize
, so for aframeSize
of 2048 and a control-block size of 64, this is 1984 sample frames.- in
the realtime input to be convolved
- kernel
buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even a trigger input of zero is used, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.
- trig
updates the kernel on a change from non-positive to positive (<= 0 to >0)
- frameSize
size of the kernel. this must be a power of two. the FFT calculated internally by the UGen has a size of twice this value. The maximum allowed
frameSize
is 16384. (init-time only)
- See also
- final case class Convolution2L(rate: Rate, in: GE, kernel: GE, trig: GE = 1, frameSize: GE, fadePeriods: GE = 1) extends SingleOut with IsIndividual with Product with Serializable
A frequency-domain convolution UGen using two linearly interpolated fixed kernels.
A frequency-domain convolution UGen using two linearly interpolated fixed kernels. When a trigger is received, a linear fade will be performed from the previously used kernel (internally stored by the UGen) towards the snapshot of the current kernel content upon receiving the trigger.
The delay caused by the convolution when the kernel is a dirac impulse is equal to
frameSize - controlBlockSize
, so for aframeSize
of 2048 and a control-block size of 64, this is 1984 sample frames.Note: If a trigger is received before the previous fade is complete, the interpolation is broken and the kernel instead jumps straight to one of the two buffers.
- in
the realtime input to be convolved
- kernel
buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even if the trigger input is initially zero, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.
- trig
begins a fade to update the kernel on a change from non-positive to positive (<= 0 to >0).
- frameSize
size of the kernel. this must be a power of two. the FFT calculated internally by the UGen has a size of twice this value. The maximum allowed
frameSize
is 16384. (init-time only)- fadePeriods
fade duration expressed as number of convolved blocks. If the desired duration in seconds is
dur
, then the number of periods can be calculated asfadePeriods = dur * SampleRate.ir / frameSize
. (init-time only)
- See also
- final case class Convolution3(rate: Rate, in: GE, kernel: GE, trig: GE = 1, frameSize: GE) extends SingleOut with IsIndividual with Product with Serializable
A UGen for triggered convolution in the time domain.
A UGen for triggered convolution in the time domain.
Warning: This UGen seems currently broken (SC 3.6.3)
- in
the realtime input to be convolved
- kernel
buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even a trigger input of zero is used, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.
- frameSize
(init-time only)
- final case class Crackle(rate: Rate, chaos: GE = 1.5f) extends SingleOut with IsIndividual with Product with Serializable
A noise generator UGen based on a chaotic function.
A noise generator UGen based on a chaotic function. Output values lie between zero and one. Although this is a deterministic process, it is randomly seeded.
- chaos
A parameter of the chaotic function with useful values from just below 1.0 to just above 2.0. Towards 2.0 the sound crackles. Values greater than 2.01 are not safe, as the UGen can switch to outputting NaNs. A early more crackling sound appears with a value of
1.33
.
- See also
- final case class Crest(rate: Rate, in: GE, length: GE = 400, gate: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen that measures the "crest factor" of a time-domain signal.
A UGen that measures the "crest factor" of a time-domain signal. The "crest factor" is the ratio of the absolute peak to the absolute mean over a certain time period. In pseudocode:
crest = (samples.abs.max) / (samples.abs.mean)
For
Pulse
waves the value will be 1, because the mean and the maximum are the same. ForSinOsc
, the theoretical value is2.sqrt
. ForSaw
it is3.sqrt
. These exact values might not occur in practice, because of anti-aliasing and other sampling factors.This is not to be confused with
FFTCrest
which does the same thing for spectral data.This is a third-party UGen (MCLDUGens).
- in
signal to analyze, can be audio rate or control rate
- length
number of samples over which to take the measurement. A buffer of this size is created internally (so be careful about specifying a massive number here). (init-time only)
- gate
normally the statistic is calculated on every control block cycle. If one wants it less often (e.g. to reduce CPU usage), one can modulate this – calculation only occurs if gate is greater than zero.
- final case class CuspL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 1.9f, xi: GE = 0.0f) extends SingleOut with Product with Serializable
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+1] = a - b * sqrt(abs(x[n]))
- freq
Iteration frequency in Hertz
- a
Equation variable
- b
Equation variable
- xi
Initial value of x
- See also
- final case class CuspN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 1.9f, xi: GE = 0.0f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+1] = a - b * sqrt(abs(x[n]))
- freq
Iteration frequency in Hertz
- a
Equation variable
- b
Equation variable
- xi
Initial value of x
- See also
- final case class DC(rate: Rate, in: GE) extends SingleOut with Product with Serializable
A UGen that creates a constant signal at a given calculation rate.
A UGen that creates a constant signal at a given calculation rate.
- in
constant value to output, fixed at initialisation time. (init-time only)
- See also
- final case class DFM1(rate: Rate, in: GE, freq: GE = 440, res: GE = 0.1f, gain: GE = 1.0f, mode: GE = 0, noise: GE = 3.0E-4f) extends SingleOut with Product with Serializable
A digital filter UGen which aims at accurately modeling an analog filter.
A digital filter UGen which aims at accurately modeling an analog filter. It provides low-pass and high-pass modes, and the filter can be overdriven and will self-oscillate at high resonances.
This is a third-party UGen (TJUGens).
- in
Input signal to filter.
- freq
Cutoff frequency in Hertz.
- res
Resonance of the filter. Resonance is minimal at
0.0
and high at1.0
, above which the filter starts overdrive and sound saturated (e.g.1.2
).- gain
Linear gain applied to the input signal.
- mode
The filter can be used in low-pass (
0
) or high-pass (1
) mode.- noise
Amount (amplitude) of noise added to the model.
- final case class DNoiseRing(change: GE = 0.5f, chance: GE = 0.5f, shift: GE = 1, numBits: GE = 8, init: GE = 0) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
Demand rate UGen implementing a Wiard noise ring.
Demand rate UGen implementing a Wiard noise ring.
"In latter model synthesizers, digital noise sources began to appear in place of analog ones. Traditionally, a pseudo-random shift register set up for optimal length. By optimal length, it is meant that every state of all available bits will appear at some time, but the order is unknown. Essentially a counter that counts in an unknown order. This represents the maximum state of information "entropy" available for that number of bits. But music has close self-similarity over short periods of time. That is, it repeats itself with changes appearing slowly. This shift register generator is designed to give control of the rate of appearance of new information. It has a tight set of controls over how random it actually is and how fast change occurs." (source: http://mamonu.weebly.com/wiard-noisering.html)
This is a third-party UGen (DEINDUGens).
- change
probability of changing to a new value
- chance
probability of the new value becoming HIGH
- init
initial internal state
- final case class Dbrown(lo: GE = 0.0f, hi: GE = 1.0f, step: GE = 0.01f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.
A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.
- lo
minimum value (inclusive)
- hi
minimum value (inclusive)
- step
the maximum step a value can take from the previous value
- length
length of the sequence or
inf
- See also
- final case class Dbufrd(buf: GE, index: GE = 0, loop: GE = 1) extends SingleOut with DemandRated with IsIndividual with HasDoneFlag with Product with Serializable
A demand-rate UGen that reads out a buffer.
- final case class Dbufwr(in: GE, buf: GE, index: GE = 0, loop: GE = 1) extends SingleOut with DemandRated with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable
- final case class Dconst(sum: GE, in: GE, tolerance: GE = 0.001f) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total.
A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total. The last value will be truncated so that the sum of
Dconst
's output values will match the total exactly.- sum
the sum to reach. This may be a number, demand UGen or any other UGen. When a
Dconst
instance resets, one value will be taken for the sum, and it can't be modulated until the next reset.- in
a demand-rate stream, providing the output values
- tolerance
how close the running sum can get to stop the output: abs(running-sum - sum) <= tolerance. This is to avoid the problem of floating point rounding error preventing reaching the exact target sum.
- final case class Decay(rate: MaybeRate, in: GE, time: GE = 1.0f) extends SingleOut with Product with Serializable
An integrator UGen with exponential decay of past values.
An integrator UGen with exponential decay of past values. This is essentially the same as
Integrator
except that instead of supplying the coefficient directly, it is calculated from a 60 dB decay time. This is the time required for the integrator to lose 99.9 % of its value or -60dB.Note: This should not be confused with
Lag
which does not overshoot due to integration, but asymptotically follows the input signal.- in
input signal to be processed
- See also
- final case class Decay2(rate: MaybeRate, in: GE, attack: GE = 0.01f, release: GE = 1.0f) extends SingleOut with Product with Serializable
A integrator UGen with controllable attack and release times.
A integrator UGen with controllable attack and release times. While
Decay
has a very sharp attack and can produce clicks,Decay2
rounds off the attack by subtracting one Decay from another. It can be seen as equivalent toDecay.ar(in, release) - Decay.ar(in, attack)
Note: This should not be confused with
LagUD
which does not overshoot due to integration, but asymptotically follows the input signal.- in
input signal to be processed
- See also
- final case class DecodeB2(rate: Rate, numChannels: Int, w: GE, x: GE, y: GE, orient: GE = 0.5f) extends MultiOut with Product with Serializable
A two dimensional Ambisonics B-format decoding UGen.
A two dimensional Ambisonics B-format decoding UGen. It assumes a set of speakers in a regular polygon. The output channels are in clockwise order. The position of the first speaker is specified by the
orient
argument.- numChannels
the number of output channels to produce
- w
W (first) channel of B-format input signal
- x
X (second) channel of B-format input signal
- y
Y (third) channel of B-format input signal
- orient
orientation of the first channel. If zero, the first channel corresponds to the front vertex of the polygon. If the polygon does not have an edge at the front but a vertex, then an
orient
of 0.5 indicates that the first channel corresponds to the speaker left of the center.
- final case class DegreeToKey(rate: Rate, buf: GE, in: GE, octave: GE = 12) extends SingleOut with IsIndividual with Product with Serializable
A UGen that uses an input signal as an index into an octave repeating table of pitch classes.
A UGen that uses an input signal as an index into an octave repeating table of pitch classes. The input is truncated to an integer, and indices wrap around the table and shift octaves as they do.
- buf
buffer which contains the steps for each scale degree.
- in
input index signal
- octave
number of steps per octave in the scale.
- See also
- final case class DelTapRd(rate: Rate, buf: GE, phase: GE, delayTime: GE, interp: GE = 1) extends SingleOut with IsIndividual with Product with Serializable
Tap a delay line from a
DelTapWr
UGen.Tap a delay line from a
DelTapWr
UGen.- buf
Buffer where DelTapWr has written signal. Max delay time is based on buffer size.
- phase
the current phase of the DelTapWr UGen. This is the output of DelTapWr.
- delayTime
Delay time in seconds.
- interp
The kind of interpolation to be used. 1 is none, 2 is linear, 4 is cubic..
- See also
- final case class DelTapWr(rate: Rate, buf: GE, in: GE) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
Write to a buffer for a
DelTapRd
UGenWrite to a buffer for a
DelTapRd
UGen- buf
The buffer to write signal into. Max delay time is based on buffer size.
DelTapWr
outputs its current sample value for use in thephase
argument ofDelTapRd
.- in
The input signal.
- See also
- final case class Delay1(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
A UGen that delays the input by 1 audio frame or control period.
A UGen that delays the input by 1 audio frame or control period.
For audio-rate signals the delay is 1 audio frame, and for control-rate signals the delay is 1 control period.
Note: The first value output is not zero but the same as the first input value! In this respect the UGen behaves different than
DelayN
.- in
input to be delayed
- final case class Delay2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
A UGen that delays the input by 2 audio frames or control periods.
A UGen that delays the input by 2 audio frames or control periods.
For audio-rate signals the delay is 2 audio frames, and for control-rate signals the delay is 2 control periods.
Warning: the The first value output is zero, while both the second and the third value output equal the first input value! In this respect the UGen behaves different than
DelayN
.- in
input to be delayed
- final case class DelayC(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f) extends SingleOut with Product with Serializable
Simple delay line with cubic interpolation.
- final case class DelayL(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f) extends SingleOut with Product with Serializable
Simple delay line with linear interpolation.
- final case class DelayN(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f) extends SingleOut with Product with Serializable
Simple delay line with no interpolation.
- final case class Demand(rate: MaybeRate, trig: GE, in: GE, reset: GE = 0) extends MultiOut with HasDoneFlag with Product with Serializable
A UGen which polls results from demand-rate ugens when receiving a trigger.
A UGen which polls results from demand-rate ugens when receiving a trigger. When there is a trigger at the
trig
input, a value is demanded from each ugen in thein
input and output. The unit generators in the list should be demand-rate. When there is a trigger at the reset input, the demand rate ugens in the list are reset.Note: By design, a reset trigger only resets the demand ugens; it does not reset the value at Demand's output. Demand continues to hold its value until the next value is demanded, at which point its output value will be the first expected item in the
in
argument.Note: One demand-rate ugen represents a single stream of values, so that embedding the same ugen twice calls this stream twice per demand, possibly yielding different values. To embed the same sequence twice, either make sure the ugen is demanded only once, or create two instances of the ugen.
Warning: Demand currently seems to have problems with infinite sequences. As a workaround use a very large length instead. E.g. instead of
Dbrown(0, 1, inf)
useDbrown(0, 1, 0xFFFFFFFF)
!Warning: Demand seems to have a problem with initial triggers. For example
Demand.kr(Impulse.kr(0), 1)
will have a spurious zero value output first.- trig
trigger. Can be any signal. A trigger happens when the signal changes from non-positive to positive.
- in
a demand-rate signal (possibly multi-channel) which is read at each trigger
- reset
trigger. Resets the list of ugens (
in
) when triggered.
- final case class DemandEnvGen(rate: Rate, levels: GE, durs: GE, shapes: GE = 1, curvatures: GE = 0.0f, gate: GE = 1.0f, reset: GE = 1.0f, levelScale: GE = 1.0f, levelBias: GE = 0.0f, timeScale: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with Product with Serializable
An envelope generator UGen using demand-rate inputs for the envelope segments.
An envelope generator UGen using demand-rate inputs for the envelope segments. For each parameter of the envelope (levels, durations and shapes), values are polled every time a new segment starts.
- levels
demand-rate ugen (or other ugen) returning level values
- durs
demand-rate ugen (or other ugen) returning duration values
- shapes
demand-rate ugen (or other ugen) returning shape number for the envelope segment.
- curvatures
demand-rate ugen (or other ugen) returning curvature values. these are used for curveShape segments (shape number 5) and should be zero for other shapes.
- gate
a control rate gate: if gate is x >= 1, the ugen runs. if gate is 0 > x > 1, the ugen is released at the next level (according to doneAction). if gate is x <= 0, the ugen is sampled and held.
- reset
a trigger signal. a trigger occurs when passing from non-positive to positive. when the trigger amplitude is < 1, the input ugens (those that are demand-rated) are reset when the current segment ends. if the trigger amplitude is > 1, the reset is performed immediately.
- levelScale
demand-rate ugen returning level scaling values
- levelBias
demand-rate ugen returning level offset values
- timeScale
demand-rate ugen returning time scaling values
- doneAction
a done action performed when one of the demand-rated series ends
- See also
- final case class DetectIndex(rate: Rate, buf: GE, in: GE) extends SingleOut with IsIndividual with Product with Serializable
A UGen which determines the index in a buffer at which the value matches a given input signal.
A UGen which determines the index in a buffer at which the value matches a given input signal. If the input value is not found, it outputs -1.
For example, if the buffer contains values 5, 3, 2, 8, and the input signal is 3, the output will be 1. If the input is 3.001, the output will be -1. Unlike
IndexInBetween
, this UGen always searches through the entire buffer until the value is found or the end has been reached (returning -1).- See also
- final case class DetectSilence(rate: MaybeRate, in: GE, amp: GE = 1.0E-4f, dur: GE = 0.1f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with Product with Serializable
A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent").
A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent"). A silence is detected if the absolute sample values of the input remain less than or equal to the
amp
threshold for a consecutive amount of time given by thedur
argument.A value of
1
is output when this condition is met, and a value of0
is output when the condition is not met (i.e. at least one sample occurs in the input whose absolute value is greater thanamp
). Besides, when the output changes from zero to one, thedoneAction
is executed (unless it isdoNothing
).A special case is the initial condition of the UGen: It will begin with an output value of
0
(no silence detected), even if the input signal is below the amplitude threshold. It is only after the first input sample rising above the threshold that the actual monitoring begins and a trigger of1
or the firing of the done-action may occur.- in
input signal to be measured.
- amp
minimum amplitude threshold which must be exceeded for the input signal to be considered non-silent. (init-time only)
- dur
The duration in seconds for which the input signal must be continuously smaller than or equal to the threshold to be considered silent. (init-time only)
- doneAction
an action to be performed when the output changes from zero to one (silence detected).
- See also
- final case class Dgeom(start: GE = 1.0f, grow: GE = 2.0f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen that produces a geometric series.
- final case class Dibrown(lo: GE = 0, hi: GE = 1, step: GE = 1, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the
drunk
object in Max.A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the
drunk
object in Max.Note: The
length
parameter seems currently broken.- lo
minimum value (inclusive)
- hi
maximum value (inclusive)
- step
the maximum step a value can take from the previous value
- length
length of the sequence or
inf
. This is currently (SuperCollider 3.7.2) broken, and the sequence always has infinite length.
- See also
- final case class DiodeRingMod(rate: Rate, car: GE, mod: GE) extends SingleOut with Product with Serializable
Ring modulation UGen based on a physical model of a diode.
Ring modulation UGen based on a physical model of a diode.
This is a third-party UGen (DEINDUGens).
- car
carrier signal
- mod
modulator signal
- See also
- final case class DiskIn(rate: Rate, numChannels: Int, buf: GE, loop: GE = 0) extends MultiOut with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable
A UGen to stream in a signal from an audio file.
A UGen to stream in a signal from an audio file. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.
Note: The buffer size must be a multiple of (2 * the server's block size). See
Buffer#cue
for details.- numChannels
the amount of channels the file and the buffer will have. This is an Int and hence must be pre-determined. Different SynthDefs must be created for different numbers of channels.
- buf
the id of the buffer with the correct number of channels and frames
- loop
whether the file should loop when its end is reached
- final case class DiskOut(rate: Rate, buf: GE, in: GE) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
A UGen which writes a signal to a sound file on disk.
A UGen which writes a signal to a sound file on disk. To achieve this efficiently, a buffer is needs to be provides which is used to buffer the incoming signal.
Note: It might be that the buffer size must be a multiple of (2 * the server's block size). We haven't currently verified this, but to be safe, you should make sure this property is met.
The signal output by the UGen represents the number of frames written.
- buf
the buffer used internally by the UGen. this number of frames in the buffer must be a power of two (this is currently not checked!). The buffer must have been initialized with a
write
command whoseleaveOpen
argument is true. Note that the number of channels of the buffer and of the input signal must be the same, otherwiseDiskOut
will fail silently (and not write anything to the file). Warning: Crashes the server if the number of channels exceeds 32.- in
the signal to be recorded
- final case class Diwhite(lo: GE = 0, hi: GE = 1, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen that produces equally distributed random integer numbers.
- final case class Donce(in: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
- final case class Done(src: GE with HasDoneFlag) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable
A UGen which monitors another UGen to see when it is finished.
A UGen which monitors another UGen to see when it is finished. Some UGens, such as
PlayBuf
,RecordBuf
,Line
,XLine
,EnvGen
,Linen
,BufRd
,BufWr
,DbufRd
, and the Buffer delay UGens set a 'done' flag when they are finished playing. This UGen echoes that flag as an explicit output signal when it is set to track a particular UGen. When the tracked UGen changes to done, the output signal changes from zero to one.- src
the UGen to track
- final case class Dpoll(in: GE, label: String = "poll", run: GE = 1, trigId: GE = -1) extends SingleOut with DemandRated with HasSideEffect with IsIndividual with Product with Serializable
A demand rate UGen printing the current output value of its input to the console when polled.
A demand rate UGen printing the current output value of its input to the console when polled.
- in
the signal you want to poll
- label
a string or symbol to be printed with the polled value (init-time only)
- run
if 1 the polling is active, if 0 it is inactive.
- trigId
if greater then 0, a
"/tr"
OSC message is sent back to the client (similar toSendTrig
)
- final case class Drand(seq: GE, length: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen which outputs random elements from a sequence.
A demand-rate UGen which outputs random elements from a sequence.
Drand
allows duplicate elements to appear, whereasDxrand
forbids repetitions.- seq
A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.
- length
The number of items polled from the sequence
- final case class Dreset(in: GE, reset: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen that, when triggered, resets the state of its
in
argument.A demand-rate UGen that, when triggered, resets the state of its
in
argument.- in
a demand-rate UGen, producing values which are passed through, and which will be reset by this UGen
- reset
a demand-rate or any other UGen. When crossing from non-positive to positive,
Dreset
resets itsin
argument.
- final case class Dseq(seq: GE, repeats: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen which reproduces and repeats a sequence of values.
A demand-rate UGen which reproduces and repeats a sequence of values.
The arguments can be constant or any other ugens, where demand rate UGens are normally polled, proceeding to the next value when the sub-sequence ends.
- seq
A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.
- repeats
The number of repetitions of the entire sequence
- final case class Dser(seq: GE, length: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen which reproduces and repeats values of a sequence.
A demand-rate UGen which reproduces and repeats values of a sequence. It is very similar to
Dseq
, the difference being that thelength
parameter specifies the length of output sequence, not the number of repetitions of the input sequence. The input sequence is repeated iflength
is greater than the length of the input sequence.The arguments can be constant or any other ugens, where demand rate UGens are normally polled, proceeding to the next value when the sub-sequence ends.
- seq
A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.
- length
The number of items polled from the sequence
- final case class Dseries(start: GE = 0.0f, step: GE = 1.0f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen which produces an arithmetic (linear) series.
A demand-rate UGen which produces an arithmetic (linear) series.
The arguments can be constant or any other ugens.
- start
the start value of the series
- step
the incremental step by which the series changes. the step is added to the previous value on each demand.
- length
the number of elements to produces (maybe be infinite)
- final case class Dshuf(seq: GE, repeats: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen which outputs a randomly shuffled version of an input sequence.
A demand-rate UGen which outputs a randomly shuffled version of an input sequence. The sequence is only shuffled once, thus when
repeats
is greater than one, the same randomized sequence will be repeated, until the UGen is reset. This happens for example, when it is nested inside aDseq
, as shown in the example "reshuffle".- seq
A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.
- repeats
The number of repetitions of the entire sequence
- final case class Dstutter(n: GE, in: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
- final case class Dswitch(seq: GE, index: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
- final case class Dswitch1(seq: GE, index: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
- final case class Dust(rate: Rate, density: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable
A UGen generating random impulses with values ranging from
0
to+1
.A UGen generating random impulses with values ranging from
0
to+1
. The pulse duration is one sample for audio-rate and one block for control-rate operation.The approximate RMS energy is
(density/sr).log2 * 3 - 4.8
wheresr
is the sample-rate. For example, at 44.1 kHz, a density of 1000 Hz yields an RMS of approx. -21.2 dB.- density
the average number of impulses per second
- final case class Dust2(rate: Rate, density: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable
A UGen generating random impulses with values ranging from
-1
to+1
. - final case class Duty(rate: Rate, dur: GE = 1.0f, level: GE, reset: GE = 0, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with Product with Serializable
A UGen which polls results from demand-rate ugens in intervals specified by a duration input.
A UGen which polls results from demand-rate ugens in intervals specified by a duration input. A value from the
level
ugen is demanded and output according to a stream of duration values. When there is a trigger at the reset input, thelevel
and thedur
input are reset.- dur
the provider of time values. Can be a demand-rate ugen or any signal. The next poll is acquired after the previous duration.
- level
a demand-rate ugen providing the output values.
- reset
a trigger which resets the dur input (if demand-rated) and the the level input ugen. The reset input may also be a demand-rate ugen, in this case providing a stream of reset times.
- doneAction
a doneAction that is evaluated when the duration stream ends.
- Note
The argument order is different from its sclang counterpart.
- See also
- final case class Dwhite(lo: GE = 0.0f, hi: GE = 1.0f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen that produces random decimal numbers with a constant spectral density, equivalent to
WhiteNoise
for audio- or control-rate.A demand-rate UGen that produces random decimal numbers with a constant spectral density, equivalent to
WhiteNoise
for audio- or control-rate.- lo
minimum value (inclusive)
- hi
maximum value (inclusive)
- length
length of the sequence or
inf
- See also
- final case class Dxrand(seq: GE, length: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
A demand-rate UGen which outputs random elements from a sequence.
A demand-rate UGen which outputs random elements from a sequence.
Dxrand
forbid repetitions, whereasDrand
allows duplicate elements to appear.- seq
A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.
- length
The number of items polled from the sequence
- final case class Env(startLevel: GE, segments: Seq[Segment], releaseNode: GE = -99, loopNode: GE = -99) extends EnvLike with Product with Serializable
- sealed trait EnvFactory[V] extends ProductReader[V]
- final case class EnvGen(rate: Rate, envelope: GE, gate: GE = 1, levelScale: GE = 1.0f, levelBias: GE = 0.0f, timeScale: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with HasDoneFlag with Product with Serializable
An envelope generator UGen.
An envelope generator UGen. It uses a break point description in its
envelope
input, typically coming from anEnv
object. The envelope may be re-triggered using thegate
input. Upon start and upon re-triggering, theenvelope
,levelScale
,levelBias
andtimeScale
parameters are polled and remain constant for the duration of the envelope.To construct a manual envelope without the use of the
Env
class, the format should be as follows:val env = Seq[GE](startLevel, numSegments, releaseNode, loopNode, targetLevel1, duration1, curveType1, curvature1, targetLevel2, duration2, curveType2, curvature2, ...)
Where the curve-type is one of
Curve.step.id
,Curve.lin.id
,Curve.exp.id
, etc. The curvature values are only relevant for the parametric curve type. ThereleaseNode
andloopNode
parameters are segment indices or the special value-99
indicating that there are no release or loop segments.Note: The actual minimum duration of a segment is not zero, but one sample step for audio rate and one block for control rate. This may result in asynchronicity when in two envelopes of different number of levels, the envelope times add up to the same total duration. Similarly, when modulating times, the new time is only updated at the end of the current segment; this may lead to asynchronicity of two envelopes with modulated times.
- envelope
the description of the envelope break-points. Typically you pass an instance of
Env
which will then automatically expand to the correct format.- gate
triggers the envelope and holds it open while greater than zero. If the envelope is of fixed duration (e.g.
Env.linen
,Env.perc
), thegate
argument is used as a simple trigger. If it contains a sustained segment (e.g.Env.adsr
,Env.asr
), the envelope is held open until the gate becomes 0, at which point is released. Ifgate
is less than zero, a release is enforced with duration-1.0 - gate
.- levelScale
amplitude factor with which the nominal envelope is multiplied.
- levelBias
amplitude offset which is added to the nominal envelope.
- timeScale
time scale factor with which the envelope segment durations are multiplied.
- doneAction
action to be performed when the envelope reaches its end point.
- sealed trait EnvLike extends GE
- final case class ExpRand(lo: GE = 0.01f, hi: GE = 1.0f) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable
A scalar UGen that generates a single random decimal value, using an exponential distribution from
lo
tohi
. - final case class FBSineC(rate: Rate, freq: GE = Nyquist(), im: GE = 1.0f, fb: GE = 0.1f, a: GE = 1.1f, c: GE = 0.5f, xi: GE = 0.1f, yi: GE = 0.1f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0 , and a = 1 a normal sine wave results.
- freq
Iteration frequency in Hertz
- im
Index multiplier amount
- fb
Feedback amount
- a
Phase multiplier amount
- c
Phase increment amount
- xi
Initial value of x
- yi
Initial value of y
- final case class FBSineL(rate: Rate, freq: GE = Nyquist(), im: GE = 1.0f, fb: GE = 0.1f, a: GE = 1.1f, c: GE = 0.5f, xi: GE = 0.1f, yi: GE = 0.1f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.
- freq
Iteration frequency in Hertz
- im
Index multiplier amount
- fb
Feedback amount
- a
Phase multiplier amount
- c
Phase increment amount
- xi
Initial value of x
- yi
Initial value of y
- final case class FBSineN(rate: Rate, freq: GE = Nyquist(), im: GE = 1.0f, fb: GE = 0.1f, a: GE = 1.1f, c: GE = 0.5f, xi: GE = 0.1f, yi: GE = 0.1f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.
- freq
Iteration frequency in Hertz
- im
Index multiplier amount
- fb
Feedback amount
- a
Phase multiplier amount
- c
Phase increment amount
- xi
Initial value of x
- yi
Initial value of y
- final case class FFT(buf: GE, in: GE, hop: GE = 0.5f, winType: GE = 0, active: GE = 1, winSize: GE = 0) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable
A UGen performing short-time forward fourier transformations.
A UGen performing short-time forward fourier transformations. In order to properly link the spectral ugens (
PV_...
), you should begin by using the output of each UGen (which is just the fft buffer identifier), and use that as buffer input of the next UGen. That way, the UGen graph is correctly sorted. E.g.IFFT(PV_...(FFT(buf, in)))
.The UGen will initially output zero until the first FFT can be performed. This is the case after
hop * fftSize
. Thus, for a default fft buffer size of 1024 and ahop
of 0.5, and for a default control block size of 64, for the first 1024*0.5/64 = 8 control blocks the UGen will output zero. This also implies that the first FFT in this case is performed on the first 512 samples of thein
signal (prepended by 512 zeros). In other words, the first 'full' FFT of the input happens after fftSize/controlBlockSize cycles, no matter what hop size was chosen.If you use FFT for performing signal analysis and not phase vocoder effects, make sure you change the window type accordingly.
- buf
The buffer to use for writing the FFT to. The size must be a power of two. Since
FFT
operates at control rate (also being a power of two), the buffer should probably be at least as long as the control block size. (init-time only)- in
The time domain signal to be transformed into the spectral domain.
- hop
A factor determining the step size between successive FFTs. That is, FFTs are performed every fftSize * hop sample frames. The default of 0.5 means thus a 50% overlap, while a hope of 1.0 means no overlapping. Choosing 0.0 will most likely crash the server! (init-time only)
- winType
The window function applied before each FFT is taken. The default of
0
is a sine window which is good for phase vocoder applications (using thePV_...
UGens). For analysis applications, you may want to use-1
which is a rectangle window (effectively no windowing) or1
which is a Hann window. A Hann window gives perfect overlap-add reconstruction for a hope size of 0.5 (or 0.25 etc.) (init-time only)- active
This parameter can be temporarily set to <= 0 to pause the FFT operation.
- winSize
With the default value of zero, the window size equals the fft size. If you wish to perform zero padding, an explicit window size can be specified. (init-time only)
- See also
- final case class FFTTrigger(buf: GE, hop: GE = 0.5f, polar: GE = 0) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable
A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal.
A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal. This is useful if you want to provide a buffer whose content had already been transformed into the Fourier domain.
- buf
the identifier of the buffer to use (init-time only)
- hop
the hop size for timing triggers (init-time only)
- polar
whether the complex buffer content is given in cartesian coordinates (0) or in polar coordinates (1) (init-time only)
- final case class FOS(rate: MaybeRate, in: GE, a0: GE = 0.0f, a1: GE = 0.0f, b1: GE = 0.0f) extends SingleOut with Product with Serializable
A first order filter section UGen.
- final case class FSinOsc(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable
A sine oscillator UGen using a fast approximation.
A sine oscillator UGen using a fast approximation. It uses a ringing filter and is less CPU expensive than
SinOsc
. However, the amplitude of the wave will vary with frequency. Generally the amplitude will go down when the frequency rises and it will go up as if the frequency is lowered.Warning: In the current implementation, the amplitude can blow up if the frequency is modulated by certain alternating signals (e.g. abruptly by
TRand
).- freq
frequency in Hertz
- iphase
initial phase of the oscillator in radians. This cannot be modulated. A value of
0.5 Pi
means the output starts at +1. A value of1.5 Pi
means the output starts at -1, (init-time only)
- final case class Flatten(elem: GE) extends GE.Lazy with Product with Serializable
A graph element that flattens the channels from a nested multi-channel structure.
A graph element that flattens the channels from a nested multi-channel structure.
- elem
the element to flatten
- final case class Fold(rate: Rate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen that constrains a signal to a given range, by "folding" values outside the range.
A UGen that constrains a signal to a given range, by "folding" values outside the range. This is similar to the
fold2
binary operator but permits both a lower range valuelo
and an upper range valuehi
.Folding can be understood as "reflecting" around the boundaries. For example, if the upper margin is 3, then if an input value exceeds 3, the excess is negatively reflected; 3.1 becomes 2.9, 3.2 becomes 2.8, etc. until the lower margin is reached again where another reflection occurs. Likewise, if the lower margin is 1, then if an input value falls below 1, the undershoot is reflected; 0.9 becomes 1.1, 0.8 becomes 1.2, etc. until the upper margin is reached again where another reflection occurs.
- in
input signal to constrain
- lo
lower margin of folding
- hi
upper margin of folding
- final case class FoldIndex(rate: Rate, buf: GE, in: GE = 0) extends SingleOut with IsIndividual with Product with Serializable
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the
in
argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are "folded" inside the valid range. Folding means reflecting the excess at the valid range's boundaries.For example, if the buffer has four samples, index 4 is wrapped to index 2 (the excess beyond the maximum index of 3 is 4 - 3 = 1, and the excess is folded so that and 3 - 1 = 2), index 5 is folded to index 1, index -1 is folded to index 1, index -2 is folded to index 2, etc.
While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the
Index
UGen for details.- buf
The buffer to read from.
- in
The sample index into the buffer. This is truncated to an integer automatically.
- final case class Formant(rate: Rate, fundFreq: GE = 440.0f, formFreq: GE = 1760.0f, bw: GE = 880.0f) extends SingleOut with Product with Serializable
A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.
A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.
- fundFreq
Fundamental frequency in Hertz. Read at control-rate, so if input is audio-rate, it will be sub-sampled.
- formFreq
Formant frequency in Hertz. This determines the overtone(s) most prominently perceived. Read at control-rate, so if input is audio-rate, it will be sub-sampled.
- bw
Pulse width frequency in Hertz. Controls the bandwidth of the formant. Must be greater than or equal to
fundFreq
. Read at control-rate, so if input is audio-rate, it will be sub-sampled.
- final case class Formlet(rate: MaybeRate, in: GE, freq: GE = 440.0f, attack: GE = 1.0f, decay: GE = 1.0f) extends SingleOut with Product with Serializable
A FOF-like resonant filter UGen.
A FOF-like resonant filter UGen. Its impulse response is like that of a sine wave with a
Decay2
envelope over it. It is possible to control the attack and decay times.Formlet
is equivalent to:Ringz(in, freq, decay) - Ringz(in, freq, attack)
The great advantage to this filter over FOF (Fonction d'onde formantique) is that there is no limit to the number of overlapping grains since the grain is just the impulse response of the filter.
Note:
Ringz
and derived UGensKlank
andFormlet
produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.- in
input signal to be filtered
- freq
resonant frequency in Hertz
- attack
the 60 dB attack time in seconds
- decay
the 60 dB decay time in seconds
- final case class Free(trig: GE, node: GE) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable
A UGen that, when triggered, frees a given node.
- final case class FreeSelf(trig: GE) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable
A UGen that, when triggered, frees enclosing synth.
A UGen that, when triggered, frees enclosing synth. It frees the enclosing synth when the input signal crosses from non-positive to positive.
Note that if the trigger is initially high the UGen will not react. For example,
FreeSelf.kr("foo".kr)
will not work if the control is initially1
. A work-around is to wrap the input in this case in aTrig
object:FreeSelf.kr(Trig.kr("foo".kr))
. This is most likely a bug.This UGen outputs its input signal for convenience.
- trig
the input signal which will trigger the action.
- final case class FreeSelfWhenDone(src: GE with HasDoneFlag) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable
A UGen that, when its input UGen is finished, frees enclosing synth.
A UGen that, when its input UGen is finished, frees enclosing synth. This is essentially a shortcut for
FreeSelf.kr(Done.kr(src))
, so instead of providing a trigger signal it reads directly the done flag of an appropriate ugen (such asLine
orPlayBuf
).This UGen outputs its input signal for convenience.
- src
the input UGen which when finished will trigger the action.
- final case class FreeVerb(in: GE, mix: GE = 0.33f, room: GE = 0.5f, damp: GE = 0.5f) extends SingleOut with AudioRated with Product with Serializable
A monophonic reverb UGen.
A monophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator.
- in
input signal to reverberate
- mix
dry/wet balance from zero (only dry) to one (only wet)
- room
room size
- damp
high frequency attenuation (1 is maximum attenuation)
- final case class FreeVerb2(inL: GE, inR: GE, mix: GE = 0.33f, room: GE = 0.5f, damp: GE = 0.5f) extends MultiOut with AudioRated with Product with Serializable
A stereophonic reverb UGen.
A stereophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator. However, if the same input is used for left and right channel, the output channels are different and uncorrelated. There is also some cross-feed between the two channels.
- inL
left channel of input signal to reverberate
- inR
right channel of input signal to reverberate
- mix
dry/wet balance from zero (only dry) to one (only wet)
- room
room size
- damp
high frequency attenuation (1 is maximum attenuation)
- final case class FreqShift(rate: Rate, in: GE, freq: GE = 0.0f, phase: GE = 0.0f) extends SingleOut with Product with Serializable
A frequency shifting UGen.
A frequency shifting UGen. It implements single sideband (SSB) amplitude modulation, also known as frequency shifting, but not to be confused with pitch shifting. Frequency shifting moves all the components of a signal by a fixed amount but does not preserve the original harmonic relationships.
- freq
the shift amount in Hertz. Positive values shift upwards, negative values shift downwards.
- phase
a phase parameter in radians (0 to 2 Pi).
- See also
- final case class Friction(rate: MaybeRate, in: GE, friction: GE = 0.5f, spring: GE = 0.414f, damp: GE = 0.313f, mass: GE = 0.1f, beltMass: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen implementing a physical model of a system with dry-friction.
A UGen implementing a physical model of a system with dry-friction. A chaotic filter.
The input is treated as the driving force in a physical model of a mass resting on a belt, which can stick or slip relative to the belt (depending on the friction between the two). The input represents the position of the belt, and the mass is held approximately in place by a spring and a damper. The output is the position of the mass, which in very high-friction situations will be exactly the same as the input – but when the other forces can overcome the friction then stick-and-slip alternations will typically occur.
Note that DC offset will have a qualitative effect on the system's behaviour (because of the spring being stretched), so feel free to experiment with adding/removing DC.
The model is inspired by the one considered in this research article: A. Luo and B. Gegg, Dynamics of a harmonically excited oscillator with dry-friction on a sinusoidally time-varying, traveling surface, International Journal of Bifurcation and Chaos, 16 (2006), pp. 3539–3566.
To create the system studied in that paper (which analyses chaotic stick-and-slip oscillations), the input should be a sinusoid added to an ever-increasing ramp value. But for musical effects you can do different things.
This is a third-party UGen (MCLDUGens).
- final case class GESeq(elems: IndexedSeq[GE]) extends GE with Product with Serializable
- final case class GVerb(in: GE, roomSize: GE = 10.0f, revTime: GE = 3.0f, damping: GE = 0.5f, inputBW: GE = 0.5f, spread: GE = 15.0f, dryLevel: GE = 1.0f, earlyRefLevel: GE = 0.7f, tailLevel: GE = 0.5f, maxRoomSize: GE = 300.0f) extends MultiOut with AudioRated with Product with Serializable
A stereophonic reverb UGen.
A stereophonic reverb UGen. It is based on the GVerb LADSPA effect by Juhana Sadeharju.
Note: A CPU spike may occur when the synth is instantiated. Warning: The UGen has a bug which results in loud noise if the room size is increased during playback. It seems safe to start with a large room size and decrease the value during playing. Warning: The UGen may crash the server if
roomSize
becomes larger thanmaxRoomSize
.- roomSize
Size of the virtual room in meters. It must not be greater than
maxRoomSize
. Note that quick changes inroomSize
may result in zipper noise and an audible Doppler effect.- revTime
reverberation time in seconds.
- damping
high frequency attenuation (1 is maximum attenuation)
- inputBW
high frequency attenuation of the input signal (0 to 1)
- spread
stereo spread of the reverb signal. Units?
- dryLevel
amount of dry signal
- earlyRefLevel
amount of early reflections
- tailLevel
amount of late reverberation
- maxRoomSize
maximum value that
roomSize
can take. This is used for the early reflection delay lines and is only read at initialization time. (init-time only)
- final case class Gate(rate: MaybeRate, in: GE, gate: GE) extends SingleOut with Product with Serializable
A gate or hold UGen.
A gate or hold UGen. It allows the input signal value to pass when the
gate
argument is positive, otherwise it holds last value.Before the first high gate value is registered, this UGen outputs zero.
- in
the input signal to gate
- gate
the signal specifying whether to pass the input signal (when greater than zero) or whether to close the gate and hold the last value (when less than or equal to zero)
- See also
- final case class GbmanL(rate: Rate, freq: GE = Nyquist(), xi: GE = 1.2f, yi: GE = 2.1f) extends SingleOut with Product with Serializable
- freq
Iteration frequency in Hertz
- yi
Initial value of y
- final case class GbmanN(rate: Rate, freq: GE = Nyquist(), xi: GE = 1.2f, yi: GE = 2.1f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = 1 - y[n] + abs(x[n]) y[n+1] = x[n]
The behavior of the system is only dependent on its initial conditions. Reference: Devaney, R. L. "The Gingerbreadman." Algorithm 3, 15-16, Jan. 1992.
- freq
Iteration frequency in Hertz
- yi
Initial value of y
- See also
- final case class Gendy1(rate: Rate, ampDist: GE = 1.0f, durDist: GE = 1.0f, adParam: GE = 1.0f, ddParam: GE = 1.0f, minFreq: GE = 440.0f, maxFreq: GE = 660.0f, ampScale: GE = 0.5f, durScale: GE = 0.5f, initCPs: GE = 12, kNum: GE = 12) extends SingleOut with IsIndividual with Product with Serializable
- final case class Gendy2(rate: Rate, ampDist: GE = 1.0f, durDist: GE = 1.0f, adParam: GE = 1.0f, ddParam: GE = 1.0f, minFreq: GE = 440.0f, maxFreq: GE = 660.0f, ampScale: GE = 0.5f, durScale: GE = 0.5f, initCPs: GE = 12, kNum: GE = 12, a: GE = 1.17f, c: GE = 0.31f) extends SingleOut with IsIndividual with Product with Serializable
- final case class Gendy3(rate: Rate, ampDist: GE = 1.0f, durDist: GE = 1.0f, adParam: GE = 1.0f, ddParam: GE = 1.0f, freq: GE = 440.0f, ampScale: GE = 0.5f, durScale: GE = 0.5f, initCPs: GE = 12, kNum: GE = 12) extends SingleOut with IsIndividual with Product with Serializable
- final case class Goertzel(rate: Rate, in: GE, length: GE = 1024, freq: GE, hop: GE = 1.0f) extends MultiOut with Product with Serializable
A UGen implementing the Goertzel algorithm which is a way to calculate the magnitude and phase of a signal's content at a single specified frequency.
A UGen implementing the Goertzel algorithm which is a way to calculate the magnitude and phase of a signal's content at a single specified frequency. It is the equivalent of running an FFT, and then only looking at the output corresponding to a single bin. If one is only interested in a small number of bins, then it is more efficient; if one is interested in the majority of bins, one typically wants to do an FFT instead.
This is a third-party UGen (MCLDUGens).
- length
used in the same way as an FFT buffer size: The larger this value, the better the frequency resolution, but the worse the time resolution.
- freq
target frequency in Hertz. (init-time only)
- hop
same meaning as in the FFT UGen. Supply a value between zero and one, for the amount of overlap between Goertzel "frames". The default is a hop of 1 (meaning no overlap between frames). If you specify 0.5, then the analysis value will be produced twice as often; 0.25, four times as often. (init-time only)
- final case class GrainBuf(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, buf: GE, speed: GE = 1.0f, pos: GE = 0.0f, interp: GE = 2, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
A granular synthesis UGen taking sound stored in a buffer.
A granular synthesis UGen taking sound stored in a buffer. Another buffer can be used to provide an amplitude envelope. The input sound buffer must be monophonic, but output may be multi-channel, using a panorama control.
All arguments except
numChannels
andmaxGrain
are polled at grain creation (trigger) time.- numChannels
the number of channels to output. If
1
, a monophonic signal is returned and thepan
argument is ignored.- trig
a control- or audio-rate trigger to start a new grain. For audio-rate, timing is sample frame accurate.
- dur
grain duration in seconds
- buf
buffer holding a mono audio signal portions of which are read as grains
- speed
playback speed of the grain, where
1.0
is original rate,0.5
is half speed etc.- pos
grain start position, where
0
is beginning and1
is the end of the input buffer- interp
interpolation type when using pitch-shifting via
speed
.1
for no interpolation (nearest sample),2
for linear interpolation, and4
for cubic interpolation.- pan
panning position when
numChannels
is greater than one. Equivalent to the pan position ofPan2
(for stereo output) orPanAz
(for more than two channels)- envBuf
identifier of a buffer containing a signal to use for the grain envelope. The default value of
-1
means that a built-in Hann envelope is used.- maxGrains
maximum number of overlapping grains that can be used at a given time. This value is set at the UGens init time and cannot be modified later. Lower value mean that less memory is used.
- final case class GrainFM(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, carFreq: GE = 440.0f, modFreq: GE = 200.0f, index: GE = 1.0f, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
- final case class GrainIn(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, in: GE, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
- final case class GrainSin(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, freq: GE = 440.0f, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
- final case class GrayNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable
A noise generator UGen which results from flipping random bits in a word.
A noise generator UGen which results from flipping random bits in a word. The resulting waveform looks like a sample-and-hold function with values between
-1
and+1
(before being multiplied bymul
).This type of noise has a high RMS level relative to its peak to peak level. With approx. -4.8 dB, the RMS is the same as white noise, but the spectrum is emphasized towards lower frequencies.
- mul
Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel
mul
argument will cause the generation of multiple independent noise generators.
- final case class Greyhole(rate: Rate, inL: GE, inR: GE, delayTime: GE = 2.0f, damp: GE = 0.0f, size: GE = 1.0f, diff: GE = 0.707f, feedback: GE = 0.9f, modDepth: GE = 0.1f, modFreq: GE = 2.0f) extends MultiOut with Product with Serializable
A complex echo-like effect UGen, inspired by the classic Eventide effect of a similar name.
A complex echo-like effect UGen, inspired by the classic Eventide effect of a similar name. The effect consists of a diffuser (like a mini-reverb) connected in a feedback system with a long modulated delay-line. Excels at producing spacey washes of sound.
Note: You may need to increase the server's real-time memory
This is a third-party UGen (DEINDUGens).
- inL
left input signal
- inR
right input signal
- delayTime
approximate delay time in seconds. (0.1..60)
- damp
damping of high-frequencies as the delay decays. 0 is no damping, 1 is very strong damping (0..1)
- size
scales the size of delay-lines, producing the impression of a larger or smaller space. Values below 1 can sound quite metallic. (0.5..5)
- diff
shape of echo patterns produced by the diffuser. At very low values, the diffuser acts like a delay-line whose length is controlled by the
size
parameter. Medium values produce a slow build-up of echoes, giving the sound a reversed-like quality. Values of 0.707 or greater than produce smooth exponentially decaying echoes. (0..1)- feedback
amount of feedback through the system. Sets the number of repeating echoes. A setting of 1.0 produces infinite sustain. (0..1)
- modDepth
depth of delay-line modulation. Use in combination with
modFreq
to produce chorus and pitch-variations in the echoes. (0..1)- modFreq
frequency of delay-line modulation. Use in combination with
modDepth
to produce chorus and pitch-variations in the echoes. (0..10)
- See also
- final case class HPF(rate: MaybeRate, in: GE, freq: GE = 440.0f) extends SingleOut with Product with Serializable
A second order high pass filter UGen.
- final case class HPZ1(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
A two point difference filter UGen.
- final case class HPZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
three point difference filter UGen.
- final case class Hasher(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
A UGen that returns a unique output value from -1 to +1 for each input value according to a hash function.
A UGen that returns a unique output value from -1 to +1 for each input value according to a hash function. The same input value will always produce the same output value. The input values can have any range.
- in
input to calculate the hash function for
- final case class HenonC(rate: Rate, freq: GE = Nyquist(), a: GE = 1.4f, b: GE = 0.3f, x0: GE = 0.0f, x1: GE = 0.0f) extends SingleOut with Product with Serializable
A cubic-interpolating sound generator based on the difference equation:
A cubic-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
- freq
Iteration frequency in Hertz
- a
Equation variable
- b
Equation variable
- x0
Initial value of x
- x1
Second value of x
- final case class HenonL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.4f, b: GE = 0.3f, x0: GE = 0.0f, x1: GE = 0.0f) extends SingleOut with Product with Serializable
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
- freq
Iteration frequency in Hertz
- a
Equation variable
- b
Equation variable
- x0
Initial value of x
- x1
Second value of x
- final case class HenonN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.4f, b: GE = 0.3f, x0: GE = 0.0f, x1: GE = 0.0f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
- freq
Iteration frequency in Hertz
- a
Equation variable
- b
Equation variable
- x0
Initial value of x
- x1
Second value of x
- final case class Hilbert(rate: Rate, in: GE) extends MultiOut with Product with Serializable
A Hilbert transform UGen.
A Hilbert transform UGen. This transformation produces two signals from a given input with identical frequency content, but with their respective phases shifted to be 90 degrees apart (0.5 pi radians).
The two signals output by
Hilbert
correspond to the real and imaginary part of the complex transformed signal. Due to the method used (an IIR filter), distortion occurs in the upper octave of the frequency spectrum.The transform can be used to implemented single-side-band (SSB) modulation, but a dedicated UGen
FreqShift
is already provided for this case.- in
input signal to be processed
- See also
- final case class Hopf(rate: MaybeRate, in: GE, coupling: GE, radius: GE = 1.0f) extends MultiOut with Product with Serializable
A UGen based on Hopf bifurcations that tries to synchronize to an input signal.
A UGen based on Hopf bifurcations that tries to synchronize to an input signal.
This is a third-party UGen (kuramoto).
- in
Input signal (force) to track.
- coupling
Strength of coupling.
- radius
Limit cycle radius (amplitude attractor).
- See also
- final case class IEnv(startLevel: GE, segments: Seq[Segment], offset: GE = 0f) extends EnvLike with Product with Serializable
- final case class IEnvGen(rate: Rate, envelope: GE, index: GE) extends SingleOut with Product with Serializable
Envelope generator UGen with random access index pointer into the break-point function.
Envelope generator UGen with random access index pointer into the break-point function.
Warning: The envelope must be generated using
IEnv
notEnv
.IEnv
has a completely different format. Using the wrong format (Env
) may crash the server.To construct a manual envelope without the use of the
IEnv
class, the format should be as follows:val env = Seq[GE](offset, startLevel, numSegments, totalDuration, duration1, curveType1, curvature1, targetLevel1, duration2, curveType2, curvature2, targetLevel2 ...)
- envelope
the description of the envelope break-points. Typically you pass an instance of
IEnv
which will then automatically expand to the correct format.- index
index point into the envelope, given as time in seconds
- final case class IFFT(rate: Rate, chain: GE, winType: GE = 0, winSize: GE = 0) extends SingleOut with IsIndividual with Product with Serializable
A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.
A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.
- chain
reference to the spectral signal, returned as a buffer-identifier from
FFT
or thePV_...
UGens.- winType
The window function applied after each IFFT is taken. The default of
0
is a sine window,-1
is a rectangle window, and1
is a Hann window. (init-time only)- winSize
With the default value of zero, the window size equals the fft size. If you wish to perform zero padding, an explicit window size can be specified. (init-time only)
- See also
- final case class IRand(lo: GE = 0, hi: GE = 127) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable
A scalar UGen that generates a single random integer value, using a uniform distribution from
lo
tohi
. - final case class Impulse(rate: Rate, freq: GE = 440.0f, phase: GE = 0.0f) extends SingleOut with Product with Serializable
A non-band-limited generator UGen for single sample impulses.
- final case class In(rate: Rate, bus: GE, numChannels: Int = 1) extends MultiOut with IsIndividual with Product with Serializable
A UGen that reads a signal from a bus.
A UGen that reads a signal from a bus. Whether an audio- or control-bus is used depends on the rate of the UGen.
In.ar
andIn.kr
behave differently with respect to signals left on the bus in the previous calculation cycle (control block):In.ar
can access audio signals that were generated in the current calculation cycle by synths appearing earlier in the node tree. It does not read signals produced by nodes in the previous calculation cycle (i.e. synths appearing later in the node tree), the input would instead be zero. To allow such "feedback",InFeedback
can be used.In contrast,
In.kr
does not distinguish between "new" and "old" data: It will always read the most recent value found on the bus, whether it was generated earlier in this calculation cycle, left over from the last one, or set before by the client.Note: The server uses the first
NumOutputBuses
channels to write to the sound card, followed by anotherNumInputBuses
to read from the sound card. For convenience, the pseudo-UGensPhysicalOut
andPhysicalIn
can be used.- bus
index of the bus to read from. When
numChannels
is greater than one, the other channels or read from the adjacent indices.- numChannels
number of channels to read
- final case class InFeedback(bus: GE, numChannels: Int = 1) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.
A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.
Audio buses adhere to the concept of a cycle timestamp, which increases for each audio block calculated. When the various output ugens (
Out
,OffsetOut
,XOut
) write data to a bus, they mix it with any data from the current cycle, but overwrite any data from the previous cycle. (ReplaceOut
overwrites all data regardless.) Thus depending on node order and what synths are writing to the bus, the data on a given bus may be from the current cycle or be one cycle old at the time of reading.In.ar
checks the timestamp of any data it reads in and zeros any data from the previous cycle (for use within that node; the data remains on the bus). This is fine for audio data, as it avoids feedback, but for control data it is useful to be able to read data from any place in the node order. For this reasonIn.kr
also reads data that is older than the current cycle.In some cases one might also want to read audio from a node later in the current node order. This can be achieved with
InFeedback
. It reads from the previous cycle, and hence introduces a delay of one block size, which by default is 64 sample frames (equal to about 1.45 ms at 44.1 kHz sample rate).Note that no delay occurs when the bus contains a signal which has been written already in the current cycle. The delay is only introduced when no present signal exists.
- bus
the index of the audio bus to read in from.
- numChannels
the number of channels (i.e. adjacent buses) to read in. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs.
- See also
- final case class InRange(rate: Rate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen that tests if a signal is within a given range.
- final case class InRect(rate: Rate, x: GE, y: GE, left: GE = 0.0f, top: GE = 0.0f, right: GE = 1.0f, bottom: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen that tests if two signals lie both within a given ranges.
A UGen that tests if two signals lie both within a given ranges. The two input signals can be understood as horizontal and vertical coordinates, therefore the test become one that determines whether the input is within a given "rectangle".
If
x >= left
andx <= right
andy > top
andy <= bottom
, outputs 1.0, otherwise outputs 0.0.- x
"horizontal" signal to test
- y
"vertical" signal to test
- left
lower margin of horizontal test range (inclusive)
- top
lower margin of vertical test range (inclusive)
- right
upper margin of horizontal test range (inclusive)
- bottom
upper margin of vertical test range (inclusive)
- final case class InTrig(bus: GE, numChannels: Int = 1) extends MultiOut with ControlRated with IsIndividual with Product with Serializable
A UGen which generates a trigger anytime a control bus is set.
A UGen which generates a trigger anytime a control bus is set.
Any time the bus is "touched" i.e. has its value set (using
"/c_set"
etc.), a single impulse trigger will be generated. Its amplitude is the value that the bus was set to. Note that if a signal is continuously written to that bus, for instance usingOut.kr
, only one initial trigger is generated once that ugen starts writing, but no successive triggers are generated.- bus
the index of the control bus to read in from.
- numChannels
the number of channels (i.e. adjacent buses) to read in. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs.
- See also
- final case class Index(rate: Rate, buf: GE, in: GE = 0) extends SingleOut with IsIndividual with Product with Serializable
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the
in
argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are clipped to the valid range.While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, index 0 corresponds to frame 0, channel 0, index 1 correspond to frame 0, channel 1, index 2 corresponds to frame 1, channel 0, and index 3 corresponds to frame 1, channel 1.
- buf
The buffer to read from.
- in
The sample index into the buffer. This is truncated to an integer automatically.
- final case class IndexInBetween(rate: Rate, buf: GE, in: GE) extends SingleOut with IsIndividual with Product with Serializable
A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal.
A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal. The output index is a decimal whose fractional part is suitable for linearly interpolating between the buffer slot values.
For example, if the Buffer contains values 3, 21, 25, 26 and the input signal has the value 22, then the output will be 1.25, because the value 22 is in-between the values stored at indices 1 and 2 and the linear location of 22 is one-quarter of the way along the interval between them: 21 * (1 - 0.25) + 25 * (1 - 0.75) = 22.
If the input value is smaller than the first sample, the output will be zero. If the input value is larger than any sample in the buffer, the output will be the buffer size minus one.
While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, and the algorithm finds the frame 1 in channel 0, the reported index is 2 (frame * numChannels + channel).
IndexInBetween
is the complement of theIndexL
UGen.- buf
The buffer to search in.
- in
The input signal whose value is looked up in the buffer.
- See also
- final case class IndexL(rate: Rate, buf: GE, in: GE = 0) extends SingleOut with IsIndividual with Product with Serializable
A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.
A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.
It uses the
in
argument as index into the buffer. Out-of-range index values are clipped to the valid range. If the index has a fractional part, it is used to interpolate between the buffer index at the floor and the buffer index at the ceiling of the index argument.While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the
Index
UGen for details.- buf
The buffer to read from.
- in
The sample index into the buffer. This can have a fractional part.
- See also
- final case class InsideOut(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
A UGen that produces distortion by subtracting the input signal's magnitude from 1.
A UGen that produces distortion by subtracting the input signal's magnitude from 1.
If the input is positive, it outputs (+1 - input). If the input is negative, it outputs (-1 - input).
This is a third-party UGen (MCLDUGens).
- in
input signal to be distorted
- final case class Integrator(rate: MaybeRate, in: GE, coeff: GE = 1.0f) extends SingleOut with Product with Serializable
A filter UGen to integrate an input signal with a leak.
- final case class JPverb(rate: Rate, inL: GE, inR: GE, revTime: GE = 1.0f, damp: GE = 0.0f, size: GE = 1.0f, earlyDiff: GE = 0.707f, modDepth: GE = 0.1f, modFreq: GE = 2.0f, low: GE = 1.0f, mid: GE = 1.0f, high: GE = 1.0f, lowCut: GE = 500.0f, highCut: GE = 2000.0f) extends MultiOut with Product with Serializable
An algorithmic reverb UGen, inspired by the lush chorused sound of certain vintage Lexicon and Alesis reverberation units.
An algorithmic reverb UGen, inspired by the lush chorused sound of certain vintage Lexicon and Alesis reverberation units. Designed to sound great with synthetic sound sources, rather than sound like a realistic space.
Note: You may need to increase the server's real-time memory
This is a third-party UGen (DEINDUGens).
- inL
left input signal to be reverberated
- inR
right input signal to be reverberated
- revTime
approximate reverberation time in seconds (T60 - the time for the reverberation to decay 60 dB). Does not effect early reflections. (0.1..60)
- damp
damping of high-frequencies as the reverberation decays. 0 is no damping, 1 is very strong damping (0..1)
- size
scales the size of delay-lines, producing the impression of a larger or smaller space. Values below 1 can sound quite metallic. (0.5..5)
- earlyDiff
shape of early reflections. Values of > 0.707 produce smooth exponential decay. Lower values produce a slower build-up of echoes. (0..1)
- modDepth
depth of delay-line modulation in sample frames. Use in combination with
modFreq
to set amount of chorusing within the structure. (0..50)- modFreq
frequency of delay-line modulation. Use in combination with
modDepth
to set amount of chorusing within the structure. (0..10)- low
multiplier for the reverberation time within the low band. (0..1)
- mid
multiplier for the reverberation time within the mid band. (0..1)
- high
multiplier for the reverberation time within the high band. (0..1)
- lowCut
frequency in Hz at which the crossover between the low and mid bands of the reverberation occurs. (100..6000)
- highCut
frequency in Hz at which the crossover between the mid and high bands of the reverberation occurs. (1000..10000)
- final case class K2A(in: GE) extends SingleOut with AudioRated with Product with Serializable
A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation.
A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation. The current control input value is always reached in at the beginning of the subsequent control block. A special case is the initialization which begins directly at the first control input value (therefore, the first control block of the audio-rate output is is always constant.)
For example, if the block size is 64, and the first three input values are -0.5, 0.6, 0.3, then the output signal will be 65 samples of value -0.5, followed by a linear ramp of 64 samples towards 0.6, followed by a linear ramp of 64 samples to towards 0.3.
- in
control-rate signal to convert
- final case class KeyState(keyCode: GE, lo: GE = 0.0f, hi: GE = 1.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable
A UGen that detects a specific keyboard stroke.
A UGen that detects a specific keyboard stroke. When the given key is not pressed, the
lo
value is output, while the key is pressed thehi
value is output. Iflag
is greater than zero, aLag
-type operation is applied for a smoother transition betweenlo
andhi
.- keyCode
hardware code for the key to monitor. This is likely platform dependent. For example, on Linux, key-codes 24 to 29 correspond to 'Q', 'W', 'E', 'R', 'T', 'Y'.
- lo
value output when the currently pressed does not match the code
- hi
value output when the currently pressed does match the code
- lag
60 dB lag time in seconds.
- See also
- final case class KeyTrack(chain: GE, keyDecay: GE = 2.0f, chromaLeak: GE = 0.5f) extends SingleOut with ControlRated with IsIndividual with Product with Serializable
A (12TET major/minor) key tracker UGen.
A (12TET major/minor) key tracker UGen. It is based on a pitch class profile of energy across FFT bins and matching this to templates for major and minor scales in all transpositions. It assumes a 440 Hz concert A reference. Output is 0-11 C major to B major, 12-23 C minor to B minor.
- chain
the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, with a standard hop of half FFT size, the FFT size should be 4096 at 44.1 or 48 kHz and 8192 at 88.2 or 96 kHz sampling rate.
- keyDecay
Number of seconds for the influence of a window on the final key decision to decay by 40dB (to 0.01 its original value). Can be control-rate modulated.
- chromaLeak
Each frame, the chroma values are set to the previous value multiplied by this chroma decay. 0.0 will start each frame afresh with no memory. Can be control-rate modulated.
- final case class Klang(specs: GE, freqScale: GE = 1.0f, freqOffset: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable
- final case class KlangSpec(freq: GE, amp: GE = 1, decay: GE = 0) extends GE with Product with Serializable
- final case class Klank(specs: GE, in: GE, freqScale: GE = 1.0f, freqOffset: GE = 0.0f, decayScale: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable
Klank is a UGen of a bank of fixed frequency resonators which can be used to simulate the resonant modes of an object.
Klank is a UGen of a bank of fixed frequency resonators which can be used to simulate the resonant modes of an object. Each mode is given a ring time, which is the time for the mode to decay by 60 dB.
Note:
Ringz
and derived UGensKlank
andFormlet
produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.- specs
(init-time only)
- freqScale
(init-time only)
- freqOffset
(init-time only)
- decayScale
(init-time only)
- final case class Kuramoto(rate: Rate, mode: GE = 0.0, initPhase: GE = 0.0, incr: GE = 0.0, extPhase: GE = 0.0, intCoupling: GE, extCoupling: GE = 0.0) extends MultiOut with Product with Serializable
A UGen that implements the Kuramoto model of synchronization of coupled oscillators.
A UGen that implements the Kuramoto model of synchronization of coupled oscillators.
- mode
0
: all oscillators are coupled;1
: neighboring oscillators are coupled (they can be imagined to form a ring);2
: neighboring oscillators are negatively coupled;3
: like2
but discarding current phases (?);4
: like2
but using cosine instead of sine mapping
- final case class LFClipNoise(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument. The difference to
LFClipNoise
is that this UGen quantizes time to the nearest integer division of the sample-rate, and the frequency input is only polled at the moment a new output value is scheduled.- freq
rate at which to generate random values.
- See also
- final case class LFCub(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable
A sine-like oscillator UGen with a shape made of two cubic pieces.
A sine-like oscillator UGen with a shape made of two cubic pieces. It is smoother than
LFPar
.- freq
oscillator frequency in Hertz
- iphase
initial phase in cycle (0 to 1) (init-time only)
- See also
- final case class LFDClipNoise(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument. The difference to
LFClipNoise
is that this UGen does not quantize time and recovers fast from frequency input changes.- freq
rate at which to generate random values.
- final case class LFDNoise0(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A dynamic step noise UGen.
A dynamic step noise UGen. Like
LFNoise0
, it generates abruptly changing random values between-1
and+1
at a rate given by thefreq
argument, with two differences: There is no time quantization, and it there is fast recovery from low freq values.In contrast,
LFNoise0
,LFNoise1
, andLFNoise2
quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.If very high or very low frequencies are not needed, or fixed frequencies are used,
LFNoise0
is more efficient.- freq
rate at which to generate random values.
- final case class LFDNoise1(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A dynamic ramp noise UGen.
A dynamic ramp noise UGen. Like
LFNoise1
, it generates linearly interpolated random values between-1
and+1
at a rate given by thefreq
argument, with two differences: There is no time quantization, and it there is fast recovery from low freq values.In contrast,
LFNoise0
,LFNoise1
, andLFNoise2
quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.If very high or very low frequencies are not needed, or fixed frequencies are used,
LFNoise1
is more efficient.- freq
rate at which to generate random values.
- final case class LFDNoise3(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A dynamic ramp noise UGen.
A dynamic ramp noise UGen. It is similar to
LFNoise2
, with three differences: It uses cubic instead of quadratic interpolation for the random values between-1
and+1
at a rate given by thefreq
argument. There is no time quantization, and it there is fast recovery from low freq values.In contrast,
LFNoise0
,LFNoise1
, andLFNoise2
quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.- freq
rate at which to generate random values.
- final case class LFGauss(rate: Rate, dur: GE = 1.0f, width: GE = 0.1f, phase: GE = 0.0f, loop: GE = 1, doneAction: GE = doNothing) extends SingleOut with Product with Serializable
A non-band-limited gaussian function oscillator UGen.
A non-band-limited gaussian function oscillator UGen. Output ranges from
minVal
to 1. It implements the formula:f(x) = exp((x - phase).squared / (-2 * width.squared))
where
x
is to vary in the range -1 to 1 over the perioddur
.minVal
is the initial value at -1. E.g. for default parameters, it isexp(-50)
or roughly zero.- dur
duration in seconds of a full -1 <= x <= 1 cycle, or the reciprocal of the frequency
- width
relative width of the bell. Best to keep below 0.25 when used as envelope.
- phase
phase offset
- loop
if greater than zero, the UGen oscillates. Otherwise it calls
doneAction
after one cycle.- doneAction
evaluated after cycle completes
- final case class LFNoise0(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A step noise UGen.
A step noise UGen. It generates abruptly changing random values between
-1
and+1
at a rate given by thefreq
argument.The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant
LFDNoise0
has precise frequency and reacts to frequency changes instantly.- freq
rate at which to generate random values.
- final case class LFNoise1(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A ramp noise UGen.
A ramp noise UGen. It generates line segments whose start and end points are chosen randomly between
-1
and+1
. New breakpoints are generated at a specified frequency.The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant
LFDNoise1
has precise frequency and reacts to frequency changes instantly.- freq
rate at which to generate new breakpoints.
- final case class LFNoise2(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable
A quadratically interpolating noise UGen.
A quadratically interpolating noise UGen. This interpolation happens between breakpoints chosen randomly between
-1
and+1
at a specified frequency.The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant
LFDNoise3
has precise frequency and reacts to frequency changes instantly.Note: Due to the interpolation, the output values can occasionally extend beyond the normal range of -1 to +1, if the frequency varies in certain ways.
- freq
rate at which to generate new breakpoints.
- final case class LFPar(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable
A sine-like oscillator UGen with a shape made of two parabolas.
A sine-like oscillator UGen with a shape made of two parabolas. It has audible odd harmonics and is non-band-limited. Its output ranges from -1 to +1.
- freq
oscillator frequency in Hertz
- iphase
initial phase in cycle (0 to 1) (init-time only)
- See also
- final case class LFPulse(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f, width: GE = 0.5f) extends SingleOut with Product with Serializable
A non-band-limited pulse oscillator UGen.
A non-band-limited pulse oscillator UGen. Outputs a high value of one and a low value of zero.
- freq
oscillator frequency in Hertz
- iphase
initial phase offset in cycles (
0..1
). If you think of a buffer of one cycle of the waveform, this is the starting offset into this buffer. Hence, aniphase
of0.25
means that you will hear the first impulse after0.75
periods! If you prefer to specify the perceived delay instead, you could use aniphase
of-0.25 + 1
which is more intuitive. Note that the phase is not automatically wrapped into the range of0..1
, so putting aniphase
of-0.25
currently results in a strange initial signal which only stabilizes to the correct behaviour after one period! (init-time only)- width
pulse width duty cycle from zero to one. If you want to specify the width rather in seconds, you can use the formula
width = freq * dur
, e.g. for a single sample impulse usewidth = freq * SampleDur.ir
.
- See also
- final case class LFSaw(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable
A sawtooth oscillator UGen.
A sawtooth oscillator UGen. The oscillator is creating an aliased sawtooth, that is it does not use band-limiting. For a band-limited version use
Saw
instead. The signal range is -1 to +1.- freq
oscillator frequency in Hertz
- iphase
initial phase offset. For efficiency reasons this is a value ranging from -1 to 1 (thus equal to the initial output value). Note that a phase of zero (default) means the wave starts at 0 and rises to +1 before jumping down to -1. Use a phase of 1 to have the wave start at -1. (init-time only)
- See also
- final case class LFTri(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable
A triangle oscillator UGen designed for low frequency control signals (being non-band-limited).
A triangle oscillator UGen designed for low frequency control signals (being non-band-limited). The output varies from -1 to 1.
With an initial phase of zero, the oscillator begins at 0, rises to 1, then falls to -1 and goes back to zero after one complete phase. With an initial phase of 1 (corresponding to 90 degrees), the oscillator begins at 1 and then falls to -1. With an initial phase of 3 (or 270 degrees), the oscillator begins at -1 and then rises to 1.
- freq
frequency in Hertz
- iphase
initial phase of the oscillator. A full phase (2 Pi or 360 degrees) is represented by an
iphase
value of 4. The initial phase cannot be modulated. (init-time only)
- final case class LPF(rate: MaybeRate, in: GE, freq: GE = 440.0f) extends SingleOut with Product with Serializable
A second order low pass filter UGen.
- final case class LPZ1(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
two point average filter UGen.
two point average filter UGen. Implements the formula :
out(i) = 0.5 * (in(i) + in(i-1))
- in
input signal to be filtered
- See also
- final case class LPZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable
three point average filter UGen.
- final case class Lag(rate: MaybeRate, in: GE, time: GE = 0.1f) extends SingleOut with Product with Serializable
An exponential lag UGen.
An exponential lag UGen. This is essentially the same as
OnePole
except that instead of supplying the coefficient directly, it is calculated from a 60 dB lag time. This is the time required for the filter to converge to within 0.01 % of a value. This is useful for smoothing out control signals.- in
input signal.
- time
60 dB lag time in seconds.
- final case class Lag2(rate: MaybeRate, in: GE, time: GE = 0.1f) extends SingleOut with Product with Serializable
A cascaded exponential lag UGen.
- final case class Lag2UD(rate: MaybeRate, in: GE, timeUp: GE = 0.1f, timeDown: GE = 0.1f) extends SingleOut with Product with Serializable
A cascaded exponential lag UGen with separate inputs for up and down slope.
A cascaded exponential lag UGen with separate inputs for up and down slope.
Lag2UD.kr(in, up, down)
is equivalent toLagUD.kr(LagUD.kr(in, up, down), up, down)
, thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factors once instead of twice.- in
input signal.
- timeUp
60 dB lag time in seconds effective during a rising slope in the input signal
- timeDown
60 dB lag time in seconds effective during a falling slope in the input signal
- final case class Lag3(rate: MaybeRate, in: GE, time: GE = 0.1f) extends SingleOut with Product with Serializable
A cascaded exponential lag UGen.
A cascaded exponential lag UGen.
Lag3.kr(in, time)
is equivalent toLag.kr(Lag.kr(Lag.kr(Lag.kr(in, time), time), time)
, thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factor once instead of three times.- in
input signal.
- time
60 dB lag time in seconds.
- final case class Lag3UD(rate: MaybeRate, in: GE, timeUp: GE = 0.1f, timeDown: GE = 0.1f) extends SingleOut with Product with Serializable
A cascaded exponential lag UGen with separate inputs for up and down slope.
A cascaded exponential lag UGen with separate inputs for up and down slope.
Lag3UD.kr(in, up, down)
is equivalent toLagUD.kr(LagUD.kr(LagUD.kr(in, up, down), up, down), up, down)
, thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factors once instead of three times.- in
input signal.
- timeUp
60 dB lag time in seconds effective during a rising slope in the input signal
- timeDown
60 dB lag time in seconds effective during a falling slope in the input signal
- final case class LagIn(rate: Rate, bus: GE, numChannels: Int = 1, time: GE = 0.1f) extends MultiOut with IsIndividual with Product with Serializable
A UGen that reads a signal from a control bus and applies a lag filter to it.
A UGen that reads a signal from a control bus and applies a lag filter to it. This is essentially the same as
Lag.kr(In.kr(...), time)
.- bus
index of the bus to read from. When
numChannels
is greater than one, the other channels or read from the adjacent indices.- numChannels
number of channels to read
- time
60 dB lag time in seconds.
- final case class LagUD(rate: MaybeRate, in: GE, timeUp: GE = 0.1f, timeDown: GE = 0.1f) extends SingleOut with Product with Serializable
An exponential lag UGen with separate inputs for up and down slope.
An exponential lag UGen with separate inputs for up and down slope. This is essentially the same as
Lag
except that you can supply a different 60 dB time for when the signal goes up, from when the signal goes down.- in
input signal.
- timeUp
60 dB lag time in seconds effective during a rising slope in the input signal
- timeDown
60 dB lag time in seconds effective during a falling slope in the input signal
- final case class LastValue(rate: Rate, in: GE, thresh: GE = 0.01f) extends SingleOut with Product with Serializable
A sample-and-hold UGen that outputs the last value before the input changed more than a threshold.
A sample-and-hold UGen that outputs the last value before the input changed more than a threshold. Change is based on the absolute of the differentiation of input signal.
- in
input signal to analyze and filter
- thresh
threshold below which the input sign
- See also
- final case class Latch(rate: Rate, in: GE, trig: GE = 1) extends SingleOut with Product with Serializable
A sample-and-hold UGen.
A sample-and-hold UGen. When triggered, a new value is taken from the input and hold until the next trigger occurs.
Before the first trigger is registered, this UGen outputs zero.
- in
the input signal
- trig
the trigger. The can be any signal. A trigger happens when the signal changes from non-positive to positive.
- final case class LatoocarfianC(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 3.0f, c: GE = 0.5f, d: GE = 0.5f, xi: GE = 0.5f, yi: GE = 0.5f) extends SingleOut with Product with Serializable
A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
- freq
Iteration frequency in Hertz.
- a
Equation variable
- b
Equation variable
- c
Equation variable
- d
Equation variable
- xi
Initial value of x
- yi
Initial value of y
- See also
- final case class LatoocarfianL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 3.0f, c: GE = 0.5f, d: GE = 0.5f, xi: GE = 0.5f, yi: GE = 0.5f) extends SingleOut with Product with Serializable
A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
- freq
Iteration frequency in Hertz
- a
Equation variable
- b
Equation variable
- c
Equation variable
- d
Equation variable
- xi
Initial value of x
- yi
Initial value of y
- See also
- final case class LatoocarfianN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 3.0f, c: GE = 0.5f, d: GE = 0.5f, xi: GE = 0.5f, yi: GE = 0.5f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
- freq
Iteration frequency in Hertz.
- a
Equation variable
- b
Equation variable
- c
Equation variable
- d
Equation variable
- xi
Initial value of x
- yi
Initial value of y
- See also
- final case class LeakDC(rate: MaybeRate, in: GE, coeff: GE) extends SingleOut with Product with Serializable
A filter UGen to remove very low frequency content DC offset.
A filter UGen to remove very low frequency content DC offset.
This is a one-pole highpass filter implementing the formula
y[n] = x[n] - x[n-1] + coeff * y[n-1]
- in
input signal to be filtered
- coeff
the leak coefficient determines the filter strength. the value must be between zero and one (exclusive) for the filter to remain stable. values closer to one produce less bass attenuation.
- See also
- final case class LeastChange(rate: MaybeRate, a: GE, b: GE) extends SingleOut with Product with Serializable
A UGen that switches between two input signal depending on which is changing less.
A UGen that switches between two input signal depending on which is changing less. Change is based on the absolute of the differentiation of the respective signals.
- a
first input signal to select from
- b
second input signal to select from
- See also
- final case class Limiter(rate: Rate, in: GE, level: GE = 1.0f, dur: GE = 0.01f) extends SingleOut with Product with Serializable
Limits the input amplitude to the given level.
Limits the input amplitude to the given level. Unlike
Compander
, this UGen will never overshoot, but it needs to look ahead in the input signal, introducing a delay in its output. The delay time is equal to twice the value of thedur
parameter (the buffer internally used).- in
input signal to be limited
- level
maximum amplitude to which the signal is limited. The limiter will kick in when the input signal exceeds
+level
or falls below-level
.- dur
look-ahead time in seconds (init-time only)
- See also
- final case class LinCongC(rate: Rate, freq: GE = Nyquist(), a: GE = 1.1f, c: GE = 0.13f, m: GE = 1.0f, xi: GE = 0.0f) extends SingleOut with Product with Serializable
A cubic-interpolating sound generator based on the difference equation:
- final case class LinCongL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.1f, c: GE = 0.13f, m: GE = 1.0f, xi: GE = 0.0f) extends SingleOut with Product with Serializable
A linear-interpolating sound generator based on the difference equation:
- final case class LinCongN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.1f, c: GE = 0.13f, m: GE = 1.0f, xi: GE = 0.0f) extends SingleOut with Product with Serializable
A non-interpolating sound generator based on the difference equation:
- final case class LinExp(rate: MaybeRate, in: GE, srcLo: GE = 0.0f, srcHi: GE = 1.0f, dstLo: GE = 1.0f, dstHi: GE = 2.0f) extends SingleOut with Product with Serializable
A UGen which maps a linear range to an exponential range.
A UGen which maps a linear range to an exponential range. The equivalent formula is
(dstHi / dstLo).pow((in - srcLo) / (srcHi - srcLo)) * dstLo
.Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.
- in
input signal to convert
- srcLo
lower limit of input range
- srcHi
upper limit of input range
- dstLo
lower limit of output range
- dstHi
upper limit of output range
- final case class LinLin(in: GE, srcLo: GE = 0f, srcHi: GE = 1f, dstLo: GE = 0f, dstHi: GE = 1f) extends GE.Lazy with Product with Serializable
A graph element which maps a linear range to another linear range.
A graph element which maps a linear range to another linear range. The equivalent formula is
(in - srcLo) / (srcHi - srcLo) * (dstHi - dstLo) + dstLo
.Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.
Examples
// oscillator to frequency range play { val mod = SinOsc.kr(Line.kr(1, 10, 10)) SinOsc.ar(LinLin(mod, -1, 1, 100, 900)) * 0.1 }
- in
The input signal to convert.
- srcLo
The lower limit of input range.
- srcHi
The upper limit of input range.
- dstLo
The lower limit of output range.
- dstHi
The upper limit of output range.
- final case class LinPan2(rate: Rate, in: GE, pos: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable
A stereo panorama UGen based on linear amplitude control.
A stereo panorama UGen based on linear amplitude control. When in center position (
pos = 0
), the signal is attenuated by 0.5 or approx. -6 dB.- in
(monophonic) input signal to be panned
- pos
panorama position between -1 (hard left) via 0 (center) to +1 (hard right)
- level
additional gain control
- final case class LinRand(lo: GE = 0.0f, hi: GE = 1.0f, minMax: GE = 0) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable
A scalar UGen that generates a single random decimal value between
lo
andhi
with a selectable skew towards either end.A scalar UGen that generates a single random decimal value between
lo
andhi
with a selectable skew towards either end.The
minMax <= 0
behaves rather odd: IfminMax
is less than 1, the distribution is skewed towardslo
(withlo = 0
andhi = 1
, the mean is approx. 0.33). IfminMax
is greater than or equal to 1, the distribution is skewed towardshi
(withlo = 0
andhi = 1
, the mean is approx 0.66).- lo
lower limit of the output range
- hi
upper limit of the output range
- minMax
if
0
, the output is skewed towardslo
, if1
, the output is skewed towardshi
.
- final case class LinXFade2(rate: Rate, inA: GE, inB: GE = 0.0f, pan: GE = 0.0f, level: GE = 1.0f) extends SingleOut with Product with Serializable
An linear two channel cross fading UGen.
An linear two channel cross fading UGen. In center position (
pan = 0
), both input signals are attenuated by 0.5 or approx. -6 dB.- inA
The first input signal
- inB
The second input signal
- pan
the cross-fade position from
-1
(only input A audible) to+1
(only input B audible)- level
An overall amplitude multiplier that is applied to the output signal
- final case class Line(rate: Rate, start: GE = 0.0f, end: GE = 1.0f, dur: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with HasDoneFlag with Product with Serializable
A line generator UGen that moves from a start value to the end value in a given duration.
A line generator UGen that moves from a start value to the end value in a given duration.
Warning: Durations greater than around 2.8e6 seconds cause the UGen to misbehave and jump to the end value directly.
- start
Starting value (init-time only)
- end
Ending value (init-time only)
- dur
Duration in seconds. (init-time only)
- doneAction
A done-action that is evaluated when the Line has reached the end value after the given duration
- final case class Linen(rate: Rate, gate: GE = 1, attack: GE = 0.01f, sustain: GE = 1.0f, release: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with HasDoneFlag with Product with Serializable
A linear ASR-type envelope generator UGen.
A linear ASR-type envelope generator UGen.
- gate
triggers the envelope and holds it open while greater than zero. A value of less than zero enforces a release with duration
-1.0 - gate
.- attack
duration (seconds) of the attack segment
- sustain
level of the sustain segment
- release
duration (seconds) of the release segment
- doneAction
action to be performed when the envelope reaches its end point.
- See also
- final case class ListTrig(rate: Rate, buf: GE, size: GE, reset: GE = 0, delay: GE = 0) extends SingleOut with IsIndividual with Product with Serializable
A UGen that produces a scheduled sequences of trigger impulses.
A UGen that produces a scheduled sequences of trigger impulses. Trigger times are provided as a list (buffer) of absolute offsets from time zero. A trigger is output as a single control period of value
1
, after which output returns to zero.This is a third-party UGen (MCLDUGens).
- buf
identifier of the buffer containing the offsets for the triggers in seconds. The offsets are taken against the start time of the synth or the last time a
reset
was received. They are not accumulative, and the behavior is undefined if the values are not sorted in ascending order. The buffer should be monophonic.- size
the number of values to use from the buffer. Typically, this should be
BufFrames.kr(buf)
.- reset
resets the timer and begins reading the time offsets again at the start of the buffer.
- delay
this value is added to each of the buffer values. For example, to delay the list of values all by half a second, use a
delay
of0.5
. This parameter is only updated at initialization or reset.
- Note
The argument order is different from its sclang counterpart.
- See also
- final case class ListTrig2(rate: Rate, buf: GE, size: GE, reset: GE = 0) extends SingleOut with IsIndividual with Product with Serializable
A UGen that produces a scheduled sequences of trigger impulses.
A UGen that produces a scheduled sequences of trigger impulses. Trigger times are provided as a list (buffer) of relative durations between consecutive events. A trigger is output as a single control period of value
1
, after which output returns to zero.This is a third-party UGen (MCLDUGens).
- buf
identifier of the buffer containing the durations for the triggers in seconds. A value represents a relative offsets with respect to its predecessor. The first value indicates the time between the start of the synth or last
reset
received and the first trigger. The buffer should be monophonic.- size
the number of values to use from the buffer. Typically, this should be
BufFrames.kr(buf)
.- reset
resets the timer and begins reading the time deltas again at the start of the buffer.
- Note
The argument order is different from its sclang counterpart.
- See also
- final case class LocalBuf(numFrames: GE, numChannels: GE = 1) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable
A UGen that allocates a buffer local to the synth.
A UGen that allocates a buffer local to the synth. This is convenient for example when using an
FFT
chain.- numFrames
number of sample frames for the buffer
- numChannels
number of channels for the buffer
- See also
- final case class LocalIn(rate: Rate, init: GE = 0) extends MultiOut with Product with Serializable
A UGen that reads buses that are local to the enclosing synth.
A UGen that reads buses that are local to the enclosing synth. These buses should be written using a
LocalOut
ugen. They behave like regular buses, but are more convenient for the implementation of a self contained effect that uses a feedback processing loop.In a synth, there can be only each one control-rate and audio-rate
LocalIn
/LocalOut
pair. The signal written to aLocalOut
will not be read by theLocalIn
until the next control block cycle, introducing a delay ofControlDur
.Warning: The argument has been changed
numChannels: Int
in version 1.15.3 toinit: GE
in version 1.16.0. The previous version was incompatible with SuperCollider 3.6.x. A previous usage such asLocalIn.ar(2)
to create two channels must now be expressed asLocalIn.ar(Seq(0, 0))
!- init
the initial state of the UGen. The number of channels of this signal should match with the number of channels written via
LocalOut
.
- See also
- final case class LocalOut(rate: Rate, in: GE) extends ZeroOut with Product with Serializable
A UGen that writes to buses that are local to the enclosing synth.
A UGen that writes to buses that are local to the enclosing synth. These buses should have been defined by a
LocalIn
ugen. These behave like regular buses, but are more convenient for the implementation of a self contained effect that uses a feedback processing loop.In a synth, there can be only each one control-rate and audio-rate
LocalIn
/LocalOut
pair. The signal written to aLocalOut
will not be read by theLocalIn
until the next control block cycle, introducing a delay ofControlDur
.For more examples, see
LocalIn
.- in
signal to be written to the synth-local bus. The signal's number of channels must be the same number of channels as were declared in the corresponding
LocalIn
.
- See also
- final case class Logger(rate: Rate, buf: GE, in: GE, trig: GE, reset: GE = 0) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable
A UGen to store values in a buffer upon receiving a trigger.
A UGen to store values in a buffer upon receiving a trigger. When a trigger happens, the current input values are sampled and stored as the next consecutive frame of the buffer.
Storage starts at the buffer beginning and increments the write position until the buffer is full. While the buffer is not yet full, the UGen outputs
1
, then it outputs0
. The buffer position can be reset using thereset
input.Note that the UGen zeroes the buffer upon first instantiation, to ensure that out-of-date data is not confused with new data.
This is a third-party UGen (MCLDUGens).
- buf
identifier of the buffer to write to. Its number of channels should match those of
in
.- in
(multi-channel) signal to write to the buffer. Its number of channels should match those of
buf
.- trig
a non-positive to positive transition causes the UGen to append the current input values to the buffer
- reset
a non-positive to positive transition causes the write index into the buffer to be reset to zero. The contents of the buffer will also be filled with zeroes. If the buffer was full, the UGen output switches back to zero.
- Note
The argument order is different from its sclang counterpart.
- See also
- final case class Logistic(rate: Rate, chaos: GE = 3.0f, freq: GE = 1000.0f, init: GE = 0.5f) extends SingleOut with Product with Serializable
A noise generator UGen based on the logistic map.
A noise generator UGen based on the logistic map. Its formula is
y[n+1] = chaos * y[n] * (1.0 - y[n])
- chaos
a parameter of the chaotic function with useful values from 0.0 to 4.0. Chaotic behavior occurs from 3.57 up. Using values outside this range can make the UGen blow up, resulting in NaNs.
- freq
Frequency of calculation in Hertz. The value is limited by the sampling rate.
- init
Initial value of the recursive function
- See also
- final case class LorenzL(rate: Rate, freq: GE = Nyquist(), s: GE = 10.0f, r: GE = 28.0f, b: GE = 2.667f, h: GE = 0.05f, xi: GE = 0.1f, yi: GE = 0.0f, zi: GE = 0.0f) extends SingleOut with Product with Serializable
A strange attractor discovered by Edward N.
A strange attractor discovered by Edward N. Lorenz while studying mathematical models of the atmosphere. The system is composed of three ordinary differential equations:
x' = s * (y - x) y' = x * (r - z) - y z' = x * y - b * z
The time step amount h determines the rate at which the ODE is evaluated. Higher values will increase the rate, but cause more instability. A safe choice is the default amount of 0.05.
- freq
Iteration frequency in Hertz
- s
Equation variable
- r
Equation variable
- b
Equation variable
- h
Integration time step
- xi
Initial value of x
- yi
Initial value of y
- zi
Initial value of z
- final case class Loudness(chain: GE, smask: GE = 0.25f, tmask: GE = 1.0f) extends SingleOut with ControlRated with IsIndividual with Product with Serializable
A UGen for the extraction of instantaneous loudness.
A UGen for the extraction of instantaneous loudness. A perceptual loudness function which outputs loudness in sones; this is a variant of an MP3 perceptual model, summing excitation in ERB bands. It models simple spectral and temporal masking, with equal loudness contour correction in ERB bands to obtain phons (relative dB), then a phon to sone transform. The final output is typically in the range of 0 to 64 sones, though higher values can occur with specific synthesised stimuli.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
Warning: the UGen is broken if FFT sizes other than the ones specified for
chain
are used.- chain
the output (buffer) of an FFT UGen which transforms the audio input to track. The FFT size should be 1024 for 44.1 and 48 kHz sampling rate, and 2048 for 88.2 and 96 kHz sampling rate.
- smask
Spectral masking parameter: lower bins mask higher bin power within ERB bands, with a power falloff (leaky integration multiplier) of
smask
per bin. Can be control-rate modulated.- tmask
Temporal masking parameter: the phon level let through in an ERB band is the maximum of the new measurement, and the previous minus
tmask
phons. Can be control-rate modulated.
- final case class MFCC(chain: GE, numCoeffs: Int = 13) extends MultiOut with ControlRated with IsIndividual with Product with Serializable
A UGen for extracting mel frequency cepstral coefficients.
A UGen for extracting mel frequency cepstral coefficients. It generates a set of MFCCs; these are obtained from a band-based frequency representation (using the Mel scale by default), and then a discrete cosine transform (DCT). The DCT is an efficient approximation for principal components analysis, so that it allows a compression, or reduction of dimensionality, of the data, in this case reducing 42 band readings to a smaller set of MFCCs. A small number of features (the coefficients) end up describing the spectrum. The MFCCs are commonly used as timbral descriptors.
The output values are somewhat normalised for the range 0.0 to 1.0, but there are no guarantees on exact conformance to this. Commonly, the first coefficient will be the highest value. The number of output channels corresponds to the number of coefficients specified. Technical note: The 0th coefficient is not generated as it consists of multiplying all bands by 1 and summing
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
- chain
the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, with a standard hop of half FFT size, the FFT size should be 1024 at 44.1 or 48 kHz and 2048 at 88.2 or 96 kHz sampling rate.
- numCoeffs
the number of coefficients, defaults to 13, maximum of 42; more efficient to use less of course! Since this number determines the number of output channels of the UGen, it has to be an
Int
.
- final case class MantissaMask(rate: MaybeRate, in: GE, bits: GE = 3) extends SingleOut with Product with Serializable
A UGen that masks off bits in the mantissa of the floating point sample value.
A UGen that masks off bits in the mantissa of the floating point sample value. This introduces a quantization noise, but is less severe than linearly quantizing the signal.
- in
input signal to quantize
- bits
The number of mantissa bits to preserve, from 0 to 23.
- final case class MdaPiano(rate: Rate, freq: GE = 440, gate: GE = 1, velocity: GE = 100, decay: GE = 0.8f, release: GE = 0.8f, hardness: GE = 0.8f, velHard: GE = 0.8f, muffle: GE = 0.8f, velMuff: GE = 0.8f, velCurve: GE = 0.8f, stereo: GE = 0.2f, tune: GE = 0.5f, random: GE = 0.1f, stretch: GE = 0.1f, sustain: GE = 0) extends MultiOut with Product with Serializable
A piano synthesiser UGen.
A piano synthesiser UGen. It is not polyphonic, but it can be retriggered to play notes in sequence.
The original VST plugin by Paul Kellett was ported to SuperCollider by Dan Stowell. Most likely the arguments are in the normalized range 0 to 1.
This is a third-party UGen (MdaUGens).
- freq
Frequency of the note in Hz.
- gate
note-on occurs when gate goes from non-positive to positive; note-off occurs when it goes from positive to non-positive. Most of the other controls are only updated when a new note-on occurs.
- velocity
velocity (range is 0 to 127)
- decay
The time for notes to decay after the initial strike.
- release
The time for notes to decay after the key is released.
- hardness
adjusts sample key-ranges up or down to change the "size" and brightness of the piano.
- muffle
gentle low pass filter.
- stereo
Width of the stereo effect (which makes low notes sound towards the left, high notes towards the right). 0 to 1.
- tune
Overall tuning.
- random
Randomness in note tuning.
- stretch
Stretches the tuning out (higher notes pushed higher).
- sustain
if positive, act as if the piano's sustain pedal is pressed.
- final case class Median(rate: Rate, in: GE, length: GE = 3) extends SingleOut with Product with Serializable
A filter UGen that calculates the median of a running window over its input signal.
A filter UGen that calculates the median of a running window over its input signal. This non-linear filter can be used to reduce impulse noise from a signal.
- length
window size. I.e., the number of input samples in which to find the median. Must be an odd number from 1 to 31. A value of 1 has no effect. Warning: This parameter is only read an initialization time and cannot be modulated while the UGen is running. (init-time only)
- Note
The argument order is different from its sclang counterpart.
- See also
- final case class MidEQ(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with Product with Serializable
A single band parametric equalizer UGen.
A single band parametric equalizer UGen. It attenuates or boosts a frequency band.
- in
input signal to be filtered
- freq
center frequency in Hertz
- rq
reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter. Too high values for
rq
may blow the filter up!- gain
The amount of boost (when positive) or attenuation (when negative) applied to the frequency band, in decibels.
- final case class Mix(elem: GE) extends SingleOut with Product with Serializable
A graph element that mixes the channels of a signal together.
A graph element that mixes the channels of a signal together. It works like the sclang counterpart.
The
Mix
companion object contains various useful mixing idioms:-
Mix.tabulate(n: Int)(fun: Int => GE)
: corresponds toSeq.tabulate
and toArray.fill
in sclang. -Mix.fill(n: Int)(thunk: => GE)
: corresponds toSeq.fill
. -Mix.seq(elems: GE*)
: A shortcut forMix(GESeq(elems: _*))
.A separate graph element is
Mix.mono
.Mix.mono(elem: GE)
flattens all channels of the input element before summing them, guaranteeing that the result is monophonic.Finally,
Mix.fold
is an idiom that not actually adds elements, but recursively folds them. Thus,Mix.fold(elem: GE, n: Int)(fun: GE => GE)
is equivalent to(1 to n).foldLeft(elem) { (res, _) => fun(res) }
Mix.fold
is often used in the SuperCollider examples to apply a filtering process such as reverberation several times. For cases where the iteration index is needed, the full form as shown above can be used instead.- elem
the graph element whose channels to mix together
- See also
- final case class ModDif(rate: Rate, x: GE, y: GE = 0.0f, mod: GE = 1.0f) extends SingleOut with Product with Serializable
A UGen that returns the minimum difference of two values in modulo arithmetics.
A UGen that returns the minimum difference of two values in modulo arithmetics. On a circle, there are two distances between two points. This UGen returns the smaller value of the two.
- x
the first input value
- y
the second input value
- mod
the modulo argument, i.e. the maximum value output, which is double of the maximal difference that will be returned by the UGen.
- final case class MoogFF(rate: MaybeRate, in: GE, freq: GE = 200.0f, gain: GE = 2.0f, reset: GE = 0) extends SingleOut with Product with Serializable
A Moog VCF style UGen.
A Moog VCF style UGen. This is a type of resonant low pass filter.
The design of this filter is described in Federico Fontana, "Preserving the Digital Structure of the Moog VCF." In: Proceedings of the ICMC, Copenhagen 2007. Ported to SuperCollider by Dan Stowell.
- freq
cutoff frequency in Hertz
- gain
filter resonance gain, between 0 and 4
- reset
when greater than zero, this will reset the state of the digital filters at the beginning of the next control block.
- final case class MostChange(rate: Rate, a: GE, b: GE) extends SingleOut with Product with Serializable
A UGen that switches between two input signal depending on which is changing more.
A UGen that switches between two input signal depending on which is changing more. Change is based on the absolute of the differentiation of the respective signals.
- a
first input signal to select from
- b
second input signal to select from
- See also
- final case class MouseButton(lo: GE = 0.0f, hi: GE = 1.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable
A UGen that outputs two different values depending on whether the mouse button is pressed.
A UGen that outputs two different values depending on whether the mouse button is pressed. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
- lo
value output while button is not pressed
- hi
value output while button is pressed
- lag
60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.
- final case class MouseX(lo: GE = 0.0f, hi: GE = 1.0f, warp: GE = 0.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable
A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range.
A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
- lo
value when the mouse is on the left side of the screen
- hi
value when the mouse is on the right side of the screen. Note: this value is never reached, because the maximum mouse coordinate is one pixel less than the screen size. For example, if the screen width is 1440,
lo
is 0.0 andhi
is 1.0, the maximum value output is1.0 * 1439/1440 = 0.999306
.- warp
curve shape. Either zero (default) for a linear mapping, or 1 for an exponential mapping. Note: When using exponential mapping, make sure the
lo
value is greater than zero, otherwise NaN values will be output.- lag
60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.
- See also
- final case class MouseY(lo: GE = 0.0f, hi: GE = 1.0f, warp: GE = 0.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable
A UGen that maps the vertical screen location of the mouse to a given linear or exponential range.
A UGen that maps the vertical screen location of the mouse to a given linear or exponential range. The
lo
value corresponds to the bottom of the screen, and thehi
value corresponds to the top of the screen (not vice-versa).This UGen is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
- lo
value when the mouse is on the bottom side of the screen. Note: this value is never reached, because the maximum mouse coordinate is one pixel less than the screen height. For example, if the screen height is 900,
lo
is 0.0 andhi
is 1.0, the minimum value output is1.0 - 1.0 * 899.0/900 = 0.001111
.- hi
value when the mouse is on the top side of the screen
- warp
curve shape. Either zero (default) for a linear mapping, or 1 for an exponential mapping. Note: When using exponential mapping, make sure the
lo
value is greater than zero, otherwise NaN values will be output.- lag
60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.
- See also
- final case class MulAdd(in: GE, mul: GE, add: GE) extends SingleOut with Product with Serializable
A UGen that multiplies an input with another signal and then adds a third signal.
A UGen that multiplies an input with another signal and then adds a third signal. This can be used to translate an element into a different value range.
Usually the graph element operator
mulAdd
is used instead of explicitly writingMulAdd
.MulAdd(in, mul, add) == in.mulAdd(mul, add) == in * mul + add
Examples
// scale value range play { // input range -1 to +1, // output range ((-1 * 100) + 300) = 200 // to ((+1 * 100) + 300) = 400 val freq = SinOsc.kr(1).mulAdd(100, 300) // or MulAdd(..., 100, 300) freq.poll(label = "freq") SinOsc.ar(freq) * 0.1 }
- in
the input signal to scale and offset
- mul
the scaling factor, applied first to the input
- add
the offset, added after applying the multiplication
- See also
- final case class NRand(lo: GE = 0.0f, hi: GE = 1.0f, n: GE = 2) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable
A scalar UGen that generates a single random decimal value, averaging a given number of samples from a uniform distribution between
lo
andhi
.A scalar UGen that generates a single random decimal value, averaging a given number of samples from a uniform distribution between
lo
andhi
.- lo
lower limit of the output range
- hi
upper limit of the output range
- n
the number of random numbers to average. For
n = 1
, the result is identical toRand
, forn = 2
, the distribution is triangular, and for larger values the distribution converges towards a Gaussian. Warning: The value should be not be less than one.
- final case class NodeID() extends SingleOut with ScalarRated with Product with Serializable
Identifier of the node which contains the UGen.
Identifier of the node which contains the UGen.
- See also
- final case class Normalizer(rate: Rate, in: GE, level: GE = 1, dur: GE = 0.01f) extends SingleOut with Product with Serializable
A UGen that normalizes the input amplitude to the given level.
A UGen that normalizes the input amplitude to the given level. Unlike
Compander
, this UGen will not overshoot, but it needs to look ahead in the input signal, introducing a delay in its output. The delay time is equal to twice the value of thedur
parameter (the buffer internally used).- in
input signal to be normalized
- level
peak output amplitude level to which to normalize the input
- dur
look-ahead time in seconds. Shorter times will produce smaller delays and quicker transient response times, but may introduce amplitude modulation artifacts. (init-time only)
- final case class NumAudioBuses() extends SingleOut with ScalarRated with Product with Serializable
Number of audio buses.
Number of audio buses.
- final case class NumBuffers() extends SingleOut with ScalarRated with Product with Serializable
Maximum number of audio buffers.
Maximum number of audio buffers.
- final case class NumChannels(in: GE) extends SingleOut with ScalarRated with Product with Serializable
A graph element that produces an integer with number-of-channels of the input element.
A graph element that produces an integer with number-of-channels of the input element.
Because ScalaCollider allows late-expanding graph elements, we have no direct way to get an integer of some array-size of a UGen's outputs. On the other hand, there may be sound synthesis definitions that can abstract over the number of channels at definition time.
Examples
// amplitude compensation play { val sines: GE = Seq.fill(8)(SinOsc.ar(ExpRand(200, 2000))) val norm = Mix(sines) / NumChannels(sines) // guarantee that they don't clip norm * 0.2 }
- in
the element whose number-of-channels to produce
- See also
- final case class NumControlBuses() extends SingleOut with ScalarRated with Product with Serializable
Number of control buses.
Number of control buses.
- final case class NumInputBuses() extends SingleOut with ScalarRated with Product with Serializable
Number of input buses.
Number of input buses.
- final case class NumOutputBuses() extends SingleOut with ScalarRated with Product with Serializable
Number of output buses.
Number of output buses.
- final case class NumRunningSynths() extends SingleOut with ScalarRated with Product with Serializable
Number of currently running synths.
Number of currently running synths.
- final case class Nyquist() extends GE with ScalarRated with Product with Serializable
A helper graph element equivalent to
SampleRate.ir * 0.5
.A helper graph element equivalent to
SampleRate.ir * 0.5
.- See also
- final case class OffsetOut(bus: GE, in: GE) extends ZeroOut with AudioRated with HasSideEffect with IsIndividual with Product with Serializable
A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle.
A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle. I.e. if the synth is scheduled to be started part way through a control cycle,
OffsetOut
will maintain the correct offset by buffering the output and delaying it until the exact time that the synth was scheduled for.This UGen adds ("mixes") the input-signal to the existing contents of the bus.
Multi-channel input signals, for example a
PanAz
, are written as such to the bus without expansion. That is, thebus
index argument is used for the first channel, the second channel will appear onbus + 1
, etc.If you have an expanding multi-channel input, however, you have to be careful. For example, if you have
PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1))
, this results in one output UGen carrying one channel, and another one carrying two channels. (The way this works is consistent with SCLang). In order to get the correct behaviour (left outputs of thePanAz
summed, and right output of thePanAz
summed), wrap this expression in aMix(...)
before passing it to the output UGen.Note: You cannot currently achieve sample accurate scheduling in SuperCollider. This UGen is therefore more or less useless.
- bus
bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus.
- in
signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.
- See also
- final case class OnePole(rate: MaybeRate, in: GE, coeff: GE = 0.5f) extends SingleOut with Product with Serializable
A one pole (IIR) filter UGen.
- final case class OneZero(rate: MaybeRate, in: GE, coeff: GE = 0.5f) extends SingleOut with Product with Serializable
A one zero (FIR) filter UGen.
A one zero (FIR) filter UGen. Implements the formula :
out(i) = ((1 - abs(coef)) * in(i)) + (coef * in(i-1))
- in
input signal to be processed
- coeff
feed forward coefficient. +0.5 makes a two point averaging filter (see also
LPZ1
), -0.5 makes a differentiator (see alsoHPZ1
), +1 makes a single sample delay (see alsoDelay1
), -1 makes an inverted single sample delay.
- final case class Onsets(chain: GE, thresh: GE = 0.5f, fun: GE = 3, decay: GE = 1.0f, noiseFloor: GE = 0.1f, minGap: