feat: mutation

app/util/lfo.js

@@ -0,0 +1,65 @@
+import TickingPromise from '@/util/ticking-promise.js';
+
+const Modulators = {
+  flat: () => 0.5,
+  random: () => Math.random(),
+  sawtooth: (unit) => unit,
+  sine: (unit) => 0.5 * (1 + Math.sin(unit * Math.PI * 2)),
+  square: (unit) => (unit < 0.5 ? 0 : 1),
+  triangle: (unit) => 2 * Math.abs(((unit + 0.75) % 1) - 0.5),
+};
+
+export default function lfo(object, properties) {
+  const oscillators = {};
+  for (const key in properties) {
+    const property = properties[key];
+    const oscillator = {
+      count: Infinity,
+      elapsed: 0,
+      offset: 0,
+      ...property,
+    };
+    if (!oscillator.median) {
+      oscillator.median = oscillator.magnitude / 2;
+    }
+    if (!oscillator.modulators) {
+      oscillator.modulators = [Modulators.triangle];
+    }
+    else {
+      const {modulators} = oscillator;
+      for (const i in modulators) {
+        if ('string' === typeof modulators[i]) {
+          modulators[i] = Modulators[modulators[i]];
+        }
+      }
+    }
+    oscillator.low = oscillator.median - oscillator.magnitude / 2;
+    oscillators[key] = oscillator;
+  }
+  let stop;
+  const promise = new TickingPromise(
+    (resolve) => {
+      stop = resolve;
+    },
+    (elapsed, resolve) => {
+      for (const key in oscillators) {
+        const oscillator = oscillators[key];
+        oscillator.elapsed += elapsed;
+        if (oscillator.elapsed >= oscillator.frequency) {
+          if (0 === --oscillator.count) {
+            resolve();
+            return;
+          }
+          oscillator.elapsed = oscillator.elapsed % oscillator.frequency;
+        }
+        const x = ((oscillator.offset + oscillator.elapsed) / oscillator.frequency) % 1;
+        let y = 0;
+        for (const modulator of oscillator.modulators) {
+          y += modulator(x);
+        }
+        object[key] = oscillator.low + oscillator.magnitude * (y / oscillator.modulators.length);
+      }
+    },
+  );
+  return {stop, oscillators, promise};
+}

app/util/transition.js

@@ -0,0 +1,177 @@
+import TickingPromise from '@/util/ticking-promise.js';
+
+/* eslint-disable */
+const Easing = {
+  linear: function (t, b, c, d) {
+    return b + c * t/d
+  },
+  easeInQuad: function (t, b, c, d) {
+    return c*(t/=d)*t + b;
+  },
+  easeOutQuad: function (t, b, c, d) {
+    return -c *(t/=d)*(t-2) + b;
+  },
+  easeInOutQuad: function (t, b, c, d) {
+    if ((t/=d/2) < 1) return c/2*t*t + b;
+    return -c/2 * ((--t)*(t-2) - 1) + b;
+  },
+  easeInCubic: function (t, b, c, d) {
+    return c*(t/=d)*t*t + b;
+  },
+  easeOutCubic: function (t, b, c, d) {
+    return c*((t=t/d-1)*t*t + 1) + b;
+  },
+  easeInOutCubic: function (t, b, c, d) {
+    if ((t/=d/2) < 1) return c/2*t*t*t + b;
+    return c/2*((t-=2)*t*t + 2) + b;
+  },
+  easeInQuart: function (t, b, c, d) {
+    return c*(t/=d)*t*t*t + b;
+  },
+  easeOutQuart: function (t, b, c, d) {
+    return -c * ((t=t/d-1)*t*t*t - 1) + b;
+  },
+  easeInOutQuart: function (t, b, c, d) {
+    if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
+    return -c/2 * ((t-=2)*t*t*t - 2) + b;
+  },
+  easeInQuint: function (t, b, c, d) {
+    return c*(t/=d)*t*t*t*t + b;
+  },
+  easeOutQuint: function (t, b, c, d) {
+    return c*((t=t/d-1)*t*t*t*t + 1) + b;
+  },
+  easeInOutQuint: function (t, b, c, d) {
+    if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
+    return c/2*((t-=2)*t*t*t*t + 2) + b;
+  },
+  easeInSine: function (t, b, c, d) {
+    return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
+  },
+  easeOutSine: function (t, b, c, d) {
+    return c * Math.sin(t/d * (Math.PI/2)) + b;
+  },
+  easeInOutSine: function (t, b, c, d) {
+    return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
+  },
+  easeInExpo: function (t, b, c, d) {
+    return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
+  },
+  easeOutExpo: function (t, b, c, d) {
+    return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
+  },
+  easeInOutExpo: function (t, b, c, d) {
+    if (t==0) return b;
+    if (t==d) return b+c;
+    if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
+    return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
+  },
+  easeInCirc: function (t, b, c, d) {
+    return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
+  },
+  easeOutCirc: function (t, b, c, d) {
+    return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
+  },
+  easeInOutCirc: function (t, b, c, d) {
+    if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
+    return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
+  },
+  easeInElastic: function (t, b, c, d) {
+    var s=1.70158;var p=0;var a=c;
+    if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+    if (a < Math.abs(c)) { a=c; var s=p/4; }
+    else var s = p/(2*Math.PI) * Math.asin (c/a);
+    return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+  },
+  easeOutElastic: function (t, b, c, d) {
+    var s=1.70158;var p=0;var a=c;
+    if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
+    if (a < Math.abs(c)) { a=c; var s=p/4; }
+    else var s = p/(2*Math.PI) * Math.asin (c/a);
+    return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
+  },
+  easeInOutElastic: function (t, b, c, d) {
+    var s=1.70158;var p=0;var a=c;
+    if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
+    if (a < Math.abs(c)) { a=c; var s=p/4; }
+    else var s = p/(2*Math.PI) * Math.asin (c/a);
+    if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+    return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
+  },
+  easeInBack: function (t, b, c, d, s) {
+    if (s == undefined) s = 1.70158;
+    return c*(t/=d)*t*((s+1)*t - s) + b;
+  },
+  easeOutBack: function (t, b, c, d, s) {
+    if (s == undefined) s = 1.70158;
+    return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
+  },
+  easeInOutBack: function (t, b, c, d, s) {
+    if (s == undefined) s = 1.70158;
+    if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
+    return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
+  },
+  easeInBounce: function (t, b, c, d) {
+    return c - easing.easeOutBounce (d-t, 0, c, d) + b;
+  },
+  easeOutBounce: function (t, b, c, d) {
+    if ((t/=d) < (1/2.75)) {
+      return c*(7.5625*t*t) + b;
+    } else if (t < (2/2.75)) {
+      return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
+    } else if (t < (2.5/2.75)) {
+      return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
+    } else {
+      return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
+    }
+  },
+  easeInOutBounce: function (t, b, c, d) {
+    if (t < d/2) return easing.easeInBounce (t*2, 0, c, d) * .5 + b;
+    return easing.easeOutBounce (t*2-d, 0, c, d) * .5 + c*.5 + b;
+  }
+};
+/* eslint-enable */
+
+export default function transition(object, properties) {
+  const transitions = {};
+  for (const key in properties) {
+    const property = properties[key];
+    const transition = {
+      elapsed: 0,
+      start: object[key],
+      ...property,
+    };
+    if (!transition.easing) {
+      transition.easing = Easing.easeOutQuad;
+    }
+    else {
+      if ('string' === typeof transition.easing) {
+        transition.easing = Easing[transition.easing];
+      }
+    }
+    transitions[key] = transition;
+  }
+  let stop;
+  const promise = new TickingPromise(
+    (resolve) => {
+      stop = resolve;
+    },
+    (elapsed, resolve) => {
+      for (const key in transitions) {
+        const transition = transitions[key];
+        transition.elapsed += elapsed;
+        if (transition.elapsed >= transition.duration) {
+          resolve();
+          return;
+        }
+        object[key] = transition.easing(
+          transition.elapsed,
+          transition.start,
+          transition.magnitude,
+          transition.duration,
+        );
+      }
+    },
+  );
+  return {stop, transition, promise};
+}