@blibliki/engine 0.1.27 → 0.3.1

package/src/modules/Oscillator.ts

@@ -1,222 +1,267 @@
-import {
-  Multiply,
-  now,
-  Oscillator as Osc,
-  Signal,
-  ToneOscillatorType,
-} from "tone";
-import Engine from "../Engine";
-
-import Note from "../core/Note";
-import Module, { PolyModule, Startable } from "../core/Module";
-
-export type TWave = "sine" | "triangle" | "square" | "sawtooth";
-
-export interface OscillatorInterface {
-  noteName: string;
+import { dbToGain } from "@blibliki/utils";
+import { IAnyAudioContext, IModule, 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 ".";
+
+const LOW_GAIN = -18;
+
+export type IOscillator = IModule<ModuleType.Oscillator>;
+
+export enum OscillatorWave {
+  sine = "sine",
+  triangle = "triangle",
+  square = "square",
+  sawtooth = "sawtooth",
+}
+
+/**
+ * Props for the Oscillator module.
+ *
+ * @property wave - Waveform shape of the oscillator.
+ *                  One of: "sine", "square", "sawtooth", "triangle", or "custom".
+ * @property frequency - Base frequency in Hz (e.g. 440 for A4).
+ * @property fine - Fine tuning factor in the range [-1, 1], where ±1 represents ±1 semitone.
+ * @property coarse - Coarse tuning factor in the range [-1, 1], scaled to ±12 semitones.
+ * @property octave - Octave transposition value (e.g. +1 for one octave up, -2 for two octaves down).
+ * @property lowGain - Whether to gain reduction (-18dB). When false, oscillator runs at full gain.
+ */
+export type IOscillatorProps = {
+  wave: OscillatorWave;
+  frequency: number;
   fine: number;
   coarse: number;
-  wave: TWave;
-  volume: number;
-  range: number;
-}
+  octave: number;
+  lowGain: boolean;
+};
+
+export const oscillatorPropSchema: PropSchema<IOscillatorProps> = {
+  wave: {
+    kind: "enum",
+    options: Object.values(OscillatorWave),
+    label: "Waveform",
+  },
+  frequency: {
+    kind: "number",
+    min: 0,
+    max: 25000,
+    step: 1,
+    label: "Frequency",
+  },
+  fine: {
+    kind: "number",
+    min: -1,
+    max: 1,
+    step: 0.01,
+    label: "Fine",
+  },
+  coarse: {
+    kind: "number",
+    min: -12,
+    max: 12,
+    step: 1,
+    label: "Coarse",
+  },
+  octave: {
+    kind: "number",
+    min: -4,
+    max: 4,
+    step: 1,
+    label: "Octave",
+  },
+  lowGain: {
+    kind: "boolean",
+    label: `Use ${LOW_GAIN}db Gain`,
+  },
+};
 
-const InitialProps: OscillatorInterface = {
-  noteName: "C3",
+const DEFAULT_PROPS: IOscillatorProps = {
+  wave: OscillatorWave.sine,
+  frequency: 440,
   fine: 0,
   coarse: 0,
-  wave: "sine",
-  range: 0,
-  volume: 0,
+  octave: 0,
+  lowGain: false,
 };
 
-export class MonoOscillator
-  extends Module<Osc, OscillatorInterface>
-  implements Startable
-{
-  private _note: Note;
-  private _fineMulti: Multiply;
-  private _fineSignal: Signal;
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<OscillatorInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super(new Osc(), {
-      id,
-      name,
-      props: { ...InitialProps, ...props },
+export class MonoOscillator extends Module<ModuleType.Oscillator> {
+  declare audioNode: OscillatorNode;
+  isStated = false;
+  lowOutputGain: GainNode;
+  detuneGain!: GainNode;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.Oscillator>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      new OscillatorNode(context);
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
     });
 
+    this.lowOutputGain = new GainNode(this.context, {
+      gain: dbToGain(LOW_GAIN),
+    });
+
+    this.applyOutputGain();
+    this.initializeGainDetune();
     this.registerInputs();
-    this.registerBasicOutputs();
-    this.start(now());
+    this.registerOutputs();
   }
 
-  get note(): Note {
-    return this._note;
+  protected onAfterSetWave(value: OscillatorWave) {
+    this.audioNode.type = value;
   }
 
-  setNoteAt(value: Note | string, time: number) {
-    this._note = this.getNote(value);
-    this.updateFrequency(time);
+  protected onAfterSetFrequency() {
+    this.updateFrequency();
   }
 
-  set note(value: Note | string) {
-    this._note = this.getNote(value);
+  protected onAfterSetFine() {
     this.updateFrequency();
   }
 
-  get noteName() {
-    return this._props["noteName"];
+  protected onAfterSetCoarse() {
+    this.updateFrequency();
   }
 
-  set noteName(value: string) {
-    this._props = { ...this.props, noteName: value };
-    this.note = new Note(this.noteName);
+  protected onAfterSetOctave() {
+    this.updateFrequency();
   }
 
-  get fineSingal() {
-    if (this._fineSignal) return this._fineSignal;
-
-    this._fineSignal = new Signal();
-    this._fineMulti = new Multiply(100);
-    this._fineSignal.connect(this._fineMulti);
-    this._fineMulti.connect(this.internalModule.detune);
+  protected onAfterSetLowGain() {
+    if (!this.superInitialized) return;
 
-    return this._fineSignal;
+    this.rePlugAll();
   }
 
-  get fine() {
-    return this._props["fine"];
-  }
-
-  set fine(value: number) {
-    this._props = { ...this.props, fine: value };
-
-    this.fineSingal.value = this.fine;
-  }
+  start(time: TTime) {
+    if (this.isStated) return;
 
-  get coarse() {
-    return this._props["coarse"];
+    this.isStated = true;
+    this.audioNode.start(nt(time));
   }
 
-  set coarse(value: number) {
-    this._props = { ...this.props, coarse: Math.floor(value) };
+  stop(time: TTime) {
+    this.audioNode.stop(nt(time));
+    this.rePlugAll(() => {
+      this.audioNode = new OscillatorNode(this.context, {
+        type: this.props.wave,
+        frequency: this.finalFrequency,
+      });
+      this.applyOutputGain();
+      this.detuneGain.connect(this.audioNode.detune);
+    });
 
-    this.updateFrequency();
+    this.isStated = false;
   }
 
-  get wave() {
-    return this._props["wave"];
-  }
+  triggerAttack = (note: Note, triggeredAt: TTime) => {
+    super.triggerAttack(note, triggeredAt);
 
-  set wave(value: TWave) {
-    this._props = { ...this.props, wave: value };
-    this.internalModule.type = this.wave as ToneOscillatorType;
-  }
+    this.props = { frequency: note.frequency };
+    this.updateFrequency(triggeredAt);
+    this.start(triggeredAt);
+  };
 
-  get volume() {
-    return this._props["volume"];
-  }
+  triggerRelease(note: Note, triggeredAt: TTime) {
+    super.triggerRelease(note, triggeredAt);
 
-  set volume(value: number) {
-    this._props = { ...this.props, volume: value };
+    const lastNote = this.activeNotes.length
+      ? this.activeNotes[this.activeNotes.length - 1]
+      : null;
+    if (!lastNote) return;
 
-    this.internalModule.volume.value = this.volume;
+    this.props = { frequency: lastNote.frequency };
+    this.updateFrequency(triggeredAt);
   }
 
-  get range() {
-    return this._props["range"];
-  }
+  private get finalFrequency(): number | undefined {
+    const { frequency, coarse, octave, fine } = this.props;
+    if (!this.superInitialized) return;
 
-  set range(value: number) {
-    this._props = { ...this.props, range: value };
-    this.updateFrequency();
+    const transposed =
+      frequency * Math.pow(2, coarse / 12 + octave + fine / 12);
+    return transposed;
   }
 
-  start(time: number) {
-    if (!Engine.isStarted) return;
-
-    const oscState = this.internalModule.state;
+  private updateFrequency(actionAt?: TTime) {
+    if (this.finalFrequency === undefined) return;
 
-    if (oscState === "started") {
-      this.internalModule.restart(time);
+    if (actionAt) {
+      this.audioNode.frequency.setValueAtTime(
+        this.finalFrequency,
+        nt(actionAt),
+      );
     } else {
-      this.internalModule.start(time);
+      this.audioNode.frequency.value = this.finalFrequency;
     }
   }
 
-  stop(time?: number) {
-    this.internalModule.stop(time);
+  private applyOutputGain() {
+    this.audioNode.connect(this.lowOutputGain);
   }
 
-  triggerAttack = (note: Note, triggeredAt: number) => {
-    this.setNoteAt(note, triggeredAt);
-    this.start(triggeredAt);
-  };
-
-  triggerRelease = () => {
-    // Do nothing
-  };
-
-  private updateFrequency(time?: number) {
-    if (!this.note) return;
-
-    const freq = this.note.adjustFrequency(this.range, this.coarse);
-
-    if (time) {
-      this.internalModule.frequency.linearRampToValueAtTime(freq, time);
-    } else {
-      this.internalModule.frequency.value = freq;
-    }
-  }
-
-  private getNote(note: Note | string): Note {
-    return note instanceof Note ? note : new Note(note);
+  private initializeGainDetune() {
+    this.detuneGain = new GainNode(this.context, { gain: 100 });
+    this.detuneGain.connect(this.audioNode.detune);
   }
 
   private registerInputs() {
     this.registerAudioInput({
-      name: "fine",
-      internalModule: this.fineSingal,
+      name: "detune",
+      getAudioNode: () => this.detuneGain,
+    });
+  }
+
+  private registerOutputs() {
+    this.registerAudioOutput({
+      name: "out",
+      getAudioNode: () =>
+        this.props.lowGain ? this.lowOutputGain : this.audioNode,
     });
   }
 }
 
-export default class Oscillator extends PolyModule<
-  MonoOscillator,
-  OscillatorInterface
-> {
-  static moduleName = "Oscillator";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<OscillatorInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      child: MonoOscillator,
-      props: { ...InitialProps, ...props },
+export default class Oscillator extends PolyModule<ModuleType.Oscillator> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.Oscillator>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.Oscillator>,
+    ) => new MonoOscillator(engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
     });
 
-    this.registerBasicOutputs();
-    this.registerMidiIn();
-    this.registerForwardAudioInput({ name: "fine" });
+    this.registerInputs();
+    this.registerDefaultIOs("out");
   }
 
-  start(time: number) {
-    this.audioModules.forEach((audioModule) => audioModule.start(time));
+  start(time: TTime) {
+    this.audioModules.forEach((audioModule) => {
+      audioModule.start(time);
+    });
   }
 
-  stop(time?: number) {
-    this.audioModules.forEach((audioModule) => audioModule.stop(time));
+  stop(time: TTime) {
+    this.audioModules.forEach((audioModule) => {
+      audioModule.stop(time);
+    });
+  }
+
+  private registerInputs() {
+    this.registerAudioInput({ name: "detune" });
   }
 }

package/src/modules/Scale.ts

@@ -0,0 +1,79 @@
+import { IAnyAudioContext, IModule, Module } from "@/core";
+import { PropSchema } from "@/core/schema";
+import { CustomWorklet, newAudioWorklet } from "@/processors";
+import { ICreateModule, ModuleType } from ".";
+
+export type IScale = IModule<ModuleType.Scale>;
+export type IScaleProps = {
+  min: number;
+  max: number;
+  current: number;
+};
+
+export const scalePropSchema: PropSchema<IScaleProps> = {
+  min: {
+    kind: "number",
+    min: -Infinity,
+    max: Infinity,
+    step: 0.01,
+    label: "Min",
+  },
+  max: {
+    kind: "number",
+    min: -Infinity,
+    max: Infinity,
+    step: 0.01,
+    label: "Max",
+  },
+  current: {
+    kind: "number",
+    min: -Infinity,
+    max: Infinity,
+    step: 0.01,
+    label: "Current",
+  },
+};
+
+const DEFAULT_PROPS: IScaleProps = { min: 0, max: 1, current: 0.5 };
+
+export default class Scale extends Module<ModuleType.Scale> {
+  declare audioNode: AudioWorkletNode;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.Scale>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      newAudioWorklet(context, CustomWorklet.ScaleProcessor);
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
+
+    this.registerDefaultIOs();
+  }
+
+  get current() {
+    return this.audioNode.parameters.get("current")!;
+  }
+
+  get min() {
+    return this.audioNode.parameters.get("min")!;
+  }
+
+  get max() {
+    return this.audioNode.parameters.get("max")!;
+  }
+
+  protected onSetMin(value: number) {
+    this.min.value = value;
+  }
+
+  protected onSetMax(value: number) {
+    this.max.value = value;
+  }
+
+  protected onSetCurrent(value: number) {
+    this.current.value = value;
+  }
+}

package/src/modules/StepSequencer.ts

@@ -0,0 +1,61 @@
+import { INote, PropSchema, Module, IModule, MidiOutput } from "@/core";
+import { BarsBeatsSixteenths } from "@/core/Timing/Time";
+import { ICreateModule, ModuleType } from ".";
+
+export type IStepSequencer = IModule<ModuleType.StepSequencer>;
+
+export type ISequence = {
+  active: boolean;
+  time: BarsBeatsSixteenths;
+  duration: string;
+  notes: INote[];
+};
+
+export type IStepSequencerProps = {
+  bars: number;
+  steps: number;
+  sequences: ISequence[][];
+};
+
+export const stepSequencerPropSchema: PropSchema<
+  Omit<IStepSequencerProps, "sequences">
+> = {
+  steps: {
+    kind: "number",
+    min: 1,
+    max: 16,
+    step: 1,
+    label: "Steps",
+  },
+  bars: {
+    kind: "number",
+    min: 1,
+    max: 16,
+    step: 1,
+    label: "Steps",
+  },
+};
+
+const DEFAULT_PROPS: IStepSequencerProps = {
+  sequences: [],
+  steps: 16,
+  bars: 1,
+};
+
+// Not implemented yet, just the data modeling
+export default class StepSequencer extends Module<ModuleType.StepSequencer> {
+  declare audioNode: undefined;
+  midiOutput!: MidiOutput;
+
+  constructor(
+    engineId: string,
+    params: ICreateModule<ModuleType.StepSequencer>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+
+    super(engineId, {
+      ...params,
+      props,
+    });
+  }
+}

package/src/modules/VirtualMidi.ts

@@ -1,74 +1,58 @@
-import Engine from "../Engine";
-import { MidiEvent } from "../core/midi";
-import Note from "../core/Note";
-import Module, { DummnyInternalModule } from "../core/Module";
-import { MidiOutput } from "../core/IO";
+import { PropSchema, Module, IModule, MidiOutput, Note } from "@/core";
+import { TTime } from "@/core/Timing/Time";
+import MidiEvent from "@/core/midi/MidiEvent";
+import { ICreateModule, ModuleType } from ".";
 
-export interface VirtualMidiInterface {
+export type IVirtualMidi = IModule<ModuleType.VirtualMidi>;
+export type IVirtualMidiProps = {
   activeNotes: string[];
-}
+};
 
-const InitialProps: VirtualMidiInterface = {
-  activeNotes: [],
+export const virtualMidiPropSchema: PropSchema<IVirtualMidiProps> = {
+  activeNotes: {
+    kind: "array",
+    label: "Active notes",
+  },
 };
 
-export default class VirtualMidi extends Module<
-  DummnyInternalModule,
-  VirtualMidiInterface
-> {
-  static moduleName = "VirtualMidi";
-  midiOutput: MidiOutput;
+const DEFAULT_PROPS: IVirtualMidiProps = { activeNotes: [] };
+
+export default class VirtualMidi extends Module<ModuleType.VirtualMidi> {
+  declare audioNode: undefined;
+  midiOutput!: MidiOutput;
 
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: VirtualMidiInterface;
-  }) {
-    const { id, name, props } = params;
-    super(new DummnyInternalModule(), {
-      id,
-      name,
-      props: { ...InitialProps, ...props },
+  constructor(engineId: string, params: ICreateModule<ModuleType.VirtualMidi>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+
+    super(engineId, {
+      ...params,
+      props,
     });
 
     this.registerInputs();
     this.registerOutputs();
   }
 
-  get activeNotes() {
-    return this._props["activeNotes"];
-  }
-
-  // can't set externaly
-  set activeNotes(value: string[]) {
-    this._props = { ...this.props, activeNotes: value };
-  }
-
   sendMidi(midiEvent: MidiEvent) {
     this.midiOutput.onMidiEvent(midiEvent);
   }
 
-  triggerAttack = (note: Note, triggerAttack: number) => {
-    this.activeNotes = [...this.activeNotes, note.fullName];
-    Engine._triggerPropsUpdate(this.id, this.props);
+  triggerAttack = (note: Note, triggerAttack: TTime) => {
+    this.props = { activeNotes: [...this.props.activeNotes, note.fullName] };
+    this.triggerPropsUpdate();
     this.sendMidi(MidiEvent.fromNote(note, true, triggerAttack));
   };
 
-  triggerRelease = (note: Note, triggerAttack: number) => {
-    this.activeNotes = this.activeNotes.filter(
-      (name) => name !== note.fullName
-    );
-    Engine._triggerPropsUpdate(this.id, this.props);
+  triggerRelease = (note: Note, triggerAttack: TTime) => {
+    this.props = {
+      activeNotes: this.props.activeNotes.filter(
+        (name) => name !== note.fullName,
+      ),
+    };
+    this.triggerPropsUpdate();
     this.sendMidi(MidiEvent.fromNote(note, false, triggerAttack));
   };
 
-  serialize() {
-    return {
-      ...super.serialize(),
-      activeNotes: this.activeNotes,
-    };
-  }
-
   private registerInputs() {
     this.registerMidiInput({
       name: "midi in",