@blibliki/engine 0.5.2 → 0.9.0

package/src/modules/Envelope.ts

@@ -1,69 +1,104 @@
 import { ContextTime } from "@blibliki/transport";
-import { Context, cancelAndHoldAtTime } from "@blibliki/utils";
+import { Context } from "@blibliki/utils";
 import { GainNode } from "@blibliki/utils/web-audio-api";
 import { Module } from "@/core";
 import Note from "@/core/Note";
-import { IModuleConstructor } from "@/core/module/Module";
+import { IModuleConstructor, SetterHooks } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
 import { ModulePropSchema } from "@/core/schema";
+import { CustomWorklet, newAudioWorklet } from "@/processors";
 import { ICreateModule, ModuleType } from ".";
 
-export type IEnvelopeProps = {
+export type ICustomEnvelopeProps = {
   attack: number;
+  attackCurve: number;
   decay: number;
   sustain: number;
   release: number;
 };
 
-const DEFAULT_PROPS: IEnvelopeProps = {
-  attack: 0.01,
-  decay: 0,
+const DEFAULT_PROPS: ICustomEnvelopeProps = {
+  attack: 0.1,
+  attackCurve: 0.5,
+  decay: 0.1,
   sustain: 1,
-  release: 0,
+  release: 0.1,
 };
 
-export const envelopePropSchema: ModulePropSchema<IEnvelopeProps> = {
-  attack: {
-    kind: "number",
-    min: 0.0001,
-    max: 20,
-    step: 0.01,
-    exp: 3,
-    label: "Attack",
-  },
-  decay: {
-    kind: "number",
-    min: 0,
-    max: 20,
-    step: 0.01,
-    exp: 3,
-    label: "Decay",
-  },
-  sustain: {
-    kind: "number",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    label: "Sustain",
-  },
-  release: {
-    kind: "number",
-    min: 0,
-    max: 20,
-    step: 0.01,
-    exp: 3,
-    label: "Release",
-  },
-};
-
-class MonoEnvelope extends Module<ModuleType.Envelope> {
-  declare audioNode: GainNode;
+export const customEnvelopePropSchema: ModulePropSchema<ICustomEnvelopeProps> =
+  {
+    attack: {
+      kind: "number",
+      min: 0,
+      max: 10,
+      step: 0.01,
+      exp: 7,
+      label: "Attack",
+    },
+    attackCurve: {
+      kind: "number",
+      min: 0,
+      max: 1,
+      step: 0.01,
+      label: "Attack Curve",
+    },
+    decay: {
+      kind: "number",
+      min: 0,
+      max: 10,
+      step: 0.01,
+      exp: 6.6,
+      label: "Decay",
+    },
+    sustain: {
+      kind: "number",
+      min: 0,
+      max: 1,
+      step: 0.01,
+      label: "Sustain",
+    },
+    release: {
+      kind: "number",
+      min: 0,
+      max: 10,
+      step: 0.01,
+      exp: 5,
+      label: "Release",
+    },
+  };
+
+type CustomEnvelopeSetterHooks = SetterHooks<ICustomEnvelopeProps>;
+
+class MonoCustomEnvelope
+  extends Module<ModuleType.Envelope>
+  implements
+    Pick<
+      CustomEnvelopeSetterHooks,
+      | "onAfterSetAttack"
+      | "onAfterSetAttackCurve"
+      | "onAfterSetDecay"
+      | "onAfterSetSustain"
+      | "onAfterSetRelease"
+    >
+{
+  declare audioNode: ReturnType<typeof newAudioWorklet>;
+  private gainNode!: GainNode;
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Envelope>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
     const audioNodeConstructor = (context: Context) => {
-      const audioNode = new GainNode(context.audioContext);
-      audioNode.gain.value = 0;
+      const audioNode = newAudioWorklet(
+        context,
+        CustomWorklet.CustomEnvelopeProcessor,
+      );
+
+      // Set initial parameter values
+      audioNode.parameters.get("attack")!.value = props.attack;
+      audioNode.parameters.get("attackcurve")!.value = props.attackCurve;
+      audioNode.parameters.get("decay")!.value = props.decay;
+      audioNode.parameters.get("sustain")!.value = props.sustain;
+      audioNode.parameters.get("release")!.value = props.release;
+
       return audioNode;
     };
 
@@ -73,69 +108,100 @@ class MonoEnvelope extends Module<ModuleType.Envelope> {
       audioNodeConstructor,
     });
 
-    this.registerDefaultIOs();
+    this.gainNode = new GainNode(this.context.audioContext, {
+      gain: 0,
+    });
+    this.audioNode.connect(this.gainNode.gain);
+
+    this.registerIOs();
   }
 
-  triggerAttack(note: Note, triggeredAt: ContextTime) {
-    super.triggerAttack(note, triggeredAt);
+  // AudioParam getters
+  get attackParam() {
+    return this.audioNode.parameters.get("attack")!;
+  }
 
-    const attack = this.props.attack;
-    const decay = this.props.decay;
-    const sustain = this.props.sustain;
+  get attackCurveParam() {
+    return this.audioNode.parameters.get("attackcurve")!;
+  }
 
-    cancelAndHoldAtTime(this.audioNode.gain, triggeredAt);
+  get decayParam() {
+    return this.audioNode.parameters.get("decay")!;
+  }
 
-    // Always start from a tiny value, can't ramp from 0
-    if (this.audioNode.gain.value === 0) {
-      this.audioNode.gain.setValueAtTime(0.001, triggeredAt);
-    }
+  get sustainParam() {
+    return this.audioNode.parameters.get("sustain")!;
+  }
 
-    // Attack
-    this.audioNode.gain.exponentialRampToValueAtTime(1.0, triggeredAt + attack);
+  get releaseParam() {
+    return this.audioNode.parameters.get("release")!;
+  }
 
-    // Decay
-    if (sustain > 0) {
-      this.audioNode.gain.exponentialRampToValueAtTime(
-        sustain,
-        triggeredAt + attack + decay,
-      );
-      // Do not set to zero or anything else!
-    } else {
-      this.audioNode.gain.exponentialRampToValueAtTime(
-        0.001,
-        triggeredAt + attack + decay,
-      );
-    }
+  get triggerParam() {
+    return this.audioNode.parameters.get("trigger")!;
+  }
+
+  // Setter hooks that update AudioParams
+  onAfterSetAttack: CustomEnvelopeSetterHooks["onAfterSetAttack"] = (value) => {
+    this.attackParam.value = value;
+  };
+
+  onAfterSetAttackCurve: CustomEnvelopeSetterHooks["onAfterSetAttackCurve"] = (
+    value,
+  ) => {
+    this.attackCurveParam.value = value;
+  };
+
+  onAfterSetDecay: CustomEnvelopeSetterHooks["onAfterSetDecay"] = (value) => {
+    this.decayParam.value = value;
+  };
+
+  onAfterSetSustain: CustomEnvelopeSetterHooks["onAfterSetSustain"] = (
+    value,
+  ) => {
+    this.sustainParam.value = value;
+  };
+
+  onAfterSetRelease: CustomEnvelopeSetterHooks["onAfterSetRelease"] = (
+    value,
+  ) => {
+    this.releaseParam.value = value;
+  };
+
+  triggerAttack(note: Note, triggeredAt: ContextTime) {
+    super.triggerAttack(note, triggeredAt);
+
+    this.triggerParam.setValueAtTime(1, triggeredAt);
   }
 
   triggerRelease(note: Note, triggeredAt: ContextTime) {
     super.triggerRelease(note, triggeredAt);
+
+    // Only release if this is the last active note
     if (this.activeNotes.length > 0) return;
 
-    const release = this.props.release;
-
-    // Cancel scheduled automations and set gain to the ACTUAL value at this moment
-    const currentGainValue = cancelAndHoldAtTime(
-      this.audioNode.gain,
-      triggeredAt,
-    );
-
-    if (currentGainValue >= 0.0001) {
-      // Always set the value at the release time to ensure a smooth ramp from here
-      this.audioNode.gain.setValueAtTime(currentGainValue, triggeredAt);
-      // Exponential ramp to a tiny value
-      this.audioNode.gain.exponentialRampToValueAtTime(
-        0.0001,
-        triggeredAt + release - 0.0001,
-      );
-    }
+    this.triggerParam.setValueAtTime(0, triggeredAt);
+  }
+
+  dispose() {
+    this.gainNode.disconnect();
+    super.dispose();
+  }
 
-    // Set to zero at the very end
-    this.audioNode.gain.setValueAtTime(0, triggeredAt + release);
+  private registerIOs() {
+    this.registerAudioInput({
+      name: "in",
+      getAudioNode: () => this.gainNode,
+    });
+
+    this.registerAudioOutput({
+      name: "out",
+      getAudioNode: () => this.gainNode,
+    });
   }
 }
 
-export default class Envelope extends PolyModule<ModuleType.Envelope> {
+export default class CustomEnvelope extends PolyModule<ModuleType.Envelope> {
   constructor(
     engineId: string,
     params: IPolyModuleConstructor<ModuleType.Envelope>,
@@ -144,7 +210,7 @@ export default class Envelope extends PolyModule<ModuleType.Envelope> {
     const monoModuleConstructor = (
       engineId: string,
       params: IModuleConstructor<ModuleType.Envelope>,
-    ) => new MonoEnvelope(engineId, params);
+    ) => Module.create(MonoCustomEnvelope, engineId, params);
 
     super(engineId, {
       ...params,

package/src/modules/Filter.ts

@@ -3,9 +3,9 @@ import { BiquadFilterNode } from "@blibliki/utils/web-audio-api";
 import { EnumProp, ModulePropSchema } from "@/core";
 import { IModuleConstructor, Module, SetterHooks } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
-import { createModule, ICreateModule, ModuleType } from ".";
+import { ICreateModule, ModuleType } from ".";
 import { MonoGain } from "./Gain";
-import Scale from "./Scale";
+import { MonoScale } from "./Scale";
 
 export type IFilterProps = {
   cutoff: number;
@@ -72,7 +72,7 @@ class MonoFilter
     >
 {
   declare audioNode: BiquadFilterNode;
-  private scale: Scale;
+  private scale: MonoScale;
   private amount: MonoGain;
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Filter>) {
@@ -91,17 +91,17 @@ class MonoFilter
       audioNodeConstructor,
     });
 
-    this.amount = new MonoGain(engineId, {
+    this.amount = Module.create(MonoGain, engineId, {
       name: "amount",
       moduleType: ModuleType.Gain,
       props: { gain: props.envelopeAmount },
     });
 
-    this.scale = createModule(engineId, {
+    this.scale = Module.create(MonoScale, engineId, {
       name: "scale",
       moduleType: ModuleType.Scale,
       props: { min: MIN_FREQ, max: MAX_FREQ, current: this.props.cutoff },
-    }) as Scale;
+    });
 
     this.amount.plug({ audioModule: this.scale, from: "out", to: "in" });
     this.scale.audioNode.connect(this.audioNode.frequency);
@@ -154,7 +154,7 @@ export default class Filter extends PolyModule<ModuleType.Filter> {
     const monoModuleConstructor = (
       engineId: string,
       params: IModuleConstructor<ModuleType.Filter>,
-    ) => new MonoFilter(engineId, params);
+    ) => Module.create(MonoFilter, engineId, params);
 
     super(engineId, {
       ...params,

package/src/modules/Gain.ts

@@ -14,7 +14,7 @@ export const gainPropSchema: ModulePropSchema<IGainProps> = {
   gain: {
     kind: "number",
     min: 0,
-    max: Infinity,
+    max: 2,
     step: 0.01,
     label: "Gain",
   },
@@ -64,7 +64,7 @@ export default class Gain extends PolyModule<ModuleType.Gain> {
     const monoModuleConstructor = (
       engineId: string,
       params: IModuleConstructor<ModuleType.Gain>,
-    ) => new MonoGain(engineId, params);
+    ) => Module.create(MonoGain, engineId, params);
 
     super(engineId, {
       ...params,

package/src/modules/LFO.ts

@@ -0,0 +1,287 @@
+import { Division, divisionToFrequency } from "@blibliki/transport";
+import { Context } from "@blibliki/utils";
+import { ConstantSourceNode, GainNode } from "@blibliki/utils/web-audio-api";
+import { IModule, Module } from "@/core";
+import { IModuleConstructor, SetterHooks } from "@/core/module/Module";
+import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
+import { EnumProp, ModulePropSchema } from "@/core/schema";
+import { CustomWorklet, newAudioWorklet } from "@/processors";
+import { ICreateModule, ModuleType } from ".";
+
+export type ILFO = IModule<ModuleType.LFO>;
+
+export enum LFOWaveform {
+  sine = "sine",
+  triangle = "triangle",
+  square = "square",
+  sawtooth = "sawtooth",
+  rampDown = "rampDown",
+  random = "random",
+}
+
+const DIVISIONS: Division[] = [
+  "1/64",
+  "1/48",
+  "1/32",
+  "1/24",
+  "1/16",
+  "1/12",
+  "1/8",
+  "1/6",
+  "3/16",
+  "1/4",
+  "5/16",
+  "1/3",
+  "3/8",
+  "1/2",
+  "3/4",
+  "1",
+  "1.5",
+  "2",
+  "3",
+  "4",
+  "6",
+  "8",
+  "16",
+  "32",
+];
+
+export type ILFOProps = {
+  sync: boolean;
+  frequency: number;
+  division: Division;
+  waveform: LFOWaveform;
+  offset: number;
+  amount: number;
+};
+
+const DEFAULT_PROPS: ILFOProps = {
+  sync: false,
+  frequency: 1.0,
+  division: "1/4",
+  waveform: LFOWaveform.sine,
+  offset: 0,
+  amount: 1,
+};
+
+export const lfoPropSchema: ModulePropSchema<
+  ILFOProps,
+  {
+    division: EnumProp<Division>;
+    waveform: EnumProp<LFOWaveform>;
+  }
+> = {
+  sync: {
+    kind: "boolean",
+    label: "Sync",
+  },
+  frequency: {
+    kind: "number",
+    min: 0.01,
+    max: 40,
+    step: 0.01,
+    exp: 3,
+    label: "Frequency (Hz)",
+  },
+  division: {
+    kind: "enum",
+    options: DIVISIONS,
+    label: "Division",
+  },
+  waveform: {
+    kind: "enum",
+    options: Object.values(LFOWaveform),
+    label: "Waveform",
+  },
+  offset: {
+    kind: "number",
+    min: -1,
+    max: 1,
+    step: 0.01,
+    label: "Offset",
+  },
+  amount: {
+    kind: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    label: "Amount",
+  },
+};
+
+type LFOSetterHooks = SetterHooks<ILFOProps>;
+
+export class MonoLFO
+  extends Module<ModuleType.LFO>
+  implements
+    Pick<
+      LFOSetterHooks,
+      | "onAfterSetSync"
+      | "onAfterSetFrequency"
+      | "onAfterSetDivision"
+      | "onAfterSetWaveform"
+      | "onAfterSetOffset"
+      | "onAfterSetAmount"
+    >
+{
+  declare audioNode: AudioWorkletNode;
+  private offsetConstant!: ConstantSourceNode;
+  private offsetGain!: GainNode;
+  private amplitudeGain!: GainNode;
+  private mixerGain!: GainNode;
+  private amountGain!: GainNode;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.LFO>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: Context) =>
+      newAudioWorklet(context, CustomWorklet.LFOProcessor);
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
+
+    this.setupAudioGraph();
+    this.setupBPMListener();
+    this.registerOutputs();
+    this.updateFrequency();
+  }
+
+  private setupAudioGraph() {
+    const ctx = this.context.audioContext;
+
+    // Create nodes
+    this.offsetConstant = new ConstantSourceNode(ctx, { offset: 1 });
+    this.offsetGain = new GainNode(ctx, { gain: 0 });
+    this.amplitudeGain = new GainNode(ctx, { gain: 1 });
+    this.mixerGain = new GainNode(ctx, { gain: 1 });
+    this.amountGain = new GainNode(ctx, { gain: this.props.amount });
+
+    // Set initial waveform
+    const waveformIndex = Object.values(LFOWaveform).indexOf(
+      this.props.waveform,
+    );
+    this.waveformParam.value = waveformIndex;
+
+    // Apply offset calculation
+    this.updateOffsetGains();
+
+    // Connect audio graph:
+    // LFO → amplitudeGain → mixerGain
+    this.audioNode.connect(this.amplitudeGain);
+    this.amplitudeGain.connect(this.mixerGain);
+
+    // ConstantSource(1) → offsetGain → mixerGain
+    this.offsetConstant.connect(this.offsetGain);
+    this.offsetGain.connect(this.mixerGain);
+
+    // mixerGain → amountGain → (output registered separately)
+    this.mixerGain.connect(this.amountGain);
+
+    // Start constant source
+    this.offsetConstant.start();
+  }
+
+  private setupBPMListener() {
+    this.engine.transport.addPropertyChangeCallback("bpm", () => {
+      if (!this.props.sync) return;
+
+      this.updateFrequencyFromBPM();
+    });
+  }
+
+  private registerOutputs() {
+    this.registerAudioOutput({
+      name: "out",
+      getAudioNode: () => this.amountGain,
+    });
+  }
+
+  private updateFrequency() {
+    if (this.props.sync) {
+      this.updateFrequencyFromBPM();
+    } else {
+      this.frequencyParam.value = this.props.frequency;
+    }
+  }
+
+  private updateFrequencyFromBPM() {
+    const bpm = this.engine.transport.bpm;
+    const frequency = divisionToFrequency(this.props.division, bpm);
+    this.frequencyParam.value = frequency;
+  }
+
+  private updateOffsetGains() {
+    const offset = this.props.offset;
+    // Formula: output = lfo_signal * (1 - |offset|/2) + offset/2
+    const amplitude = 1 - Math.abs(offset) / 2;
+    const dcOffset = offset / 2;
+
+    this.amplitudeGain.gain.value = amplitude;
+    this.offsetGain.gain.value = dcOffset;
+  }
+
+  get frequencyParam() {
+    return this.audioNode.parameters.get("frequency")!;
+  }
+
+  get waveformParam() {
+    return this.audioNode.parameters.get("waveform")!;
+  }
+
+  get phaseParam() {
+    return this.audioNode.parameters.get("phase")!;
+  }
+
+  onAfterSetSync: LFOSetterHooks["onAfterSetSync"] = () => {
+    this.updateFrequency();
+  };
+
+  onAfterSetFrequency: LFOSetterHooks["onAfterSetFrequency"] = (value) => {
+    this.frequencyParam.value = value;
+  };
+
+  onAfterSetDivision: LFOSetterHooks["onAfterSetDivision"] = () => {
+    this.updateFrequencyFromBPM();
+  };
+
+  onAfterSetWaveform: LFOSetterHooks["onAfterSetWaveform"] = (value) => {
+    const waveformIndex = Object.values(LFOWaveform).indexOf(value);
+    this.waveformParam.value = waveformIndex;
+  };
+
+  onAfterSetOffset: LFOSetterHooks["onAfterSetOffset"] = () => {
+    this.updateOffsetGains();
+  };
+
+  onAfterSetAmount: LFOSetterHooks["onAfterSetAmount"] = (value) => {
+    this.amountGain.gain.value = value;
+  };
+
+  dispose() {
+    this.offsetConstant.stop();
+    super.dispose();
+  }
+}
+
+export default class LFO extends PolyModule<ModuleType.LFO> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.LFO>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.LFO>,
+    ) => Module.create(MonoLFO, engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
+    });
+
+    this.registerDefaultIOs("out");
+  }
+}