@blibliki/engine 0.1.0

package/src/MidiEvent.ts

@@ -0,0 +1,44 @@
+import { now } from "tone";
+import Note from "./Note";
+
+const EvenType: { [key: number]: string } = {
+  8: "noteOff",
+  9: "noteOn",
+};
+
+export default class MidiEvent {
+  note?: Note;
+  triggeredAt: number;
+  private data: Uint8Array;
+  private _type: string;
+  private _event: MIDIMessageEvent;
+
+  constructor(event: MIDIMessageEvent) {
+    this._event = event;
+    this.triggeredAt = now();
+    this.data = event.data;
+    this.defineNote();
+  }
+
+  get type() {
+    if (this._type) return this._type;
+
+    let type = EvenType[this.data[0] >> 4];
+
+    if (type === "noteOn" && this.data[2] === 0) {
+      type = "noteOff";
+    }
+
+    return (this._type = type);
+  }
+
+  get isNote() {
+    return this.type === "noteOn" || this.type === "noteOff";
+  }
+
+  defineNote() {
+    if (!this.isNote) return;
+
+    this.note = new Note(this._event);
+  }
+}

package/src/Module/Base.ts

@@ -0,0 +1,200 @@
+import { v4 as uuidv4 } from "uuid";
+import { InputNode } from "tone";
+
+import { Input, Output, IOInterface } from "./IO";
+import MidiEvent from "../MidiEvent";
+import { AudioModule, PolyModule } from "../Module";
+
+export enum ModuleType {
+  Oscillator = "monoOscillator",
+  Envelope = "monoEnvelope",
+  AmpEnvelope = "monoAmpEnvelope",
+  FreqEnvelope = "monoFreqEnvelope",
+  Filter = "monoFilter",
+  Master = "master",
+  Voice = "voice",
+  MidiSelector = "midiSelector",
+  Volume = "monoVolume",
+}
+
+export interface Connectable {
+  connect: (inputNode: InputNode) => void;
+  disconnect: (inputNode?: InputNode) => void;
+  dispose: () => void;
+}
+
+export interface Triggerable {
+  triggerAttack: Function;
+  triggerRelease: Function;
+}
+
+export interface ModuleInterface {
+  name: string;
+  type: ModuleType;
+  props?: { [key: string]: any };
+  voiceNo?: number;
+}
+
+export class DummnyInternalModule implements Connectable {
+  connect(inputNode: InputNode) {
+    throw Error("This module is not connectable");
+  }
+
+  disconnect(inputNode?: InputNode) {}
+
+  dispose() {}
+}
+
+class Module<InternalModule extends Connectable, PropsInterface>
+  implements ModuleInterface
+{
+  internalModule: InternalModule;
+
+  readonly id: string;
+  name: string;
+  inputs: Input[] = [];
+  outputs: Output[] = [];
+  type: ModuleType;
+  readonly voiceNo?: number;
+  updatedAt: Date;
+  _props: PropsInterface;
+
+  constructor(internalModule: InternalModule, props: Partial<ModuleInterface>) {
+    this.internalModule = internalModule;
+    this.id = uuidv4();
+
+    Object.assign(this, props);
+  }
+
+  set props(value: PropsInterface) {
+    if (!value) return;
+    if (!this._props) this._props = value;
+
+    this.updatedAt = new Date();
+
+    Object.assign(this, value);
+  }
+
+  get props() {
+    return this._props;
+  }
+
+  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());
+  }
+
+  connect = (
+    inputAudioModule: AudioModule,
+    attribute: string = "internalModule"
+  ) => {
+    if (inputAudioModule instanceof PolyModule) {
+      inputAudioModule.audioModules.forEach((m) => {
+        this.internalModule.connect((m as any)[attribute] as InputNode);
+      });
+      return;
+    }
+
+    this.internalModule.connect(
+      (inputAudioModule as any)[attribute] as InputNode
+    );
+  };
+
+  disconnect = (
+    inputAudioModule: AudioModule,
+    attribute: string = "internalModule"
+  ) => {
+    if (inputAudioModule instanceof PolyModule) {
+      inputAudioModule.audioModules.forEach((m) => {
+        this.internalModule.disconnect((m as any)[attribute] as InputNode);
+      });
+      return;
+    }
+
+    this.internalModule.disconnect(
+      (inputAudioModule as any)[attribute] as InputNode
+    );
+  };
+
+  dispose() {
+    this.internalModule.dispose();
+  }
+
+  triggerAttack(midiEvent: MidiEvent) {
+    throw Error("triggerAttack not implemented");
+  }
+
+  triggerRelease(midiEvent: MidiEvent) {
+    throw Error("triggerRelease not implemented");
+  }
+
+  midiTriggered = (midiEvent: MidiEvent) => {
+    switch (midiEvent.type) {
+      case "noteOn":
+        this.triggerAttack(midiEvent);
+        break;
+      case "noteOff":
+        this.triggerRelease(midiEvent);
+        break;
+      default:
+        throw Error("This type is not a note");
+    }
+  };
+
+  serialize() {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      props: this.props,
+      inputs: this.inputs.map((i) => i.serialize()),
+      outputs: this.outputs.map((i) => i.serialize()),
+    };
+  }
+
+  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 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",
+    });
+  }
+}
+
+export default Module;

package/src/Module/Envelope/AmpEnvelope.ts

@@ -0,0 +1,17 @@
+import { AmplitudeEnvelope } from "tone";
+
+import { ModuleType } from "../index";
+import Base, { EnvelopeInterface, PolyBase } from "./Base";
+import { PolyModuleType } from "../PolyModule";
+
+export default class AmpEnvelope extends Base<AmplitudeEnvelope> {
+  constructor(name: string, props: EnvelopeInterface) {
+    super(name, ModuleType.AmpEnvelope, new AmplitudeEnvelope(), props);
+  }
+}
+
+export class PolyAmpEnvelope extends PolyBase<AmpEnvelope> {
+  constructor(name: string, props: Partial<EnvelopeInterface>) {
+    super(name, ModuleType.AmpEnvelope, PolyModuleType.AmpEnvelope, props);
+  }
+}

package/src/Module/Envelope/Base.ts

@@ -0,0 +1,159 @@
+import { Envelope as Env } from "tone";
+
+import Module, { ModuleType, Connectable, Triggerable } from "../index";
+import PolyModule, { PolyModuleType } from "../PolyModule";
+import MidiEvent from "../../MidiEvent";
+
+export const enum EnvelopeStages {
+  Attack = "attack",
+  Decay = "decay",
+  Sustain = "sustain",
+  Release = "release",
+}
+
+const MAX_TIME = 2;
+const MIN_TIME = 0.01;
+const SUSTAIN_MAX_VALUE = 1;
+const SUSTAIN_MIN_VALUE = 0;
+
+export interface EnvelopeInterface {
+  attack: number;
+  decay: number;
+  sustain: number;
+  release: number;
+  voiceNo?: number;
+}
+
+const InitialProps: EnvelopeInterface = {
+  attack: MIN_TIME,
+  decay: MIN_TIME,
+  sustain: SUSTAIN_MAX_VALUE,
+  release: MIN_TIME,
+};
+
+export default abstract class EnvelopeModule<EnvelopeLike extends Env>
+  extends Module<EnvelopeLike, EnvelopeInterface>
+  implements Triggerable
+{
+  activeNote?: string;
+  triggeredAt: number;
+
+  constructor(
+    name: string,
+    type: ModuleType,
+    internalModule: EnvelopeLike,
+    props: EnvelopeInterface
+  ) {
+    super(internalModule, {
+      name,
+      type,
+      props: { ...InitialProps, ...props },
+    });
+  }
+
+  get attack() {
+    return this._props["attack"];
+  }
+
+  set attack(value: number) {
+    this.setStage(EnvelopeStages.Attack, value);
+  }
+
+  get decay() {
+    return this._props["decay"];
+  }
+
+  set decay(value: number) {
+    this.setStage(EnvelopeStages.Decay, value);
+  }
+
+  get sustain() {
+    return this._props["sustain"];
+  }
+
+  set sustain(value: number) {
+    this.setStage(EnvelopeStages.Sustain, value);
+  }
+
+  get release() {
+    return this._props["release"];
+  }
+
+  set release(value: number) {
+    this.setStage(EnvelopeStages.Release, value);
+  }
+
+  setStage(stage: EnvelopeStages, value: number) {
+    const calculatedValue =
+      value === 0 ? this.minTime(stage) : this.maxTime(stage) * value;
+    this._props = { ...this.props, [stage]: value };
+    this.internalModule[stage] = calculatedValue;
+  }
+
+  triggerAttack(midiEvent: MidiEvent) {
+    const { note, triggeredAt } = midiEvent;
+
+    this.activeNote = note?.fullName;
+    this.triggeredAt = triggeredAt;
+    this.internalModule.triggerAttack(triggeredAt);
+  }
+
+  triggerRelease(midiEvent: MidiEvent) {
+    const { note, triggeredAt } = midiEvent;
+
+    if (this.activeNote && this.activeNote !== note?.fullName) return;
+
+    this.internalModule.triggerRelease(triggeredAt);
+  }
+
+  private maxTime(stage: EnvelopeStages): number {
+    return stage === EnvelopeStages.Sustain ? SUSTAIN_MAX_VALUE : MAX_TIME;
+  }
+
+  private minTime(stage: EnvelopeStages): number {
+    return stage === EnvelopeStages.Sustain ? SUSTAIN_MIN_VALUE : MIN_TIME;
+  }
+}
+
+export abstract class PolyBase<
+  EnvelopeModule extends Module<Connectable, any>
+> extends PolyModule<EnvelopeModule, EnvelopeInterface> {
+  constructor(
+    name: string,
+    type: ModuleType,
+    polyType: PolyModuleType,
+    props: Partial<EnvelopeInterface>
+  ) {
+    super(polyType, {
+      name,
+      type,
+      props: { ...InitialProps, ...props },
+    });
+
+    this.registerBasicInputs();
+    this.registerBasicOutputs();
+    this.registerInputs();
+  }
+
+  private registerInputs() {
+    this.registerInput({
+      name: "midi in",
+      pluggable: this.midiTriggered,
+    });
+  }
+}
+
+export class Envelope extends EnvelopeModule<Env> {
+  constructor(name: string, props: EnvelopeInterface) {
+    super(name, ModuleType.Envelope, new Env(), props);
+  }
+}
+
+export class PolyEnvelope extends PolyBase<Envelope> {
+  constructor(name: string, props: Partial<EnvelopeInterface>) {
+    super(name, ModuleType.Envelope, PolyModuleType.Envelope, {
+      ...InitialProps,
+      ...props,
+    });
+  }
+}

package/src/Module/Envelope/FreqEnvelope.ts

@@ -0,0 +1,69 @@
+import { FrequencyEnvelope } from "tone";
+
+import { ModuleType } from "../Base";
+import Filter from "../Filter";
+import { Output } from "../IO";
+import { PolyModuleType } from "../PolyModule";
+
+import Base, { EnvelopeInterface, PolyBase } from "./Base";
+
+interface FreqEnvelopeInterface extends Partial<EnvelopeInterface> {
+  amount?: number;
+}
+
+const InitialProps: FreqEnvelopeInterface = {
+  amount: 0,
+};
+
+export default class FreqEnvelope extends Base<FrequencyEnvelope> {
+  private _frequency: number;
+  private _amount: number;
+  filter: Filter;
+
+  constructor(name: string, props: EnvelopeInterface) {
+    super(name, ModuleType.FreqEnvelope, new FrequencyEnvelope(), {
+      ...InitialProps,
+      ...props,
+    });
+  }
+
+  get frequency() {
+    return this._frequency;
+  }
+
+  set frequency(value: number) {
+    this._frequency = value;
+    this.internalModule.baseFrequency = value;
+  }
+
+  get amount() {
+    return this._amount;
+  }
+
+  set amount(value: number) {
+    this._amount = value;
+
+    this.internalModule.octaves = value;
+  }
+}
+
+export class PolyFreqEnvelope extends PolyBase<FreqEnvelope> {
+  constructor(name: string, props: Partial<EnvelopeInterface>) {
+    super(name, ModuleType.FreqEnvelope, PolyModuleType.FreqEnvelope, props);
+
+    this.registerOutputs();
+  }
+
+  protected registerOutputs() {
+    this.registerOutput({
+      name: "frequency",
+      pluggable: this,
+      onPlug: (output: Output) => {
+        this.connect(output.audioModule, output.pluggable);
+      },
+      onUnPlug: (output: Output) => {
+        this.disconnect(output.audioModule, output.pluggable);
+      },
+    });
+  }
+}

package/src/Module/Envelope/index.ts

@@ -0,0 +1,3 @@
+export { default, Envelope, EnvelopeStages } from "./Base";
+export { default as AmpEnvelope } from "./AmpEnvelope";
+export { default as FreqEnvelope } from "./FreqEnvelope";

package/src/Module/Filter.ts

@@ -0,0 +1,111 @@
+import { Filter as InternalFilter } from "tone";
+
+import { FreqEnvelope } from "./Envelope";
+import Module, { ModuleType } from "./Base";
+import PolyModule, { PolyModuleType } from "./PolyModule";
+import { PolyFreqEnvelope } from "./Envelope/FreqEnvelope";
+
+interface FilterInterface {
+  cutoff: number;
+  resonance: number;
+  envelopeAmount: number;
+  voiceNo?: number;
+}
+
+interface FilterProps extends Partial<FilterInterface> {}
+
+const InitialProps: FilterInterface = {
+  cutoff: 20000,
+  resonance: 0,
+  envelopeAmount: 0,
+};
+
+export default class Filter extends Module<InternalFilter, FilterInterface> {
+  private _envelope: FreqEnvelope;
+
+  constructor(name: string, props: FilterProps) {
+    super(new InternalFilter({ type: "lowpass" }), {
+      name,
+      props: { ...InitialProps, ...props },
+      type: ModuleType.Filter,
+    });
+  }
+
+  get cutoff() {
+    return this._props["cutoff"];
+  }
+
+  set cutoff(value: number) {
+    this._props = { ...this.props, cutoff: value };
+
+    if (this._envelope) {
+      this._envelope.frequency = value;
+    } else {
+      this.internalModule.frequency.value = value;
+    }
+  }
+
+  get frequency() {
+    return this.internalModule.frequency;
+  }
+
+  get resonance() {
+    return this._props["resonance"];
+  }
+
+  set resonance(value: number) {
+    this._props = { ...this.props, resonance: value };
+
+    this.internalModule.Q.value = value;
+  }
+
+  get envelopeAmount() {
+    return this._props["envelopeAmount"];
+  }
+
+  set envelopeAmount(value: number) {
+    this._props = { ...this.props, envelopeAmount: value };
+
+    if (!this._envelope) return;
+
+    this._envelope.amount = value;
+  }
+
+  conntectedEnvelope(envelope: FreqEnvelope) {
+    this._envelope = envelope;
+    this._envelope.frequency = this.cutoff;
+  }
+}
+
+export class PolyFilter extends PolyModule<Filter, FilterInterface> {
+  constructor(name: string, props: Partial<FilterInterface>) {
+    super(PolyModuleType.Filter, {
+      name,
+      props: { ...InitialProps, ...props },
+      type: ModuleType.Filter,
+    });
+
+    this.registerBasicInputs();
+    this.registerBasicOutputs();
+    this.registerInputs();
+  }
+
+  private registerInputs() {
+    this.registerInput({
+      name: "frequency",
+      pluggable: "frequency",
+      onPlug: (output) => {
+        this.conntectedEnvelope(output.audioModule as PolyFreqEnvelope);
+      },
+    });
+  }
+
+  conntectedEnvelope(polyFreqEnvelope: PolyFreqEnvelope) {
+    polyFreqEnvelope.audioModules.forEach((envelope) => {
+      if (envelope.voiceNo === undefined) return;
+
+      const filter = this.findVoice(envelope.voiceNo);
+      filter?.conntectedEnvelope(envelope);
+    });
+  }
+}

package/src/Module/IO.ts

@@ -0,0 +1,85 @@
+import { v4 as uuidv4 } from "uuid";
+import { AudioModule } from "../Module";
+
+export interface IOInterface {
+  name: string;
+  pluggable?: any;
+  onPlug?: (io: IO) => void;
+  onUnPlug?: (io: IO) => void;
+}
+
+export interface SerializeInterface {
+  id: string;
+  name: string;
+  moduleId: string;
+  moduleName: string;
+}
+
+enum IOType {
+  Input = "input",
+  Output = "output",
+}
+
+abstract class IO {
+  id: string;
+  ioType: IOType;
+  name: string;
+  audioModule: AudioModule;
+  pluggable: any;
+  onPlug: (io: IO) => void;
+  onUnPlug: (io: IO) => void;
+  connections: Input[] | Output[] = [];
+
+  constructor(ioType: IOType, audioModule: AudioModule, props: IOInterface) {
+    this.id = uuidv4();
+    this.ioType = ioType;
+    this.audioModule = audioModule;
+
+    Object.assign(this, props);
+  }
+
+  plug(io: IO) {
+    if (this.onPlug) this.onPlug(io);
+
+    if (this.ioType === IOType.Output) io.plug(this);
+
+    this.connections.push(io);
+  }
+
+  unPlug(io: IO) {
+    if (this.onUnPlug) this.onUnPlug(io);
+
+    if (this.ioType === IOType.Output) {
+      io.unPlug(this);
+    }
+
+    this.connections = this.connections.filter(
+      (current_io) => current_io.id !== io.id
+    );
+  }
+
+  unPlugAll() {
+    this.connections.forEach((c) => this.unPlug(c));
+  }
+
+  serialize(): SerializeInterface {
+    return {
+      id: this.id,
+      name: this.name,
+      moduleId: this.audioModule.id,
+      moduleName: this.audioModule.name,
+    };
+  }
+}
+
+export class Input extends IO {
+  constructor(audioModule: AudioModule, props: IOInterface) {
+    super(IOType.Input, audioModule, props);
+  }
+}
+
+export class Output extends IO {
+  constructor(audioModule: AudioModule, props: IOInterface) {
+    super(IOType.Output, audioModule, props);
+  }
+}

package/src/Module/Master.ts

@@ -0,0 +1,18 @@
+import { Destination, getDestination } from "tone";
+import Module, { ModuleType } from "../Module";
+
+export interface MasterInterface {}
+
+export default class Master extends Module<
+  typeof Destination,
+  MasterInterface
+> {
+  constructor() {
+    super(getDestination(), {
+      name: "Master",
+      type: ModuleType.Master,
+    });
+
+    this.registerBasicInputs();
+  }
+}