Merge branch 'tidalcycles:main' into ableton_link_integration

.eslintignore

@@ -18,4 +18,5 @@ vite.config.js
 **/*.json
 **/dev-dist
 **/dist
-/src-tauri/target/**/*
+/src-tauri/target/**/*
+reverbGen.mjs

packages/codemirror/slider.mjs

@@ -6,7 +6,7 @@ export let sliderValues = {};
 const getSliderID = (from) => `slider_${from}`;
 
 export class SliderWidget extends WidgetType {
-  constructor(value, min, max, from, to, view) {
+  constructor(value, min, max, from, to, step, view) {
     super();
     this.value = value;
     this.min = min;
@@ -14,6 +14,7 @@ export class SliderWidget extends WidgetType {
     this.from = from;
     this.originalFrom = from;
     this.to = to;
+    this.step = step;
     this.view = view;
   }
 
@@ -29,7 +30,7 @@ export class SliderWidget extends WidgetType {
     slider.type = 'range';
     slider.min = this.min;
     slider.max = this.max;
-    slider.step = (this.max - this.min) / 1000;
+    slider.step = this.step ?? (this.max - this.min) / 1000;
     slider.originalValue = this.value;
     // to make sure the code stays in sync, let's save the original value
     // becuase .value automatically clamps values so it'll desync with the code
@@ -66,9 +67,9 @@ export const updateWidgets = (view, widgets) => {
 };
 
 function getWidgets(widgetConfigs, view) {
-  return widgetConfigs.map(({ from, to, value, min, max }) => {
+  return widgetConfigs.map(({ from, to, value, min, max, step }) => {
     return Decoration.widget({
-      widget: new SliderWidget(value, min, max, from, to, view),
+      widget: new SliderWidget(value, min, max, from, to, step, view),
       side: 0,
     }).range(from /* , to */);
   });
@@ -90,8 +91,10 @@ export const sliderPlugin = ViewPlugin.fromClass(
           while (iterator.value) {
             // when the widgets are moved, we need to tell the dom node the current position
             // this is important because the updateSliderValue function has to work with the dom node
-            iterator.value.widget.slider.from = iterator.from;
-            iterator.value.widget.slider.to = iterator.to;
+            if (iterator.value?.widget?.slider) {
+              iterator.value.widget.slider.from = iterator.from;
+              iterator.value.widget.slider.to = iterator.to;
+            }
             iterator.next();
           }
         }

packages/core/controls.mjs

@@ -655,6 +655,15 @@ const generic_params = [
    * .vib("<.5 1 2 4 8 16>:12")
    */
   [['vib', 'vibmod'], 'vibrato', 'v'],
+  /**
+   * Adds pink noise to the mix
+   *
+   * @name noise
+   * @param {number | Pattern} wet wet amount
+   * @example
+   * sound("<white pink brown>/2")
+   */
+  ['noise'],
   /**
    * Sets the vibrato depth in semitones. Only has an effect if `vibrato` | `vib` | `v` is is also set
    *
@@ -970,20 +979,64 @@ const generic_params = [
    *
    */
   [['room', 'size']],
+  /**
+   * Reverb lowpass starting frequency (in hertz).
+   * When this property is changed, the reverb will be recaculated, so only change this sparsely..
+   *
+   * @name roomlp
+   * @synonyms rlp
+   * @param {number} frequency between 0 and 20000hz
+   * @example
+   * s("bd sd").room(0.5).rlp(10000)
+   * @example
+   * s("bd sd").room(0.5).rlp(5000)
+   */
+  ['roomlp', 'rlp'],
+  /**
+   * Reverb lowpass frequency at -60dB (in hertz).
+   * When this property is changed, the reverb will be recaculated, so only change this sparsely..
+   *
+   * @name roomdim
+   * @synonyms rdim
+   * @param {number} frequency between 0 and 20000hz
+   * @example
+   * s("bd sd").room(0.5).rlp(10000).rdim(8000)
+   * @example
+   * s("bd sd").room(0.5).rlp(5000).rdim(400)
+   *
+   */
+  ['roomdim', 'rdim'],
+  /**
+   * Reverb fade time (in seconds).
+   * When this property is changed, the reverb will be recaculated, so only change this sparsely..
+   *
+   * @name roomfade
+   * @synonyms rfade
+   * @param {number} seconds for the reverb to fade
+   * @example
+   * s("bd sd").room(0.5).rlp(10000).rfade(0.5)
+   * @example
+   * s("bd sd").room(0.5).rlp(5000).rfade(4)
+   *
+   */
+  ['roomfade', 'rfade'],
   /**
    * Sets the room size of the reverb, see {@link room}.
+   * When this property is changed, the reverb will be recaculated, so only change this sparsely..
    *
    * @name roomsize
    * @param {number | Pattern} size between 0 and 10
-   * @synonyms size, sz
+   * @synonyms rsize, sz, size
    * @example
-   * s("bd sd").room(.8).roomsize("<0 1 2 4 8>")
+   * s("bd sd").room(.8).rsize(1)
+   * @example
+   * s("bd sd").room(.8).rsize(4)
    *
    */
   // TODO: find out why :
   // s("bd sd").room(.8).roomsize("<0 .2 .4 .6 .8 [1,0]>").osc()
   // .. does not work. Is it because room is only one effect?
-  ['size', 'sz', 'roomsize'],
+  ['roomsize', 'size', 'sz', 'rsize'],
   // ['sagogo'],
   // ['sclap'],
   // ['sclaves'],
@@ -1153,7 +1206,7 @@ const generic_params = [
   ['pitchJump'],
   ['pitchJumpTime'],
   ['lfo', 'repeatTime'],
-  ['noise'],
+  ['znoise'], // noise on the frequency or as bubo calls it "frequency fog" :)
   ['zmod'],
   ['zcrush'], // like crush but scaled differently
   ['zdelay'],

packages/superdough/helpers.mjs

@@ -112,3 +112,25 @@ export function createFilter(
 
   return filter;
 }
+
+// stays 1 until .5, then fades out
+let wetfade = (d) => (d < 0.5 ? 1 : 1 - (d - 0.5) / 0.5);
+
+// mix together dry and wet nodes. 0 = only dry 1 = only wet
+// still not too sure about how this could be used more generally...
+export function drywet(dry, wet, wetAmount = 0) {
+  const ac = getAudioContext();
+  if (!wetAmount) {
+    return dry;
+  }
+  let dry_gain = ac.createGain();
+  let wet_gain = ac.createGain();
+  dry.connect(dry_gain);
+  wet.connect(wet_gain);
+  dry_gain.gain.value = wetfade(wetAmount);
+  wet_gain.gain.value = wetfade(1 - wetAmount);
+  let mix = ac.createGain();
+  dry_gain.connect(mix);
+  wet_gain.connect(mix);
+  return mix;
+}

packages/superdough/noise.mjs

@@ -0,0 +1,63 @@
+import { drywet } from './helpers.mjs';
+import { getAudioContext } from './superdough.mjs';
+
+let noiseCache = {};
+
+// lazy generates noise buffers and keeps them forever
+function getNoiseBuffer(type) {
+  const ac = getAudioContext();
+  if (noiseCache[type]) {
+    return noiseCache[type];
+  }
+  const bufferSize = 2 * ac.sampleRate;
+  const noiseBuffer = ac.createBuffer(1, bufferSize, ac.sampleRate);
+  const output = noiseBuffer.getChannelData(0);
+  let lastOut = 0;
+  let b0, b1, b2, b3, b4, b5, b6;
+  b0 = b1 = b2 = b3 = b4 = b5 = b6 = 0.0;
+
+  for (let i = 0; i < bufferSize; i++) {
+    if (type === 'white') {
+      output[i] = Math.random() * 2 - 1;
+    } else if (type === 'brown') {
+      let white = Math.random() * 2 - 1;
+      output[i] = (lastOut + 0.02 * white) / 1.02;
+      lastOut = output[i];
+    } else if (type === 'pink') {
+      let white = Math.random() * 2 - 1;
+      b0 = 0.99886 * b0 + white * 0.0555179;
+      b1 = 0.99332 * b1 + white * 0.0750759;
+      b2 = 0.969 * b2 + white * 0.153852;
+      b3 = 0.8665 * b3 + white * 0.3104856;
+      b4 = 0.55 * b4 + white * 0.5329522;
+      b5 = -0.7616 * b5 - white * 0.016898;
+      output[i] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;
+      output[i] *= 0.11;
+      b6 = white * 0.115926;
+    }
+  }
+  noiseCache[type] = noiseBuffer;
+  return noiseBuffer;
+}
+
+// expects one of noises as type
+export function getNoiseOscillator(type = 'white', t) {
+  const ac = getAudioContext();
+  const o = ac.createBufferSource();
+  o.buffer = getNoiseBuffer(type);
+  o.loop = true;
+  o.start(t);
+  return {
+    node: o,
+    stop: (time) => o.stop(time),
+  };
+}
+
+export function getNoiseMix(inputNode, wet, t) {
+  const noiseOscillator = getNoiseOscillator('pink', t);
+  const noiseMix = drywet(inputNode, noiseOscillator.node, wet);
+  return {
+    node: noiseMix,
+    stop: (time) => noiseOscillator?.stop(time),
+  };
+}

packages/superdough/reverb.mjs

@@ -1,23 +1,30 @@
-if (typeof AudioContext !== 'undefined') {
-  AudioContext.prototype.impulseResponse = function (duration, channels = 1) {
-    const length = this.sampleRate * duration;
-    const impulse = this.createBuffer(channels, length, this.sampleRate);
-    const IR = impulse.getChannelData(0);
-    for (let i = 0; i < length; i++) IR[i] = (2 * Math.random() - 1) * Math.pow(1 - i / length, duration);
-    return impulse;
-  };
+import reverbGen from './reverbGen.mjs';
 
-  AudioContext.prototype.createReverb = function (duration) {
+if (typeof AudioContext !== 'undefined') {
+  AudioContext.prototype.generateReverb = reverbGen.generateReverb;
+  AudioContext.prototype.createReverb = function (duration, fade, lp, dim) {
     const convolver = this.createConvolver();
-    convolver.setDuration = (d) => {
-      convolver.buffer = this.impulseResponse(d);
-      convolver.duration = duration;
-      return convolver;
+    convolver.generate = (d, fade, lp, dim) => {
+      this.generateReverb(
+        {
+          audioContext: this,
+          sampleRate: 44100,
+          numChannels: 2,
+          decayTime: d,
+          fadeInTime: fade,
+          lpFreqStart: lp,
+          lpFreqEnd: dim,
+        },
+        (buffer) => {
+          convolver.buffer = buffer;
+        },
+      );
+      convolver.duration = d;
+      convolver.fade = fade;
+      convolver.lp = lp;
+      convolver.dim = dim;
     };
-    convolver.setDuration(duration);
+    convolver.generate(duration, fade, lp, dim);
     return convolver;
   };
 }
-
-// TODO: make the reverb more exciting
-// check out https://blog.gskinner.com/archives/2019/02/reverb-web-audio-api.html

packages/superdough/reverbGen.mjs

@@ -0,0 +1,129 @@
+// Copyright 2014 Alan deLespinasse
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+var reverbGen = {};
+
+/** Generates a reverb impulse response.
+
+    @param {!Object} params TODO: Document the properties.
+    @param {!function(!AudioBuffer)} callback Function to call when
+      the impulse response has been generated. The impulse response
+      is passed to this function as its parameter. May be called
+      immediately within the current execution context, or later. */
+reverbGen.generateReverb = function (params, callback) {
+  var audioContext = params.audioContext || new AudioContext();
+  var sampleRate = params.sampleRate || 44100;
+  var numChannels = params.numChannels || 2;
+  // params.decayTime is the -60dB fade time. We let it go 50% longer to get to -90dB.
+  var totalTime = params.decayTime * 1.5;
+  var decaySampleFrames = Math.round(params.decayTime * sampleRate);
+  var numSampleFrames = Math.round(totalTime * sampleRate);
+  var fadeInSampleFrames = Math.round((params.fadeInTime || 0) * sampleRate);
+  // 60dB is a factor of 1 million in power, or 1000 in amplitude.
+  var decayBase = Math.pow(1 / 1000, 1 / decaySampleFrames);
+  var reverbIR = audioContext.createBuffer(numChannels, numSampleFrames, sampleRate);
+  for (var i = 0; i < numChannels; i++) {
+    var chan = reverbIR.getChannelData(i);
+    for (var j = 0; j < numSampleFrames; j++) {
+      chan[j] = randomSample() * Math.pow(decayBase, j);
+    }
+    for (var j = 0; j < fadeInSampleFrames; j++) {
+      chan[j] *= j / fadeInSampleFrames;
+    }
+  }
+
+  applyGradualLowpass(reverbIR, params.lpFreqStart || 0, params.lpFreqEnd || 0, params.decayTime, callback);
+};
+
+/** Creates a canvas element showing a graph of the given data.
+
+    @param {!Float32Array} data An array of numbers, or a Float32Array.
+    @param {number} width Width in pixels of the canvas.
+    @param {number} height Height in pixels of the canvas.
+    @param {number} min Minimum value of data for the graph (lower edge).
+    @param {number} max Maximum value of data in the graph (upper edge).
+    @return {!CanvasElement} The generated canvas element. */
+reverbGen.generateGraph = function (data, width, height, min, max) {
+  var canvas = document.createElement('canvas');
+  canvas.width = width;
+  canvas.height = height;
+  var gc = canvas.getContext('2d');
+  gc.fillStyle = '#000';
+  gc.fillRect(0, 0, canvas.width, canvas.height);
+  gc.fillStyle = '#fff';
+  var xscale = width / data.length;
+  var yscale = height / (max - min);
+  for (var i = 0; i < data.length; i++) {
+    gc.fillRect(i * xscale, height - (data[i] - min) * yscale, 1, 1);
+  }
+  return canvas;
+};
+
+/** Applies a constantly changing lowpass filter to the given sound.
+
+    @private
+    @param {!AudioBuffer} input
+    @param {number} lpFreqStart
+    @param {number} lpFreqEnd
+    @param {number} lpFreqEndAt
+    @param {!function(!AudioBuffer)} callback May be called
+    immediately within the current execution context, or later.*/
+var applyGradualLowpass = function (input, lpFreqStart, lpFreqEnd, lpFreqEndAt, callback) {
+  if (lpFreqStart == 0) {
+    callback(input);
+    return;
+  }
+  var channelData = getAllChannelData(input);
+  var context = new OfflineAudioContext(input.numberOfChannels, channelData[0].length, input.sampleRate);
+  var player = context.createBufferSource();
+  player.buffer = input;
+  var filter = context.createBiquadFilter();
+
+  lpFreqStart = Math.min(lpFreqStart, input.sampleRate / 2);
+  lpFreqEnd = Math.min(lpFreqEnd, input.sampleRate / 2);
+
+  filter.type = 'lowpass';
+  filter.Q.value = 0.0001;
+  filter.frequency.setValueAtTime(lpFreqStart, 0);
+  filter.frequency.linearRampToValueAtTime(lpFreqEnd, lpFreqEndAt);
+
+  player.connect(filter);
+  filter.connect(context.destination);
+  player.start();
+  context.oncomplete = function (event) {
+    callback(event.renderedBuffer);
+  };
+  context.startRendering();
+
+  window.filterNode = filter;
+};
+
+/** @private
+    @param {!AudioBuffer} buffer
+    @return {!Array.<!Float32Array>} An array containing the Float32Array of each channel's samples. */
+var getAllChannelData = function (buffer) {
+  var channels = [];
+  for (var i = 0; i < buffer.numberOfChannels; i++) {
+    channels[i] = buffer.getChannelData(i);
+  }
+  return channels;
+};
+
+/** @private
+    @return {number} A random number from -1 to 1. */
+var randomSample = function () {
+  return Math.random() * 2 - 1;
+};
+
+export default reverbGen;

packages/superdough/superdough.mjs

@@ -107,17 +107,25 @@ function getDelay(orbit, delaytime, delayfeedback, t) {
 }
 
 let reverbs = {};
-function getReverb(orbit, duration = 2) {
+
+function getReverb(orbit, duration = 2, fade, lp, dim) {
+  // If no reverb has been created for a given orbit, create one
   if (!reverbs[orbit]) {
     const ac = getAudioContext();
-    const reverb = ac.createReverb(duration);
+    const reverb = ac.createReverb(duration, fade, lp, dim);
     reverb.connect(getDestination());
     reverbs[orbit] = reverb;
   }
-  if (reverbs[orbit].duration !== duration) {
-    reverbs[orbit] = reverbs[orbit].setDuration(duration);
-    reverbs[orbit].duration = duration;
+
+  if (
+    reverbs[orbit].duration !== duration ||
+    reverbs[orbit].fade !== fade ||
+    reverbs[orbit].lp !== lp ||
+    reverbs[orbit].dim !== dim
+  ) {
+    reverbs[orbit].generate(duration, fade, lp, dim);
   }
+
   return reverbs[orbit];
 }
 
@@ -215,7 +223,10 @@ export const superdough = async (value, deadline, hapDuration) => {
     delaytime = 0.25,
     orbit = 1,
     room,
-    size = 2,
+    roomfade = 0.1,
+    roomlp = 15000,
+    roomdim = 1000,
+    roomsize = 2,
     velocity = 1,
     analyze, // analyser wet
     fft = 8, // fftSize 0 - 10
@@ -353,8 +364,8 @@ export const superdough = async (value, deadline, hapDuration) => {
   }
   // reverb
   let reverbSend;
-  if (room > 0 && size > 0) {
-    const reverbNode = getReverb(orbit, size);
+  if (room > 0 && roomsize > 0) {
+    const reverbNode = getReverb(orbit, roomsize, roomfade, roomlp, roomdim);
     reverbSend = effectSend(post, reverbNode, room);
   }
 

packages/superdough/synth.mjs

@@ -1,6 +1,7 @@
 import { midiToFreq, noteToMidi } from './util.mjs';
 import { registerSound, getAudioContext } from './superdough.mjs';
 import { gainNode, getEnvelope, getExpEnvelope } from './helpers.mjs';
+import { getNoiseMix, getNoiseOscillator } from './noise.mjs';
 
 const mod = (freq, range = 1, type = 'sine') => {
   const ctx = getAudioContext();
@@ -20,75 +21,26 @@ const fm = (osc, harmonicityRatio, modulationIndex, wave = 'sine') => {
   return mod(modfreq, modgain, wave);
 };
 
+const waveforms = ['sine', 'square', 'triangle', 'sawtooth'];
+const noises = ['pink', 'white', 'brown'];
+
 export function registerSynthSounds() {
-  ['sine', 'square', 'triangle', 'sawtooth'].forEach((wave) => {
+  [...waveforms, ...noises].forEach((s) => {
     registerSound(
-      wave,
+      s,
       (t, value, onended) => {
         // destructure adsr here, because the default should be different for synths and samples
-        let {
-          attack = 0.001,
-          decay = 0.05,
-          sustain = 0.6,
-          release = 0.01,
-          fmh: fmHarmonicity = 1,
-          fmi: fmModulationIndex,
-          fmenv: fmEnvelopeType = 'lin',
-          fmattack: fmAttack,
-          fmdecay: fmDecay,
-          fmsustain: fmSustain,
-          fmrelease: fmRelease,
-          fmvelocity: fmVelocity,
-          fmwave: fmWaveform = 'sine',
-          vib = 0,
-          vibmod = 0.5,
-        } = value;
-        let { n, note, freq } = value;
-        // with synths, n and note are the same thing
-        note = note || 36;
-        if (typeof note === 'string') {
-          note = noteToMidi(note); // e.g. c3 => 48
-        }
-        // get frequency
-        if (!freq && typeof note === 'number') {
-          freq = midiToFreq(note); // + 48);
-        }
-        // maybe pull out the above frequency resolution?? (there is also getFrequency but it has no default)
-        // make oscillator
-        const { node: o, stop } = getOscillator({
-          t,
-          s: wave,
-          freq,
-          vib,
-          vibmod,
-          partials: n,
-        });
+        let { attack = 0.001, decay = 0.05, sustain = 0.6, release = 0.01 } = value;
 
-        // FM + FM envelope
-        let stopFm, fmEnvelope;
-        if (fmModulationIndex) {
-          const { node: modulator, stop } = fm(o, fmHarmonicity, fmModulationIndex, fmWaveform);
-          if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].find((v) => v !== undefined)) {
-            // no envelope by default
-            modulator.connect(o.frequency);
-          } else {
-            fmAttack = fmAttack ?? 0.001;
-            fmDecay = fmDecay ?? 0.001;
-            fmSustain = fmSustain ?? 1;
-            fmRelease = fmRelease ?? 0.001;
-            fmVelocity = fmVelocity ?? 1;
-            fmEnvelope = getEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
-            if (fmEnvelopeType === 'exp') {
-              fmEnvelope = getExpEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
-              fmEnvelope.node.maxValue = fmModulationIndex * 2;
-              fmEnvelope.node.minValue = 0.00001;
-            }
-            modulator.connect(fmEnvelope.node);
-            fmEnvelope.node.connect(o.frequency);
-          }
-          stopFm = stop;
+        let sound;
+        if (waveforms.includes(s)) {
+          sound = getOscillator(s, t, value);
+        } else {
+          sound = getNoiseOscillator(s, t);
         }
 
+        let { node: o, stop, triggerRelease } = sound;
+
         // turn down
         const g = gainNode(0.3);
 
@@ -104,10 +56,9 @@ export function registerSynthSounds() {
           node: o.connect(g).connect(envelope),
           stop: (releaseTime) => {
             releaseEnvelope(releaseTime);
-            fmEnvelope?.stop(releaseTime);
+            triggerRelease?.(releaseTime);
             let end = releaseTime + release;
             stop(end);
-            stopFm?.(end);
           },
         };
       },
@@ -146,36 +97,108 @@ export function waveformN(partials, type) {
   return osc;
 }
 
-export function getOscillator({ s, freq, t, vib, vibmod, partials }) {
-  // Make oscillator with partial count
+// expects one of waveforms as s
+export function getOscillator(
+  s,
+  t,
+  {
+    n: partials,
+    note,
+    freq,
+    vib = 0,
+    vibmod = 0.5,
+    noise = 0,
+    // fm
+    fmh: fmHarmonicity = 1,
+    fmi: fmModulationIndex,
+    fmenv: fmEnvelopeType = 'lin',
+    fmattack: fmAttack,
+    fmdecay: fmDecay,
+    fmsustain: fmSustain,
+    fmrelease: fmRelease,
+    fmvelocity: fmVelocity,
+    fmwave: fmWaveform = 'sine',
+  },
+) {
+  let ac = getAudioContext();
   let o;
+  // If no partials are given, use stock waveforms
   if (!partials || s === 'sine') {
     o = getAudioContext().createOscillator();
     o.type = s || 'triangle';
-  } else {
+  }
+  // generate custom waveform if partials are given
+  else {
     o = waveformN(partials, s);
   }
+
+  // get frequency from note...
+  note = note || 36;
+  if (typeof note === 'string') {
+    note = noteToMidi(note); // e.g. c3 => 48
+  }
+  // get frequency
+  if (!freq && typeof note === 'number') {
+    freq = midiToFreq(note); // + 48);
+  }
+
+  // set frequency
   o.frequency.value = Number(freq);
   o.start(t);
 
+  // FM
+  let stopFm, fmEnvelope;
+  if (fmModulationIndex) {
+    const { node: modulator, stop } = fm(o, fmHarmonicity, fmModulationIndex, fmWaveform);
+    if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].find((v) => v !== undefined)) {
+      // no envelope by default
+      modulator.connect(o.frequency);
+    } else {
+      fmAttack = fmAttack ?? 0.001;
+      fmDecay = fmDecay ?? 0.001;
+      fmSustain = fmSustain ?? 1;
+      fmRelease = fmRelease ?? 0.001;
+      fmVelocity = fmVelocity ?? 1;
+      fmEnvelope = getEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
+      if (fmEnvelopeType === 'exp') {
+        fmEnvelope = getExpEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
+        fmEnvelope.node.maxValue = fmModulationIndex * 2;
+        fmEnvelope.node.minValue = 0.00001;
+      }
+      modulator.connect(fmEnvelope.node);
+      fmEnvelope.node.connect(o.frequency);
+    }
+    stopFm = stop;
+  }
+
   // Additional oscillator for vibrato effect
-  let vibrato_oscillator;
+  let vibratoOscillator;
   if (vib > 0) {
-    vibrato_oscillator = getAudioContext().createOscillator();
-    vibrato_oscillator.frequency.value = vib;
+    vibratoOscillator = getAudioContext().createOscillator();
+    vibratoOscillator.frequency.value = vib;
     const gain = getAudioContext().createGain();
     // Vibmod is the amount of vibrato, in semitones
     gain.gain.value = vibmod * 100;
-    vibrato_oscillator.connect(gain);
+    vibratoOscillator.connect(gain);
     gain.connect(o.detune);
-    vibrato_oscillator.start(t);
+    vibratoOscillator.start(t);
+  }
+
+  let noiseMix;
+  if (noise) {
+    noiseMix = getNoiseMix(o, noise, t);
   }
 
   return {
-    node: o,
+    node: noiseMix?.node || o,
     stop: (time) => {
-      vibrato_oscillator?.stop(time);
+      vibratoOscillator?.stop(time);
+      noiseMix?.stop(time);
+      stopFm?.(time);
       o.stop(time);
     },
+    triggerRelease: (time) => {
+      fmEnvelope?.stop(time);
+    },
   };
 }

packages/superdough/zzfx.mjs

@@ -20,7 +20,7 @@ export const getZZFX = (value, t) => {
     pitchJump = 0,
     pitchJumpTime = 0,
     lfo = 0,
-    noise = 0,
+    znoise = 0,
     zmod = 0,
     zcrush = 0,
     zdelay = 0,
@@ -54,7 +54,7 @@ export const getZZFX = (value, t) => {
     pitchJump,
     pitchJumpTime,
     lfo,
-    noise,
+    znoise,
     zmod,
     zcrush,
     zdelay,

packages/transpiler/transpiler.mjs

@@ -43,6 +43,7 @@ export function transpiler(input, options = {}) {
             value: node.arguments[0].raw, // don't use value!
             min: node.arguments[1]?.value ?? 0,
             max: node.arguments[2]?.value ?? 1,
+            step: node.arguments[3]?.value,
           });
         return this.replace(widgetWithLocation(node));
       }

test/__snapshots__/examples.test.mjs.snap

@@ -2959,6 +2959,15 @@ exports[`runs examples > example "never" example index 0 1`] = `
 ]
 `;
 
+exports[`runs examples > example "noise" example index 0 1`] = `
+[
+  "[ (0/1 → 1/1) ⇝ 2/1 | s:white ]",
+  "[ 0/1 ⇜ (1/1 → 2/1) | s:white ]",
+  "[ (2/1 → 3/1) ⇝ 4/1 | s:pink ]",
+  "[ 2/1 ⇜ (3/1 → 4/1) | s:pink ]",
+]
+`;
+
 exports[`runs examples > example "note" example index 0 1`] = `
 [
   "[ 0/1 → 1/4 | note:c ]",
@@ -3654,16 +3663,107 @@ exports[`runs examples > example "room" example index 1 1`] = `
 ]
 `;
 
+exports[`runs examples > example "roomdim" example index 0 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd room:0.5 roomlp:10000 roomdim:8000 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.5 roomlp:10000 roomdim:8000 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.5 roomlp:10000 roomdim:8000 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.5 roomlp:10000 roomdim:8000 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.5 roomlp:10000 roomdim:8000 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.5 roomlp:10000 roomdim:8000 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.5 roomlp:10000 roomdim:8000 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.5 roomlp:10000 roomdim:8000 ]",
+]
+`;
+
+exports[`runs examples > example "roomdim" example index 1 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd room:0.5 roomlp:5000 roomdim:400 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.5 roomlp:5000 roomdim:400 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.5 roomlp:5000 roomdim:400 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.5 roomlp:5000 roomdim:400 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.5 roomlp:5000 roomdim:400 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.5 roomlp:5000 roomdim:400 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.5 roomlp:5000 roomdim:400 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.5 roomlp:5000 roomdim:400 ]",
+]
+`;
+
+exports[`runs examples > example "roomfade" example index 0 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd room:0.5 roomlp:10000 roomfade:0.5 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.5 roomlp:10000 roomfade:0.5 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.5 roomlp:10000 roomfade:0.5 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.5 roomlp:10000 roomfade:0.5 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.5 roomlp:10000 roomfade:0.5 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.5 roomlp:10000 roomfade:0.5 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.5 roomlp:10000 roomfade:0.5 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.5 roomlp:10000 roomfade:0.5 ]",
+]
+`;
+
+exports[`runs examples > example "roomfade" example index 1 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd room:0.5 roomlp:5000 roomfade:4 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.5 roomlp:5000 roomfade:4 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.5 roomlp:5000 roomfade:4 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.5 roomlp:5000 roomfade:4 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.5 roomlp:5000 roomfade:4 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.5 roomlp:5000 roomfade:4 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.5 roomlp:5000 roomfade:4 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.5 roomlp:5000 roomfade:4 ]",
+]
+`;
+
+exports[`runs examples > example "roomlp" example index 0 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd room:0.5 roomlp:10000 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.5 roomlp:10000 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.5 roomlp:10000 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.5 roomlp:10000 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.5 roomlp:10000 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.5 roomlp:10000 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.5 roomlp:10000 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.5 roomlp:10000 ]",
+]
+`;
+
+exports[`runs examples > example "roomlp" example index 1 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd room:0.5 roomlp:5000 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.5 roomlp:5000 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.5 roomlp:5000 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.5 roomlp:5000 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.5 roomlp:5000 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.5 roomlp:5000 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.5 roomlp:5000 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.5 roomlp:5000 ]",
+]
+`;
+
 exports[`runs examples > example "roomsize" example index 0 1`] = `
 [
-  "[ 0/1 → 1/2 | s:bd room:0.8 size:0 ]",
-  "[ 1/2 → 1/1 | s:sd room:0.8 size:0 ]",
-  "[ 1/1 → 3/2 | s:bd room:0.8 size:1 ]",
-  "[ 3/2 → 2/1 | s:sd room:0.8 size:1 ]",
-  "[ 2/1 → 5/2 | s:bd room:0.8 size:2 ]",
-  "[ 5/2 → 3/1 | s:sd room:0.8 size:2 ]",
-  "[ 3/1 → 7/2 | s:bd room:0.8 size:4 ]",
-  "[ 7/2 → 4/1 | s:sd room:0.8 size:4 ]",
+  "[ 0/1 → 1/2 | s:bd room:0.8 roomsize:1 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.8 roomsize:1 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.8 roomsize:1 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.8 roomsize:1 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.8 roomsize:1 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.8 roomsize:1 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.8 roomsize:1 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.8 roomsize:1 ]",
+]
+`;
+
+exports[`runs examples > example "roomsize" example index 1 1`] = `
+[
+  "[ 0/1 → 1/2 | s:bd room:0.8 roomsize:4 ]",
+  "[ 1/2 → 1/1 | s:sd room:0.8 roomsize:4 ]",
+  "[ 1/1 → 3/2 | s:bd room:0.8 roomsize:4 ]",
+  "[ 3/2 → 2/1 | s:sd room:0.8 roomsize:4 ]",
+  "[ 2/1 → 5/2 | s:bd room:0.8 roomsize:4 ]",
+  "[ 5/2 → 3/1 | s:sd room:0.8 roomsize:4 ]",
+  "[ 3/1 → 7/2 | s:bd room:0.8 roomsize:4 ]",
+  "[ 7/2 → 4/1 | s:sd room:0.8 roomsize:4 ]",
 ]
 `;
 

website/src/pages/learn/effects.mdx

@@ -183,24 +183,40 @@ global effects use the same chain for all events of the same orbit:
 
 <JsDoc client:idle name="orbit" h={0} />
 
-## delay
+## Delay
+
+### delay
 
 <JsDoc client:idle name="delay" h={0} />
 
-## delaytime
+### delaytime
 
 <JsDoc client:idle name="delaytime" h={0} />
 
-## delayfeedback
+### delayfeedback
 
 <JsDoc client:idle name="delayfeedback" h={0} />
 
-## room
+## Reverb
+
+### room
 
 <JsDoc client:idle name="room" h={0} />
 
-## roomsize
+### roomsize
 
 <JsDoc client:idle name="roomsize" h={0} />
 
+### roomfade
+
+<JsDoc client:idle name="roomfade" h={0} />
+
+### roomlp
+
+<JsDoc client:idle name="roomlp" h={0} />
+
+### roomdim
+
+<JsDoc client:idle name="roomdim" h={0} />
+
 Next, we'll look at strudel's support for [Csound](/learn/csound).

website/src/pages/learn/synths.mdx

@@ -23,6 +23,25 @@ The basic waveforms are `sine`, `sawtooth`, `square` and `triangle`, which can b
 
 If you don't set a `sound` but a `note` the default value for `sound` is `triangle`!
 
+## Noise
+
+You can also use noise as a source by setting the waveform to: `white`, `pink` or `brown`. These are different
+flavours of noise, here written from hard to soft.
+
+<MiniRepl client:idle tune={`sound("<white pink brown>/2").scope()`} />
+
+Here's a more musical example of how to use noise for hihats:
+
+<MiniRepl
+  client:idle
+  tune={`sound("bd*2,<white pink brown>*8")
+.decay(.04).sustain(0).scope()`}
+/>
+
+Some amount of pink noise can also be added to any oscillator by using the `noise` paremeter:
+
+<MiniRepl client:idle tune={`note("c3").noise("<0.1 0.25 0.5>").scope()`} />
+
 ### Additive Synthesis
 
 To tame the harsh sound of the basic waveforms, we can set the `n` control to limit the overtones of the waveform: