Gain Modulation with calculated modulation per event

packages/core/controls.mjs

@@ -430,6 +430,60 @@ export const { crush } = registerControl('crush');
  */
 export const { coarse } = registerControl('coarse');
 
+/**
+ * modulate the amplitude of a sound with a continuous waveform
+ *
+ * @name am
+ * @synonyms tremelo
+ * @param {number | Pattern} speed modulation speed in cycles
+ * @example
+ * s("triangle").am("2").amshape("<tri saw ramp square>").amdepth(.5)
+ *
+ */
+export const { am, tremolo } = registerControl(['am', 'amdepth', 'amskew', 'amphase'], 'tremolo');
+
+/**
+ * depth of amplitude modulation
+ *
+ * @name amdepth
+ * @param {number | Pattern} depth
+ * @example
+ * s("triangle").am(1).amdepth("1")
+ *
+ */
+export const { amdepth } = registerControl('amdepth');
+/**
+ * alter the shape of the modulation waveform
+ *
+ * @name amskew
+ * @param {number | Pattern} amount between 0 & 1, the shape of the waveform
+ * @example
+ * note("{f a c e}%16").am(4).amskew("<.5 0 1>")
+ *
+ */
+export const { amskew } = registerControl('amskew');
+
+/**
+ * alter the phase of the modulation waveform
+ *
+ * @name amphase
+ * @param {number | Pattern} offset the offset in cycles of the modulation
+ * @example
+ * note("{f a c e}%16").am(4).amphase("<0 .25 .66>")
+ *
+ */
+export const { amphase } = registerControl('amphase');
+
+/**
+ * shape of amplitude modulation
+ *
+ * @name amshape
+ * @param {number | Pattern} shape tri | square | sine | saw | ramp
+ * @example
+ * note("{f g c d}%16").am(4).amshape("ramp").s("sawtooth")
+ *
+ */
+export const { amshape } = registerControl('amshape');
 /**
  * Allows you to set the output channels on the interface
  *
@@ -1529,7 +1583,6 @@ export const { zmod } = registerControl('zmod');
 // like crush but scaled differently
 export const { zcrush } = registerControl('zcrush');
 export const { zdelay } = registerControl('zdelay');
-export const { tremolo } = registerControl('tremolo');
 export const { zzfx } = registerControl('zzfx');
 
 /**

packages/core/cyclist.mjs

@@ -8,61 +8,51 @@ import createClock from './zyklus.mjs';
 import { logger } from './logger.mjs';
 
 export class Cyclist {
-  constructor({ interval, onTrigger, onToggle, onError, getTime, latency = 0.1, setInterval, clearInterval }) {
+  constructor({ interval = 0.05, onTrigger, onToggle, onError, getTime, latency = 0.1, setInterval, clearInterval }) {
     this.started = false;
     this.cps = 0.5;
-    this.num_ticks_since_cps_change = 0;
-    this.lastTick = 0; // absolute time when last tick (clock callback) happened
-    this.lastBegin = 0; // query begin of last tick
-    this.lastEnd = 0; // query end of last tick
+    this.time_at_last_tick_message = 0;
+    this.cycle = 0;
     this.getTime = getTime; // get absolute time
     this.num_cycles_at_cps_change = 0;
     this.seconds_at_cps_change; // clock phase when cps was changed
+    this.num_ticks_since_cps_change = 0;
     this.onToggle = onToggle;
     this.latency = latency; // fixed trigger time offset
+
+    this.interval = interval;
+
     this.clock = createClock(
       getTime,
       // called slightly before each cycle
-      (phase, duration, _, t) => {
-        if (this.num_ticks_since_cps_change === 0) {
-          this.num_cycles_at_cps_change = this.lastEnd;
-          this.seconds_at_cps_change = phase;
+      (phase, duration, _, time) => {
+        if (this.started === false) {
+          return;
         }
-        this.num_ticks_since_cps_change++;
-        const seconds_since_cps_change = this.num_ticks_since_cps_change * duration;
-        const num_cycles_since_cps_change = seconds_since_cps_change * this.cps;
+        const num_seconds_since_cps_change = this.num_ticks_since_cps_change * duration;
+        const tickdeadline = phase - time;
+        const lastTick = time + tickdeadline;
+        const num_cycles_since_cps_change = num_seconds_since_cps_change * this.cps;
+        const begin = this.num_cycles_at_cps_change + num_cycles_since_cps_change;
+        const secondsSinceLastTick = time - lastTick - duration;
+        const eventLength = duration * this.cps;
+        const end = begin + eventLength;
+        this.cycle = begin + secondsSinceLastTick * this.cps;
 
-        try {
-          const begin = this.lastEnd;
-          this.lastBegin = begin;
-          const end = this.num_cycles_at_cps_change + num_cycles_since_cps_change;
-          this.lastEnd = end;
-          this.lastTick = phase;
+        //account for latency and tick duration when using cycle calculations for audio downstream
+        const cycle_gap = (this.latency - duration) * this.cps;
 
-          if (phase < t) {
-            // avoid querying haps that are in the past anyway
-            console.log(`skip query: too late`);
-            return;
+        const haps = this.pattern.queryArc(begin, end, { _cps: this.cps });
+        haps.forEach((hap) => {
+          if (hap.hasOnset()) {
+            let targetTime = (hap.whole.begin - this.num_cycles_at_cps_change) / this.cps;
+            targetTime = targetTime + this.latency + tickdeadline + time - num_seconds_since_cps_change;
+            const duration = hap.duration / this.cps;
+            onTrigger?.(hap, tickdeadline, duration, this.cps, targetTime, this.cycle - cycle_gap);
           }
-
-          // query the pattern for events
-          const haps = this.pattern.queryArc(begin, end, { _cps: this.cps });
-
-          haps.forEach((hap) => {
-            if (hap.hasOnset()) {
-              const targetTime =
-                (hap.whole.begin - this.num_cycles_at_cps_change) / this.cps + this.seconds_at_cps_change + latency;
-              const duration = hap.duration / this.cps;
-              // the following line is dumb and only here for backwards compatibility
-              // see https://github.com/tidalcycles/strudel/pull/1004
-              const deadline = targetTime - phase;
-              onTrigger?.(hap, deadline, duration, this.cps, targetTime);
-            }
-          });
-        } catch (e) {
-          logger(`[cyclist] error: ${e.message}`);
-          onError?.(e);
-        }
+        });
+        this.time_at_last_tick_message = time;
+        this.num_ticks_since_cps_change++;
       },
       interval, // duration of each cycle
       0.1,
@@ -75,16 +65,24 @@ export class Cyclist {
     if (!this.started) {
       return 0;
     }
-    const secondsSinceLastTick = this.getTime() - this.lastTick - this.clock.duration;
-    return this.lastBegin + secondsSinceLastTick * this.cps; // + this.clock.minLatency;
+    const gap = (this.getTime() - this.time_at_last_tick_message) * this.cps;
+    return this.cycle + gap;
   }
+
+  setCycle = (cycle) => {
+    this.num_ticks_since_cps_change = 0;
+    this.num_cycles_at_cps_change = cycle;
+  };
   setStarted(v) {
     this.started = v;
+
+    this.setCycle(0);
     this.onToggle?.(v);
   }
   start() {
     this.num_ticks_since_cps_change = 0;
     this.num_cycles_at_cps_change = 0;
+
     if (!this.pattern) {
       throw new Error('Scheduler: no pattern set! call .setPattern first.');
     }
@@ -113,6 +111,8 @@ export class Cyclist {
     if (this.cps === cps) {
       return;
     }
+    const num_seconds_since_cps_change = this.num_ticks_since_cps_change * this.interval;
+    this.num_cycles_at_cps_change = this.num_cycles_at_cps_change + num_seconds_since_cps_change * cps;
     this.cps = cps;
     this.num_ticks_since_cps_change = 0;
   }

packages/core/neocyclist.mjs

@@ -10,11 +10,8 @@ export class NeoCyclist {
   constructor({ onTrigger, onToggle, getTime }) {
     this.started = false;
     this.cps = 0.5;
-    this.lastTick = 0; // absolute time when last tick (clock callback) happened
     this.getTime = getTime; // get absolute time
     this.time_at_last_tick_message = 0;
-
-    this.num_cycles_at_cps_change = 0;
     this.onToggle = onToggle;
     this.latency = 0.1; // fixed trigger time offset
     this.cycle = 0;
@@ -86,7 +83,7 @@ export class NeoCyclist {
             this.latency +
             this.worker_time_dif;
           const duration = hap.duration / this.cps;
-          onTrigger?.(hap, 0, duration, this.cps, targetTime);
+          onTrigger?.(hap, 0, duration, this.cps, targetTime, this.cycle);
         }
       });
     };

packages/core/repl.mjs

@@ -178,15 +178,15 @@ export function repl({
 
 export const getTrigger =
   ({ getTime, defaultOutput }) =>
-  async (hap, deadline, duration, cps, t) => {
+  async (hap, deadline, duration, cps, t, cycle = 0) => {
     // TODO: get rid of deadline after https://github.com/tidalcycles/strudel/pull/1004
     try {
       if (!hap.context.onTrigger || !hap.context.dominantTrigger) {
-        await defaultOutput(hap, deadline, duration, cps, t);
+        await defaultOutput(hap, deadline, duration, cps, t, cycle);
       }
       if (hap.context.onTrigger) {
         // call signature of output / onTrigger is different...
-        await hap.context.onTrigger(getTime() + deadline, hap, getTime(), cps, t);
+        await hap.context.onTrigger(getTime() + deadline, hap, getTime(), cps, t, cycle);
       }
     } catch (err) {
       logger(`[cyclist] error: ${err.message}`, 'error');

packages/superdough/superdough.mjs

@@ -260,7 +260,7 @@ export function resetGlobalEffects() {
   analysersData = {};
 }
 
-export const superdough = async (value, t, hapDuration) => {
+export const superdough = async (value, t, hapDuration, cps, cycle) => {
   const ac = getAudioContext();
   if (typeof value !== 'object') {
     throw new Error(
@@ -281,6 +281,10 @@ export const superdough = async (value, t, hapDuration) => {
   }
   // destructure
   let {
+    am,
+    amdepth = 1,
+    amskew = 0.5,
+    amphase = 0,
     s = 'triangle',
     bank,
     source,
@@ -322,8 +326,10 @@ export const superdough = async (value, t, hapDuration) => {
     phasercenter,
     //
     coarse,
+
     crush,
     shape,
+
     shapevol = 1,
     distort,
     distortvol = 1,
@@ -470,6 +476,19 @@ export const superdough = async (value, t, hapDuration) => {
   crush !== undefined && chain.push(getWorklet(ac, 'crush-processor', { crush }));
   shape !== undefined && chain.push(getWorklet(ac, 'shape-processor', { shape, postgain: shapevol }));
   distort !== undefined && chain.push(getWorklet(ac, 'distort-processor', { distort, postgain: distortvol }));
+  am !== undefined &&
+    chain.push(
+      getWorklet(ac, 'am-processor', {
+        speed: am,
+        depth: amdepth,
+        skew: amskew,
+        phaseoffset: amphase,
+        // shape: amshape,
+
+        cps,
+        cycle,
+      }),
+    );
 
   compressorThreshold !== undefined &&
     chain.push(