@blibliki/engine 0.1.0

package/src/Module/MidiSelector.ts

@@ -0,0 +1,64 @@
+import MidiDevice from "../MidiDevice";
+import MidiDeviceManager from "../MidiDeviceManager";
+import MidiEvent from "../MidiEvent";
+import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import { Output } from "./IO";
+
+export interface MidiSelectorInterface {
+  selectedId: string | null;
+}
+
+const InitialProps: MidiSelectorInterface = {
+  selectedId: null,
+};
+
+export default class MidiSelector extends Module<
+  DummnyInternalModule,
+  MidiSelectorInterface
+> {
+  midiOutput: Output;
+
+  constructor(name: string, props: Partial<MidiSelectorInterface>) {
+    super(new DummnyInternalModule(), {
+      name,
+      props: { ...InitialProps, ...props },
+      type: ModuleType.MidiSelector,
+    });
+
+    this.registerOutputs();
+  }
+
+  get selectedId() {
+    return this._props["selectedId"];
+  }
+
+  set selectedId(value: string | null) {
+    if (this.selectedId) {
+      MidiDeviceManager.find(this.selectedId).then((midiDevice: MidiDevice) => {
+        midiDevice.removeEventListener(this.onMidiEvent);
+      });
+    }
+
+    this._props = { ...this.props, selectedId: value };
+
+    if (!value) return;
+
+    MidiDeviceManager.find(value).then((midiDevice: MidiDevice) => {
+      midiDevice.addEventListener(this.onMidiEvent);
+    });
+  }
+
+  onMidiEvent = (midiEvent: MidiEvent) => {
+    this.midiOutput.connections.forEach((input) => {
+      input.pluggable(midiEvent);
+    });
+  };
+
+  async availableDevices(): Promise<MidiDevice[]> {
+    return MidiDeviceManager.fetchDevices();
+  }
+
+  private registerOutputs() {
+    this.midiOutput = this.registerOutput({ name: "midi out" });
+  }
+}

package/src/Module/Oscillator.ts

@@ -0,0 +1,166 @@
+import MidiEvent from "../MidiEvent";
+import { Oscillator as Osc, ToneOscillatorType } from "tone";
+
+import Module, { ModuleType } from "../Module";
+import Note from "../Note";
+import PolyModule, { PolyModuleType } from "./PolyModule";
+
+export interface OscillatorInterface {
+  noteName: string;
+  fine: number;
+  coarse: number;
+  wave: string;
+  volume: number;
+  range: number;
+  voiceNo?: number;
+}
+
+const InitialProps: OscillatorInterface = {
+  noteName: "C3",
+  fine: 0,
+  coarse: 0,
+  wave: "sine",
+  range: 0,
+  volume: 0,
+};
+
+export default class Oscillator extends Module<Osc, OscillatorInterface> {
+  private _note: Note;
+
+  constructor(name: string, props: Partial<OscillatorInterface>) {
+    super(new Osc(), {
+      name,
+      props: { ...InitialProps, ...props },
+      type: ModuleType.Oscillator,
+    });
+
+    this.note = new Note("C3");
+
+    this.internalModule.sync();
+    this.internalModule.start();
+  }
+
+  get note(): Note {
+    return this._note;
+  }
+
+  setNoteAt(value: Note | string, time: number) {
+    this._note = this.getNote(value);
+    this.updateFrequency(time);
+  }
+
+  set note(value: Note | string) {
+    this._note = this.getNote(value);
+    this.updateFrequency();
+  }
+
+  get noteName() {
+    return this._props["noteName"];
+  }
+
+  set noteName(value: string) {
+    this._props = { ...this.props, noteName: value };
+    this.note = new Note(this.noteName);
+  }
+
+  get fine() {
+    return this._props["fine"];
+  }
+
+  set fine(value: number) {
+    this._props = { ...this.props, fine: Math.floor(value) };
+    this.internalModule.detune.value = this.fine;
+  }
+
+  get coarse() {
+    return this._props["coarse"];
+  }
+
+  set coarse(value: number) {
+    this._props = { ...this.props, coarse: Math.floor(value) };
+
+    this.updateFrequency();
+  }
+
+  get wave() {
+    return this._props["wave"];
+  }
+
+  set wave(value: string) {
+    this._props = { ...this.props, wave: value };
+    this.internalModule.type = this.wave as ToneOscillatorType;
+  }
+
+  get volume() {
+    return this._props["volume"];
+  }
+
+  set volume(value: number) {
+    this._props = { ...this.props, volume: value };
+
+    this.internalModule.volume.value = this.volume;
+  }
+
+  get range() {
+    return this._props["range"];
+  }
+
+  set range(value: number) {
+    this._props = { ...this.props, range: value };
+    this.updateFrequency();
+  }
+
+  start() {
+    this.internalModule.start();
+  }
+
+  triggerAttack(midiEvent: MidiEvent) {
+    if (!midiEvent.note) return;
+    this.setNoteAt(midiEvent.note, midiEvent.triggeredAt);
+  }
+
+  triggerRelease(midiEvent: MidiEvent) {
+    // Do nothing
+  }
+
+  private updateFrequency(time?: number) {
+    if (!this.note) return;
+
+    const freq = this.note.frequency(this.range, this.coarse);
+
+    if (time) {
+      this.internalModule.restart(time);
+      this.internalModule.frequency.setValueAtTime(freq, time);
+    } else {
+      this.internalModule.restart();
+      this.internalModule.frequency.value = freq;
+    }
+  }
+
+  private getNote(note: Note | string): Note {
+    return note instanceof Note ? note : new Note(note);
+  }
+}
+
+export class PolyOscillator extends PolyModule<
+  Oscillator,
+  OscillatorInterface
+> {
+  constructor(name: string, props: Partial<OscillatorInterface>) {
+    super(PolyModuleType.Oscillator, {
+      name,
+      props: { ...InitialProps, ...props },
+      type: ModuleType.Oscillator,
+    });
+
+    this.registerBasicOutputs();
+    this.registerInputs();
+  }
+
+  private registerInputs() {
+    this.registerInput({
+      name: "midi in",
+      pluggable: this.midiTriggered,
+    });
+  }
+}

package/src/Module/PolyModule.ts

@@ -0,0 +1,243 @@
+import MidiEvent from "../MidiEvent";
+import { v4 as uuidv4 } from "uuid";
+import { createModule } from ".";
+import Module, { ModuleInterface, ModuleType, Connectable } from "./Base";
+import { Input, Output, IOInterface } from "./IO";
+import { AudioModule } from "../Module";
+
+export enum PolyModuleType {
+  Oscillator = "oscillator",
+  Envelope = "envelope",
+  AmpEnvelope = "ampEnvelope",
+  FreqEnvelope = "freqEnvelope",
+  VoiceScheduler = "voiceScheduler",
+  Filter = "filter",
+  Volume = "volume",
+}
+
+interface PolyModuleInterface extends ModuleInterface {}
+
+export default abstract class PolyModule<
+  MonoAudioModule extends Module<Connectable, any>,
+  PropsInterface
+> {
+  readonly id: string;
+  _name: string;
+  audioModules: MonoAudioModule[];
+  inputs: Input[] = [];
+  outputs: Output[] = [];
+  readonly _type: PolyModuleType;
+  readonly childrenType: ModuleType;
+  private _numberOfVoices: number;
+
+  constructor(type: PolyModuleType, props: PolyModuleInterface) {
+    this.id = uuidv4();
+    this._type = type;
+    this.childrenType = props.type;
+    this.audioModules = [];
+
+    const { props: extraProps, ...basicProps } = props;
+    Object.assign(this, basicProps);
+
+    this.numberOfVoices = 1;
+
+    Object.assign(this, { props: extraProps });
+    this.registerNumberOfVoicesInput();
+  }
+
+  get type() {
+    return this._type;
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  set name(value: string) {
+    this._name = value;
+    this.audioModules.forEach((m) => (m.name = value));
+  }
+
+  // Do nothing
+  // This is a little hack to avoid override type by children module
+  set type(value: PolyModuleType) {}
+
+  get props() {
+    if (this.audioModules.length === 0) {
+      throw Error("There isn't any initialized module");
+    }
+
+    return this.audioModules[0].props;
+  }
+
+  set props(value: PropsInterface) {
+    Object.assign(this, value);
+    this.audioModules.forEach((m) => (m.props = value));
+  }
+
+  get numberOfVoices() {
+    return this._numberOfVoices;
+  }
+
+  set numberOfVoices(value: number) {
+    this._numberOfVoices = value;
+    this.adjustNumberOfModules();
+  }
+
+  plug(audioModule: AudioModule, from: string, to: string) {
+    const output = this.outputs.find((i) => i.name === from);
+    if (!output) throw Error(`Output ${from} not exist`);
+
+    console.log(`${this.name}:${from} => ${audioModule.name}:${to}`);
+
+    const input = audioModule.inputs.find((i) => i.name === to);
+    if (!input)
+      throw Error(`Input ${to} in module ${audioModule.name} not exist`);
+
+    output.plug(input);
+  }
+
+  unplugAll() {
+    this.outputs.forEach((o) => o.unPlugAll());
+  }
+
+  dispose() {
+    this.audioModules.forEach((m) => {
+      m.dispose();
+    });
+  }
+
+  midiTriggered = (midiEvent: MidiEvent, voiceNo: number = 0) => {
+    const audioModule = this.findVoice(voiceNo);
+    audioModule?.midiTriggered(midiEvent);
+  };
+
+  serialize() {
+    if (this.audioModules.length === 0)
+      throw Error("There isn't any initialized module");
+
+    return {
+      ...this.audioModules[0].serialize(),
+      id: this.id,
+      type: this.type,
+      inputs: this.inputs.map((i) => i.serialize()),
+      outputs: this.outputs.map((i) => i.serialize()),
+    };
+  }
+
+  protected connect = (
+    inputAudioModule: AudioModule,
+    attribute: string = "internalModule"
+  ) => {
+    if (inputAudioModule instanceof PolyModule) {
+      inputAudioModule.audioModules.forEach((m) => {
+        if (m.voiceNo === undefined) throw Error("Voice error");
+
+        const audioModule = this.findVoice(m.voiceNo);
+        audioModule?.connect(m, attribute);
+      });
+      return;
+    }
+
+    this.audioModules.forEach((m) => m.connect(inputAudioModule, attribute));
+  };
+
+  protected disconnect = (
+    inputAudioModule: AudioModule,
+    attribute: string = "internalModule"
+  ) => {
+    if (inputAudioModule instanceof PolyModule) {
+      inputAudioModule.audioModules.forEach((m) => {
+        if (m.voiceNo === undefined) throw Error("Voice error");
+
+        const audioModule = this.findVoice(m.voiceNo);
+
+        try {
+          audioModule?.disconnect(m, attribute);
+        } catch (e) {
+          console.log(e);
+        }
+      });
+      return;
+    }
+
+    try {
+      this.audioModules.forEach((m) =>
+        m.disconnect(inputAudioModule, attribute)
+      );
+    } catch (e) {
+      console.log(e);
+    }
+  };
+
+  protected registerInput(props: IOInterface): Input {
+    const input = new Input(this, props);
+    this.inputs.push(input);
+
+    return input;
+  }
+
+  protected registerOutput(props: IOInterface): Output {
+    const output = new Output(this, props);
+    this.outputs.push(output);
+
+    return output;
+  }
+
+  protected find(callback: (audioModule: MonoAudioModule) => boolean) {
+    const audioModule = this.audioModules.find(callback);
+    if (!audioModule) throw Error(`Audio module not found`);
+
+    return audioModule;
+  }
+
+  protected findVoice(voiceNo: number) {
+    return this.audioModules.find((m) => m.voiceNo === voiceNo);
+  }
+
+  protected registerBasicOutputs() {
+    this.registerOutput({
+      name: "output",
+      onPlug: (output: Output) => {
+        this.connect(output.audioModule);
+      },
+      onUnPlug: (output: Output) => {
+        this.disconnect(output.audioModule);
+      },
+    });
+  }
+
+  protected registerBasicInputs() {
+    this.registerInput({
+      name: "input",
+    });
+  }
+
+  private registerNumberOfVoicesInput() {
+    this.registerInput({
+      name: "number of voices",
+    });
+  }
+
+  private adjustNumberOfModules() {
+    if (this.audioModules.length === this.numberOfVoices) return;
+
+    if (this.audioModules.length > this.numberOfVoices) {
+      const audioModule = this.audioModules.pop();
+      audioModule?.dispose();
+    } else {
+      const props = this.audioModules.length ? this.props : {};
+      const audioModule = createModule(this.name, this.childrenType, {
+        ...props,
+        voiceNo: this.audioModules.length,
+      });
+
+      if (audioModule instanceof PolyModule)
+        throw Error("Polymodule not supported");
+
+      this.audioModules.push(audioModule as MonoAudioModule);
+    }
+
+    this.adjustNumberOfModules();
+  }
+}

package/src/Module/VoiceScheduler.ts

@@ -0,0 +1,153 @@
+import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import MidiEvent from "../MidiEvent";
+import { Input, Output } from "./IO";
+import PolyModule, { PolyModuleType } from "./PolyModule";
+
+export interface VoiceSchedulerInterface {
+  polyNumber: number;
+}
+
+export default class VoiceScheduler extends PolyModule<
+  Voice,
+  VoiceSchedulerInterface
+> {
+  midiOutput: Output;
+  numberOfVoicesOut: Output;
+
+  constructor(name: string, props: VoiceSchedulerInterface) {
+    super(PolyModuleType.VoiceScheduler, {
+      name,
+      props,
+      type: ModuleType.Voice,
+    });
+
+    this.registerInputs();
+    this.registerOutputs();
+    this.polyNumber = this.numberOfVoices;
+  }
+
+  set polyNumber(value: number) {
+    super.numberOfVoices = value;
+    if (!this.numberOfVoicesOut) return;
+
+    this.numberOfVoicesOut.connections.forEach((input) => {
+      if (input.audioModule instanceof Module) return;
+
+      input.audioModule.numberOfVoices = value;
+    });
+  }
+
+  get polyNumber() {
+    return this.numberOfVoices;
+  }
+
+  midiTriggered = (midiEvent: MidiEvent) => {
+    let voice: Voice | undefined;
+
+    switch (midiEvent.type) {
+      case "noteOn":
+        voice = this.findFreeVoice();
+
+        break;
+      case "noteOff":
+        voice = this.audioModules.find(
+          (v) => v.activeNote === midiEvent.note?.fullName
+        );
+        break;
+      default:
+        throw Error("This type is not a note");
+    }
+
+    if (voice === undefined) return;
+
+    voice.midiTriggered(midiEvent);
+    this.midiOutput.connections.forEach((input) => {
+      input.pluggable(midiEvent, voice?.voiceNo);
+    });
+  };
+
+  serialize() {
+    const serialize = super.serialize();
+    delete serialize.props.voiceNo;
+
+    return {
+      ...serialize,
+      props: { ...serialize.props, polyNumber: this.polyNumber },
+    };
+  }
+
+  private findFreeVoice(): Voice {
+    let voice = this.audioModules.find((v) => !v.activeNote);
+
+    if (!voice) {
+      voice = this.audioModules.sort((a, b) => {
+        if (!a || !b) return 0;
+
+        return a.triggeredAt - b.triggeredAt;
+      })[0];
+    }
+
+    return voice;
+  }
+
+  private registerInputs() {
+    this.registerInput({
+      name: "midi in",
+      pluggable: this.midiTriggered,
+    });
+  }
+
+  private registerOutputs() {
+    this.numberOfVoicesOut = this.registerOutput({
+      name: "number of voices",
+      onPlug: (input: Input) => {
+        if (input.audioModule instanceof Module) return;
+
+        input.audioModule.numberOfVoices = this.numberOfVoices;
+      },
+    });
+
+    this.midiOutput = this.registerOutput({ name: "midi out" });
+  }
+}
+
+export interface VoiceInterface {
+  voiceNo?: number;
+}
+
+export class Voice extends Module<DummnyInternalModule, VoiceInterface> {
+  midiEvent: MidiEvent | null;
+  activeNote: string | null;
+  triggeredAt: number;
+  midiOutput: Output;
+
+  constructor(name: string, props: VoiceInterface) {
+    super(new DummnyInternalModule(), {
+      name,
+      type: ModuleType.Voice,
+      props,
+    });
+  }
+
+  midiTriggered = (midiEvent: MidiEvent) => {
+    const { triggeredAt, note, type } = midiEvent;
+
+    if (!note) throw Error("No valid note on this event");
+    const noteName = note.fullName;
+
+    switch (type) {
+      case "noteOn":
+        this.activeNote = noteName;
+        this.triggeredAt = triggeredAt;
+        this.midiEvent = midiEvent;
+
+        break;
+      case "noteOff":
+        this.activeNote = null;
+        this.midiEvent = null;
+        break;
+      default:
+        throw Error("This type is not a note");
+    }
+  };
+}

package/src/Module/Volume.ts

@@ -0,0 +1,46 @@
+import { Volume as Vol } from "tone";
+
+import Module, { ModuleType } from "../Module";
+import PolyModule, { PolyModuleType } from "./PolyModule";
+
+export interface VolumeInterface {
+  volume: number;
+  voiceNo?: number;
+}
+
+const InitialProps: VolumeInterface = {
+  volume: -100,
+};
+
+export default class Volume extends Module<Vol, VolumeInterface> {
+  constructor(name: string, props: Partial<VolumeInterface>) {
+    super(new Vol(), {
+      name,
+      props: { ...InitialProps, ...props },
+      type: ModuleType.Volume,
+    });
+  }
+
+  get volume() {
+    return this._props["volume"];
+  }
+
+  set volume(value: number) {
+    this._props = { ...this.props, volume: value };
+
+    this.internalModule.volume.value = this.volume;
+  }
+}
+
+export class PolyVolume extends PolyModule<Volume, VolumeInterface> {
+  constructor(name: string, props: Partial<VolumeInterface>) {
+    super(PolyModuleType.Volume, {
+      name,
+      props: { ...InitialProps, ...props },
+      type: ModuleType.Volume,
+    });
+
+    this.registerBasicInputs();
+    this.registerBasicOutputs();
+  }
+}