@blibliki/engine 0.1.26 → 0.3.1

package/src/modules/BiquadFilter.ts

@@ -0,0 +1,162 @@
+import { IAnyAudioContext, Module } from "@/core";
+import { IModuleConstructor } from "@/core/module/Module";
+import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
+import { PropSchema } from "@/core/schema";
+import { createModule, ICreateModule, ModuleType } from ".";
+import { MonoGain } from "./Gain";
+import Scale from "./Scale";
+
+export type IBiquadFilterProps = {
+  cutoff: number;
+  envelopeAmount: number;
+  type: BiquadFilterType;
+  Q: number;
+};
+
+const MIN_FREQ = 20;
+const MAX_FREQ = 20000;
+
+const DEFAULT_PROPS: IBiquadFilterProps = {
+  cutoff: MAX_FREQ,
+  envelopeAmount: 0,
+  type: "lowpass",
+  Q: 1,
+};
+
+export const biquadFilterPropSchema: PropSchema<IBiquadFilterProps> = {
+  cutoff: {
+    kind: "number",
+    min: MIN_FREQ,
+    max: MAX_FREQ,
+    step: 1,
+    label: "Cutoff",
+  },
+  envelopeAmount: {
+    kind: "number",
+    min: -1,
+    max: 1,
+    step: 0.01,
+    label: "Envelope Amount",
+  },
+  type: {
+    kind: "enum",
+    options: ["lowpass", "highpass", "bandpass"] satisfies BiquadFilterType[],
+    label: "Type",
+  },
+  Q: {
+    kind: "number",
+    min: -100,
+    max: 100,
+    step: 0.1,
+    label: "Q",
+  },
+};
+
+class MonoBiquadFilter extends Module<ModuleType.BiquadFilter> {
+  declare audioNode: BiquadFilterNode;
+  private scale: Scale;
+  private amount: MonoGain;
+
+  constructor(
+    engineId: string,
+    params: ICreateModule<ModuleType.BiquadFilter>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      new BiquadFilterNode(context, {
+        type: props.type,
+        frequency: props.cutoff,
+        Q: props.Q,
+      });
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
+
+    this.amount = new MonoGain(engineId, {
+      name: "amount",
+      moduleType: ModuleType.Gain,
+      props: { gain: props.envelopeAmount },
+    });
+
+    this.scale = createModule(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);
+
+    this.registerDefaultIOs();
+    this.registerInputs();
+  }
+
+  protected onSetType(value: IBiquadFilterProps["type"]) {
+    this.audioNode.type = value;
+  }
+
+  protected onSetCutoff(value: IBiquadFilterProps["cutoff"]) {
+    if (!this.superInitialized) return;
+
+    this.scale.props = { current: value };
+  }
+
+  protected onSetQ(value: IBiquadFilterProps["Q"]) {
+    this.audioNode.Q.value = value;
+  }
+
+  protected onSetEnvelopeAmount(value: IBiquadFilterProps["envelopeAmount"]) {
+    if (!this.superInitialized) return;
+
+    this.amount.props = { gain: value };
+  }
+
+  private registerInputs() {
+    this.registerAudioInput({
+      name: "cutoff",
+      getAudioNode: () => this.audioNode.frequency,
+    });
+
+    this.registerAudioInput({
+      name: "cutoffMod",
+      getAudioNode: () => this.amount.audioNode,
+    });
+
+    this.registerAudioInput({
+      name: "Q",
+      getAudioNode: () => this.audioNode.Q,
+    });
+  }
+}
+
+export default class BiquadFilter extends PolyModule<ModuleType.BiquadFilter> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.BiquadFilter>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.BiquadFilter>,
+    ) => new MonoBiquadFilter(engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
+    });
+
+    this.registerInputs();
+    this.registerDefaultIOs();
+  }
+
+  private registerInputs() {
+    this.registerAudioInput({ name: "cutoff" });
+    this.registerAudioInput({ name: "cutoffMod" });
+    this.registerAudioInput({ name: "Q" });
+  }
+}

package/src/modules/Constant.ts

@@ -0,0 +1,72 @@
+import { IAnyAudioContext, IModule, Module } from "@/core";
+import Note from "@/core/Note";
+import { nt, TTime } from "@/core/Timing/Time";
+import { PropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
+
+export type IConstant = IModule<ModuleType.Constant>;
+export type IConstantProps = {
+  value: number;
+};
+
+export const constantPropSchema: PropSchema<IConstantProps> = {
+  value: {
+    kind: "number",
+    min: -Infinity,
+    max: Infinity,
+    step: 0.01,
+    label: "Value",
+  },
+};
+
+const DEFAULT_PROPS: IConstantProps = { value: 1 };
+
+export default class Constant extends Module<ModuleType.Constant> {
+  declare audioNode: ConstantSourceNode;
+  isStated = false;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.Constant>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      new ConstantSourceNode(context);
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
+
+    this.registerDefaultIOs("out");
+  }
+
+  protected onSetValue(value: IConstantProps["value"]) {
+    this.audioNode.offset.value = value;
+  }
+
+  start(time: TTime) {
+    if (this.isStated) return;
+
+    this.isStated = true;
+    this.audioNode.start(nt(time));
+  }
+
+  stop(time: TTime) {
+    this.audioNode.stop(nt(time));
+    this.rePlugAll(() => {
+      this.audioNode = new ConstantSourceNode(this.context, {
+        offset: this.props.value,
+      });
+    });
+
+    this.isStated = false;
+  }
+
+  triggerAttack = (note: Note, triggeredAt: TTime) => {
+    this.audioNode.offset.setValueAtTime(note.frequency, nt(triggeredAt));
+    this.start(triggeredAt);
+  };
+
+  triggerRelease = () => {
+    // Do nothing
+  };
+}

package/src/modules/Envelope.ts

@@ -0,0 +1,178 @@
+import { createScaleNormalized } from "@blibliki/utils";
+import { IAnyAudioContext, Module } from "@/core";
+import Note from "@/core/Note";
+import { nt, TTime } from "@/core/Timing/Time";
+import { IModuleConstructor } from "@/core/module/Module";
+import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
+import { PropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
+
+export type IEnvelopeProps = {
+  attack: number;
+  decay: number;
+  sustain: number;
+  release: number;
+};
+
+const DEFAULT_PROPS: IEnvelopeProps = {
+  attack: 0.1,
+  decay: 0.2,
+  sustain: 0,
+  release: 0.3,
+};
+
+export const envelopePropSchema: PropSchema<IEnvelopeProps> = {
+  attack: {
+    kind: "number",
+    min: 0.0001,
+    max: 1,
+    step: 0.01,
+    label: "Attack",
+  },
+  decay: {
+    kind: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    label: "Decay",
+  },
+  sustain: {
+    kind: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    label: "Sustain",
+  },
+  release: {
+    kind: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    label: "Release",
+  },
+};
+
+const scaleToTen = createScaleNormalized({
+  min: 0.001,
+  max: 10,
+});
+
+const scaleToFive = createScaleNormalized({
+  min: 0.001,
+  max: 5,
+});
+
+class MonoEnvelope extends Module<ModuleType.Envelope> {
+  declare audioNode: GainNode;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.Envelope>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: IAnyAudioContext) => {
+      const audioNode = new GainNode(context);
+      audioNode.gain.value = 0;
+      return audioNode;
+    };
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
+
+    this.registerDefaultIOs();
+  }
+
+  triggerAttack(note: Note, triggeredAt: TTime) {
+    super.triggerAttack(note, triggeredAt);
+
+    const attack = this.scaledAttack();
+    const decay = this.scaledDecay();
+    const sustain = this.props.sustain;
+    const triggeredAtNum = nt(triggeredAt);
+
+    this.audioNode.gain.cancelAndHoldAtTime(triggeredAtNum);
+
+    // Always start from a tiny value, can't ramp from 0
+    if (this.audioNode.gain.value === 0) {
+      this.audioNode.gain.setValueAtTime(0.001, triggeredAtNum);
+    }
+
+    // Attack
+    this.audioNode.gain.exponentialRampToValueAtTime(
+      1.0,
+      triggeredAtNum + attack,
+    );
+
+    // Decay
+    if (sustain > 0) {
+      this.audioNode.gain.exponentialRampToValueAtTime(
+        sustain,
+        triggeredAtNum + attack + decay,
+      );
+      // Do not set to zero or anything else!
+    } else {
+      this.audioNode.gain.exponentialRampToValueAtTime(
+        0.001,
+        triggeredAtNum + attack + decay,
+      );
+    }
+  }
+
+  triggerRelease(note: Note, triggeredAt: TTime) {
+    super.triggerRelease(note, triggeredAt);
+    if (this.activeNotes.length > 0) return;
+
+    const release = this.scaledRelease();
+    const triggeredAtNum = nt(triggeredAt);
+
+    // Cancel scheduled automations and set gain to the ACTUAL value at this moment
+    this.audioNode.gain.cancelAndHoldAtTime(triggeredAtNum);
+    const currentGainValue = this.audioNode.gain.value;
+
+    if (currentGainValue >= 0.0001) {
+      // Always set the value at the release time to ensure a smooth ramp from here
+      this.audioNode.gain.setValueAtTime(currentGainValue, triggeredAtNum);
+      // Exponential ramp to a tiny value
+      this.audioNode.gain.exponentialRampToValueAtTime(
+        0.0001,
+        triggeredAtNum + release - 0.0001,
+      );
+    }
+
+    // Set to zero at the very end
+    this.audioNode.gain.setValueAtTime(0, triggeredAtNum + release);
+  }
+
+  private scaledAttack() {
+    return scaleToTen(this.props.attack);
+  }
+
+  private scaledDecay() {
+    return scaleToFive(this.props.decay);
+  }
+
+  private scaledRelease() {
+    return scaleToTen(this.props.release);
+  }
+}
+
+export default class Envelope extends PolyModule<ModuleType.Envelope> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.Envelope>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.Envelope>,
+    ) => new MonoEnvelope(engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
+    });
+
+    this.registerDefaultIOs();
+  }
+}

package/src/modules/Filter.ts

@@ -1,148 +1,153 @@
-import { Filter as InternalFilter, FilterRollOff, Add, Multiply } from "tone";
-import Module, { PolyModule } from "../core/Module";
-
-interface FilterInterface {
+import { IAnyAudioContext, Module } from "@/core";
+import { IModuleConstructor } from "@/core/module/Module";
+import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
+import { PropSchema } from "@/core/schema";
+import { CustomWorklet, newAudioWorklet } from "@/processors";
+import { createModule, ICreateModule, ModuleType } from ".";
+import { MonoGain } from "./Gain";
+import Scale from "./Scale";
+
+export type IFilterProps = {
   cutoff: number;
-  filterType: BiquadFilterType;
-  resonance: number;
-  slope: FilterRollOff;
   envelopeAmount: number;
-}
-
-type FilterProps = Partial<FilterInterface>;
+  resonance: number;
+};
 
-const MAX_FREQ = 20000;
+const MIN_FREQ = 20;
+const MAX_FREQ = 22050;
 
-const InitialProps: FilterInterface = {
+const DEFAULT_PROPS: IFilterProps = {
   cutoff: MAX_FREQ,
-  resonance: 0,
   envelopeAmount: 0,
-  slope: -24,
-  filterType: "lowpass",
+  resonance: 0,
 };
 
-class MonoFilter extends Module<InternalFilter, FilterInterface> {
-  private _cutoff: Add;
-  private _amount: Multiply;
-
-  constructor(params: { id?: string; name: string; props: FilterProps }) {
-    const { id, name, props } = params;
-
-    super(new InternalFilter({ type: "lowpass" }), {
-      id,
-      name,
-      props: { ...InitialProps, ...props },
-    });
-
-    this._cutoff = new Add();
-    this._cutoff.connect(this.internalModule.frequency);
-
-    this._amount = new Multiply();
-    this._amount.connect(this._cutoff);
-    this.updateAmountFactor();
+export const filterPropSchema: PropSchema<IFilterProps> = {
+  cutoff: {
+    kind: "number",
+    min: MIN_FREQ,
+    max: MAX_FREQ,
+    step: 0.0001,
+    label: "Cutoff",
+  },
+  envelopeAmount: {
+    kind: "number",
+    min: -1,
+    max: 1,
+    step: 0.01,
+    label: "Envelope Amount",
+  },
+  resonance: {
+    kind: "number",
+    min: 0,
+    max: 4,
+    step: 0.01,
+    label: "resonance",
+  },
+};
 
-    this.registerBasicInputs();
-    this.registerOutputs();
-  }
+class MonoFilter extends Module<ModuleType.Filter> {
+  declare audioNode: AudioWorkletNode;
+  private scale: Scale;
+  private amount: MonoGain;
 
-  get cutoff() {
-    return this._props["cutoff"];
-  }
+  constructor(engineId: string, params: ICreateModule<ModuleType.Filter>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
 
-  set cutoff(value: number) {
-    if (this._cutoff) {
-      this._cutoff.addend.value = value;
-    }
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      newAudioWorklet(context, CustomWorklet.FilterProcessor);
 
-    this._props = { ...this.props, cutoff: value };
-    this.updateAmountFactor();
-  }
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
 
-  get filterType() {
-    return this._props["filterType"];
-  }
+    this.amount = new MonoGain(engineId, {
+      name: "amount",
+      moduleType: ModuleType.Gain,
+      props: { gain: props.envelopeAmount },
+    });
 
-  set filterType(value: BiquadFilterType) {
-    this._props = { ...this.props, filterType: value };
-    this.internalModule.type = value;
-  }
+    this.scale = createModule(engineId, {
+      name: "scale",
+      moduleType: ModuleType.Scale,
+      props: { min: MIN_FREQ, max: MAX_FREQ, current: this.props.cutoff },
+    }) as Scale;
 
-  get slope() {
-    return this._props["slope"];
-  }
+    this.amount.plug({ audioModule: this.scale, from: "out", to: "in" });
+    this.scale.audioNode.connect(this.cutoff);
 
-  set slope(value: FilterRollOff) {
-    this._props = { ...this.props, slope: value };
-    this.internalModule.rolloff = value;
+    this.registerDefaultIOs();
+    this.registerInputs();
   }
 
-  get frequency() {
-    return this.internalModule.frequency;
+  get cutoff() {
+    return this.audioNode.parameters.get("cutoff")!;
   }
 
   get resonance() {
-    return this._props["resonance"];
+    return this.audioNode.parameters.get("resonance")!;
   }
 
-  set resonance(value: number) {
-    this._props = { ...this.props, resonance: value };
+  protected onSetCutoff(value: IFilterProps["cutoff"]) {
+    if (!this.superInitialized) return;
 
-    this.internalModule.Q.value = value;
+    this.scale.props = { current: value };
   }
 
-  get envelopeAmount() {
-    return this._props["envelopeAmount"];
+  protected onSetResonance(value: IFilterProps["resonance"]) {
+    this.resonance.value = value;
   }
 
-  set envelopeAmount(value: number) {
-    this._props = { ...this.props, envelopeAmount: value };
-    this.updateAmountFactor();
-  }
+  protected onSetEnvelopeAmount(value: IFilterProps["envelopeAmount"]) {
+    if (!this.superInitialized) return;
 
-  private registerOutputs() {
-    this.registerBasicOutputs();
+    this.amount.props = { gain: value };
+  }
 
+  private registerInputs() {
     this.registerAudioInput({
       name: "cutoff",
-      internalModule: this._amount,
+      getAudioNode: () => this.scale.audioNode,
     });
-  }
-
-  private updateAmountFactor() {
-    if (!this._amount) return;
 
-    const value =
-      this.envelopeAmount > 0
-        ? this.envelopeAmount * Math.abs(MAX_FREQ - this.cutoff)
-        : this.envelopeAmount * Math.abs(1 - this.cutoff);
+    this.registerAudioInput({
+      name: "cutoffMod",
+      getAudioNode: () => this.amount.audioNode,
+    });
 
-    this._amount.factor.value = value;
+    this.registerAudioInput({
+      name: "Q",
+      getAudioNode: () => this.resonance,
+    });
   }
 }
 
-export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
-  static moduleName = "Filter";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<FilterInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      child: MonoFilter,
-      props: { ...InitialProps, ...props },
+export default class Filter extends PolyModule<ModuleType.Filter> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.Filter>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.Filter>,
+    ) => new MonoFilter(engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
     });
 
-    this.registerBasicInputs();
-    this.registerOutputs();
+    this.registerInputs();
+    this.registerDefaultIOs();
   }
 
-  private registerOutputs() {
-    this.registerBasicOutputs();
-    this.registerForwardAudioInput({ name: "cutoff" });
+  private registerInputs() {
+    this.registerAudioInput({ name: "cutoff" });
+    this.registerAudioInput({ name: "cutoffMod" });
+    this.registerAudioInput({ name: "Q" });
   }
 }