Merge branch 'main' into pump

packages/core/controls.mjs

@@ -252,6 +252,20 @@ export const { fmenv } = registerControl('fmenv');
  *
  */
 export const { fmattack } = registerControl('fmattack');
+
+/**
+ * waveform of the fm modulator
+ *
+ * @name fmwave
+ * @param {number | Pattern} wave waveform
+ * @example
+ * n("0 1 2 3".fast(4)).scale("d:minor").s("sine").fmwave("<sine square sawtooth crackle>").fm(4).fmh(2.01)
+ * @example
+ * n("0 1 2 3".fast(4)).chord("<Dm Am F G>").voicing().s("sawtooth").fmwave("brown").fm(.6)
+ *
+ */
+export const { fmwave } = registerControl('fmwave');
+
 /**
  * Decay time for the FM envelope: seconds until the sustain level is reached after the attack phase.
  *

packages/repl/prebake.mjs

@@ -36,7 +36,7 @@ export async function prebake() {
     samples(`${ds}/tidal-drum-machines.json`),
     samples(`${ds}/piano.json`),
     samples(`${ds}/Dirt-Samples.json`),
-    samples(`https://raw.githubusercontent.com/tidalcycles/uzu-drumkit/main/strudel.json`),
+    samples(`${ds}/uzu-drumkit.json`),
     samples(`${ds}/vcsl.json`),
     samples(`${ds}/mridangam.json`),
   ]);

packages/superdough/helpers.mjs

@@ -1,5 +1,8 @@
 import { getAudioContext } from './superdough.mjs';
 import { clamp, nanFallback } from './util.mjs';
+import { getNoiseBuffer } from './noise.mjs';
+
+export const noises = ['pink', 'white', 'brown', 'crackle'];
 
 export function gainNode(value) {
   const node = getAudioContext().createGain();
@@ -217,9 +220,17 @@ export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
 }
 const mod = (freq, range = 1, type = 'sine') => {
   const ctx = getAudioContext();
-  const osc = ctx.createOscillator();
-  osc.type = type;
-  osc.frequency.value = freq;
+  let osc;
+  if (noises.includes(type)) {
+    osc = ctx.createBufferSource();
+    osc.buffer = getNoiseBuffer(type, 2);
+    osc.loop = true;
+  } else {
+    osc = ctx.createOscillator();
+    osc.type = type;
+    osc.frequency.value = freq;
+  }
+
   osc.start();
   const g = new GainNode(ctx, { gain: range });
   osc.connect(g); // -range, range

packages/superdough/noise.mjs

@@ -4,7 +4,7 @@ import { getAudioContext } from './superdough.mjs';
 let noiseCache = {};
 
 // lazy generates noise buffers and keeps them forever
-function getNoiseBuffer(type, density) {
+export function getNoiseBuffer(type, density) {
   const ac = getAudioContext();
   if (noiseCache[type]) {
     return noiseCache[type];

packages/superdough/synth.mjs

@@ -9,12 +9,13 @@ import {
   getVibratoOscillator,
   webAudioTimeout,
   getWorklet,
+  noises,
 } from './helpers.mjs';
 import { getNoiseMix, getNoiseOscillator } from './noise.mjs';
 
-const getFrequencyFromValue = (value) => {
+const getFrequencyFromValue = (value, defaultNote = 36) => {
   let { note, freq } = value;
-  note = note || 36;
+  note = note || defaultNote;
   if (typeof note === 'string') {
     note = noteToMidi(note); // e.g. c3 => 48
   }
@@ -40,7 +41,17 @@ const waveformAliases = [
   ['saw', 'sawtooth'],
   ['sin', 'sine'],
 ];
-const noises = ['pink', 'white', 'brown', 'crackle'];
+
+function makeSaturationCurve(amount, n_samples) {
+  const k = typeof amount === 'number' ? amount : 50;
+  const curve = new Float32Array(n_samples);
+
+  for (let i = 0; i < n_samples; i++) {
+    const x = (i * 2) / n_samples - 1;
+    curve[i] = Math.tanh(x * k);
+  }
+  return curve;
+}
 
 export function registerSynthSounds() {
   [...waveforms].forEach((s) => {
@@ -84,6 +95,75 @@ export function registerSynthSounds() {
       { type: 'synth', prebake: true },
     );
   });
+
+  registerSound(
+    'sbd',
+    (t, value, onended) => {
+      const { duration, decay = 0.5, pdecay = 0.5, penv = 36, clip } = value;
+      const ctx = getAudioContext();
+      const attackhold = 0.02;
+      const noiselvl = 1.2;
+      const noisedecay = 0.025;
+      const mixGain = 1;
+
+      const o = ctx.createOscillator();
+      o.type = 'triangle';
+      o.frequency.value = getFrequencyFromValue(value, 29);
+      o.detune.setValueAtTime(penv * 100, 0);
+      o.detune.setValueAtTime(penv * 100, t);
+      o.detune.exponentialRampToValueAtTime(0.001, t + pdecay);
+      const g = gainNode(1);
+      g.gain.setValueAtTime(1, t + attackhold);
+      g.gain.exponentialRampToValueAtTime(0.001, t + attackhold + decay);
+      o.start(t);
+
+      const noise = getNoiseOscillator('brown', t, 2);
+      const noiseGain = gainNode(1);
+      noiseGain.gain.setValueAtTime(noiselvl, t);
+      noiseGain.gain.exponentialRampToValueAtTime(0.001, t + noisedecay);
+
+      const sat = new WaveShaperNode(ctx);
+      // tri to sine diode shaper emulation
+      sat.curve = makeSaturationCurve(2, ctx.sampleRate);
+
+      const mix = gainNode(mixGain);
+
+      o.onended = () => {
+        o.disconnect();
+        g.disconnect();
+        sat.disconnect();
+        noise.node.disconnect();
+        noiseGain.disconnect();
+        mix.disconnect();
+        onended();
+      };
+
+      const node = o.connect(sat).connect(g).connect(mix);
+      noise.node.connect(noiseGain).connect(mix);
+
+      const holdEnd = t + decay;
+      let end = holdEnd + 0.01;
+      if (clip != null) {
+        end = Math.min(t + clip * duration, end);
+      }
+
+      // prevent clicking
+      mix.gain.setValueAtTime(mixGain, end - 0.01);
+      mix.gain.linearRampToValueAtTime(0, end);
+
+      o.stop(end);
+      noise.stop(end);
+
+      return {
+        node,
+        stop: (endTime) => {
+          o.stop(endTime);
+        },
+      };
+    },
+    { type: 'synth', prebake: true },
+  );
+
   registerSound(
     'supersaw',
     (begin, value, onended) => {