@blibliki/engine 0.1.17 → 0.1.19

package/src/{Module → modules}/Oscillator.ts

@@ -1,11 +1,10 @@
 import { now, Oscillator as Osc, ToneOscillatorType } from "tone";
 import Engine from "../Engine";
 
-import Note from "../Note";
-import Module, { Voicable } from "./Base";
-import PolyModule from "./PolyModule";
+import Note from "../core/Note";
+import Module, { PolyModule, Startable } from "../core/Module";
 
-export interface OscillatorInterface extends Voicable {
+export interface OscillatorInterface {
   noteName: string;
   fine: number;
   coarse: number;
@@ -23,15 +22,27 @@ const InitialProps: OscillatorInterface = {
   volume: 0,
 };
 
-class MonoOscillator extends Module<Osc, OscillatorInterface> {
+class MonoOscillator
+  extends Module<Osc, OscillatorInterface>
+  implements Startable
+{
   private _note: Note;
 
-  constructor(name: string, props: Partial<OscillatorInterface>) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<OscillatorInterface>;
+  }) {
+    const { id, name, props } = params;
+
     super(new Osc(), {
+      id,
       name,
       props: { ...InitialProps, ...props },
     });
 
+    this.registerBasicOutputs();
+    this.registerDefaultMidiInput();
     this.start(now());
   }
 
@@ -126,7 +137,7 @@ class MonoOscillator extends Module<Osc, OscillatorInterface> {
     this.start(triggeredAt);
   };
 
-  triggerRelease = (note: Note, triggeredAt: number) => {
+  triggerRelease = () => {
     // Do nothing
   };
 
@@ -153,15 +164,22 @@ export default class Oscillator extends PolyModule<
 > {
   static moduleName = "Oscillator";
 
-  constructor(name: string, props: Partial<OscillatorInterface>) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<OscillatorInterface>;
+  }) {
+    const { id, name, props } = params;
+
     super({
+      id,
       name,
       child: MonoOscillator,
       props: { ...InitialProps, ...props },
     });
 
     this.registerBasicOutputs();
-    this.registerInputs();
+    this.registerInput({ name: "midi in" });
   }
 
   start(time: number) {
@@ -171,11 +189,4 @@ export default class Oscillator extends PolyModule<
   stop(time?: number) {
     this.audioModules.forEach((audioModule) => audioModule.stop(time));
   }
-
-  private registerInputs() {
-    this.registerInput({
-      name: "midi in",
-      pluggable: this.midiTriggered,
-    });
-  }
 }

package/src/{Module → modules}/Reverb.ts

@@ -15,10 +15,21 @@ const InitialProps: Partial<ReverbInterface> = {
 export default class Reverb extends Effect<InternalReverb, ReverbInterface> {
   static moduleName = "Reverb";
 
-  constructor(name: string, props: Partial<ReverbInterface>) {
-    super(name, new InternalReverb(), {
-      ...InitialProps,
-      ...props,
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<ReverbInterface>;
+  }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      internalModule: new InternalReverb(),
+      props: {
+        ...InitialProps,
+        ...props,
+      },
     });
   }
 

package/src/{Module → modules}/Sequencer.ts

@@ -1,8 +1,8 @@
-import { now, Part, Time } from "tone";
-import Module, { DummnyInternalModule } from "./Base";
-import { INote } from "../Note";
-import { Output } from "./IO";
-import MidiEvent from "../MidiEvent";
+import { now, Part } from "tone";
+import Module, { DummnyInternalModule } from "../core/Module";
+import { INote } from "../core/Note";
+import { MidiOutput } from "../core/IO";
+import { MidiEvent } from "../core/midi";
 import Engine from "../Engine";
 
 export interface ISequence {
@@ -27,11 +27,17 @@ export default class Sequencer extends Module<
   ISequencer
 > {
   static moduleName = "Sequencer";
-  midiOutput: Output;
+  midiOutput: MidiOutput;
   private part: Part<ISequence>;
 
-  constructor(name: string, props: Partial<ISequencer>) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<ISequencer>;
+  }) {
+    const { id, name, props } = params;
     super(new DummnyInternalModule(), {
+      id,
       name,
       props: { ...InitialProps(), ...props },
     });
@@ -88,7 +94,7 @@ export default class Sequencer extends Module<
   }
 
   private registerOutputs() {
-    this.midiOutput = this.registerOutput({ name: "midi out" });
+    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
   }
 
   private initializePart() {
@@ -151,7 +157,7 @@ export default class Sequencer extends Module<
   private updateBarParts() {
     this.part.clear();
 
-    this.sequences.forEach((barSeqs, _) => {
+    this.sequences.forEach((barSeqs) => {
       barSeqs.forEach((seq) => this.part.add(seq.time, seq));
     });
 
@@ -165,10 +171,8 @@ export default class Sequencer extends Module<
   private onPartEvent = (time: number, sequence: ISequence) => {
     if (!sequence.active) return;
 
-    const event = MidiEvent.fromSequence(sequence, time);
-
-    this.midiOutput.connections.forEach((input) => {
-      input.pluggable(event);
+    MidiEvent.fromSequence(sequence, time).forEach((event) => {
+      this.midiOutput.onMidiEvent(event);
     });
   };
 }

package/src/{Module → modules}/VirtualMidi.ts

@@ -1,8 +1,8 @@
 import Engine from "../Engine";
-import MidiEvent from "../MidiEvent";
-import Note from "../Note";
-import Module, { DummnyInternalModule } from "./Base";
-import { Output } from "./IO";
+import { MidiEvent } from "../core/midi";
+import Note from "../core/Note";
+import Module, { DummnyInternalModule } from "../core/Module";
+import { MidiOutput } from "../core/IO";
 
 export interface VirtualMidiInterface {
   activeNotes: string[];
@@ -17,10 +17,16 @@ export default class VirtualMidi extends Module<
   VirtualMidiInterface
 > {
   static moduleName = "VirtualMidi";
-  midiOutput: Output;
+  midiOutput: MidiOutput;
 
-  constructor(name: string, props: VirtualMidiInterface) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: VirtualMidiInterface;
+  }) {
+    const { id, name, props } = params;
     super(new DummnyInternalModule(), {
+      id,
       name,
       props: { ...InitialProps, ...props },
     });
@@ -39,9 +45,7 @@ export default class VirtualMidi extends Module<
   }
 
   sendMidi(midiEvent: MidiEvent) {
-    this.midiOutput.connections.forEach((input) => {
-      input.pluggable(midiEvent);
-    });
+    this.midiOutput.onMidiEvent(midiEvent);
   }
 
   triggerAttack = (note: Note) => {
@@ -64,13 +68,13 @@ export default class VirtualMidi extends Module<
   }
 
   private registerInputs() {
-    this.registerInput({
+    this.registerMidiInput({
       name: "midi in",
-      pluggable: this.midiTriggered,
+      onMidiEvent: this.onMidiEvent,
     });
   }
 
   private registerOutputs() {
-    this.midiOutput = this.registerOutput({ name: "midi out" });
+    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
   }
 }

package/src/modules/VoiceScheduler.ts

@@ -0,0 +1,145 @@
+import { MidiEvent } from "../core/midi";
+import Module, { PolyModule, DummnyInternalModule } from "../core/Module";
+import { MidiOutput } from "../core/IO";
+
+export interface VoiceSchedulerInterface {
+  polyNumber: number;
+}
+
+export default class VoiceScheduler extends PolyModule<
+  Voice,
+  VoiceSchedulerInterface
+> {
+  static moduleName = "VoiceScheduler";
+  midiOutput: MidiOutput;
+
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: VoiceSchedulerInterface;
+  }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      child: Voice,
+      props,
+    });
+
+    this.registerInputs();
+    this.registerOutputs();
+    this.polyNumber = this.numberOfVoices;
+  }
+
+  set polyNumber(value: number) {
+    super.numberOfVoices = value;
+  }
+
+  get polyNumber() {
+    return this.numberOfVoices;
+  }
+
+  onMidiEvent = (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) return;
+
+    voice.midiTriggered(midiEvent);
+    midiEvent.voiceNo = voice.voiceNo;
+    this.midiOutput.onMidiEvent(midiEvent);
+  };
+
+  serialize() {
+    const serialize = super.serialize();
+
+    return {
+      ...serialize,
+      props: { ...serialize.props, polyNumber: this.polyNumber },
+    };
+  }
+
+  private findFreeVoice(): Voice {
+    let voice = this.audioModules.find((v) => !v.activeNote);
+
+    // If no available voice, get the one with the lowest triggeredAt
+    if (!voice) {
+      voice = this.audioModules.sort((a, b) => {
+        if (!a || !b) return 0;
+
+        return a.triggeredAt - b.triggeredAt;
+      })[0];
+    }
+
+    return voice;
+  }
+
+  private registerInputs() {
+    this.registerMidiInput({
+      name: "midi in",
+      onMidiEvent: this.onMidiEvent,
+    });
+  }
+
+  private registerOutputs() {
+    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
+  }
+}
+
+class Voice extends Module<DummnyInternalModule, VoiceSchedulerInterface> {
+  midiEvent: MidiEvent | null;
+  activeNote: string | null;
+  triggeredAt: number;
+
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: VoiceSchedulerInterface;
+  }) {
+    const { id, name, props } = params;
+
+    super(new DummnyInternalModule(), {
+      id,
+      name,
+      props,
+    });
+  }
+
+  midiTriggered = (midiEvent: MidiEvent) => {
+    if (this.voiceNo === undefined) throw Error("Voice without voiceNo");
+
+    const { triggeredAt, note, type } = midiEvent;
+
+    if (!note) return;
+    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 → modules}/Volume.ts

@@ -1,10 +1,9 @@
 import { Volume as Vol } from "tone";
 
-import Module, { Voicable } from "./Base";
-import PolyModule from "./PolyModule";
-import Note from "../Note";
+import Module, { PolyModule } from "../core/Module";
+import Note from "../core/Note";
 
-export interface VolumeInterface extends Voicable {
+export interface VolumeInterface {
   volume: number;
 }
 
@@ -13,11 +12,21 @@ const InitialProps: VolumeInterface = {
 };
 
 class MonoVolume extends Module<Vol, VolumeInterface> {
-  constructor(name: string, props: Partial<VolumeInterface>) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<VolumeInterface>;
+  }) {
+    const { id, name, props } = params;
+
     super(new Vol(), {
+      id,
       name,
       props: { ...InitialProps, ...props },
     });
+
+    this.registerBasicInputs();
+    this.registerBasicOutputs();
   }
 
   get volume() {
@@ -35,7 +44,7 @@ class MonoVolume extends Module<Vol, VolumeInterface> {
     this.internalModule.volume.exponentialRampToValueAtTime(db, triggeredAt);
   };
 
-  triggerRelease = (note: Note, triggeredAt: number) => {
+  triggerRelease = () => {
     // Do nothing
   };
 }
@@ -43,8 +52,15 @@ class MonoVolume extends Module<Vol, VolumeInterface> {
 export default class Volume extends PolyModule<MonoVolume, VolumeInterface> {
   static moduleName = "Volume";
 
-  constructor(name: string, props: Partial<VolumeInterface>) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<VolumeInterface>;
+  }) {
+    const { id, name, props } = params;
+
     super({
+      id,
       name,
       child: MonoVolume,
       props: { ...InitialProps, ...props },
@@ -52,13 +68,5 @@ export default class Volume extends PolyModule<MonoVolume, VolumeInterface> {
 
     this.registerBasicInputs();
     this.registerBasicOutputs();
-    this.registerInputs();
-  }
-
-  private registerInputs() {
-    this.registerInput({
-      name: "midi in",
-      pluggable: this.midiTriggered,
-    });
   }
 }

package/src/{Module → modules}/index.ts

@@ -1,8 +1,6 @@
 import { camelCase, upperFirst } from "lodash";
-import Module, { Connectable } from "./Base";
-import PolyModule from "./PolyModule";
-import Oscillator from "./Oscillator";
 import { Envelope, AmpEnvelope, FreqEnvelope } from "./Envelope";
+import Oscillator from "./Oscillator";
 import Filter from "./Filter";
 import Master from "./Master";
 import VoiceScheduler from "./VoiceScheduler";
@@ -14,18 +12,15 @@ import Delay from "./Delay";
 import Distortion from "./Distortion";
 import BitCrusher from "./BitCrusher";
 import Sequencer from "./Sequencer";
-import DataSequencer from "./DataSequencer";
-
-export { default } from "./Base";
-export { default as PolyModule } from "./PolyModule";
-export type { ModuleInterface, Connectable, Triggerable } from "./Base";
+import { AudioModule } from "../core/Module";
 
+export { default as Master } from "./Master";
 export { default as Filter } from "./Filter";
 export { default as Oscillator } from "./Oscillator";
+export { default as VirtualMidi } from "./VirtualMidi";
+export { default as VoiceScheduler } from "./VoiceScheduler";
 export { default as Sequencer } from "./Sequencer";
-export { default as DataSequencer } from "./DataSequencer";
 export type { ISequence } from "./Sequencer";
-export type { IDataSequence } from "./DataSequencer";
 
 export {
   Envelope,
@@ -34,18 +29,18 @@ export {
   EnvelopeStages,
 } from "./Envelope";
 
-export type AudioModule =
-  | Module<Connectable, any>
-  | PolyModule<Module<Connectable, any>, any>;
+export interface ICreateModule {
+  id?: string;
+  name: string;
+  type: string;
+  props: any;
+}
 
-export function createModule(
-  name: string,
-  type: string,
-  props: any
-): AudioModule {
+export function createModule(params: ICreateModule): AudioModule {
+  const { id, type, name, props } = params;
   const klass = moduleClassFromType(type);
 
-  return new klass(name, props);
+  return new klass({ id, name, props });
 }
 
 function moduleClassFromType(type: string) {
@@ -82,8 +77,6 @@ function moduleClassFromType(type: string) {
       return BitCrusher;
     case Sequencer.moduleName:
       return Sequencer;
-    case DataSequencer.moduleName:
-      return DataSequencer;
     default:
       throw Error(`Unknown module type ${type}`);
   }

package/src/routes.ts

@@ -1,44 +1,45 @@
 import { v4 as uuidv4 } from "uuid";
 
 import Engine from "./";
+import { plugCompatibleIO } from "./core/IO/Node";
+import { Optional } from "./types";
 
 export interface RouteProps {
   sourceId: string;
-  outputName: string;
+  sourceIOId: string;
   destinationId: string;
-  inputName: string;
+  destinationIOId: string;
 }
 
 export interface RouteInterface extends RouteProps {
   id: string;
 }
 
-export function createRoute(props: RouteProps) {
-  const id = uuidv4();
+export function createRoute(props: Optional<RouteInterface, "id">) {
+  const id = props.id || uuidv4();
 
   return { ...props, id };
 }
 
 export function applyRoutes(routes: RouteInterface[]) {
-  Object.values(Engine.modules).forEach((m) => m.unplugAll());
+  Object.values(Engine.modules).forEach((m) => {
+    m.unPlugAll();
+  });
 
-  const succesedConnections = routes
-    .sort((r1, r2) => {
-      if (r1.outputName === "number of voices") return -1;
-      if (r2.outputName === "number of voices") return 1;
+  const succesedConnections = routes.map((route) => {
+    const { sourceId, sourceIOId, destinationId, destinationIOId } = route;
 
-      return 0;
-    })
-    .map((route) => {
-      const { sourceId, outputName, destinationId, inputName } = route;
+    const source = Engine.findById(sourceId);
+    const destination = Engine.findById(destinationId);
 
-      const source = Engine.findById(sourceId);
-      const destination = Engine.findById(destinationId);
+    const output = source.outputs.find(sourceIOId);
+    const input = destination.inputs.find(destinationIOId);
+    if (!input || !output) throw Error("IO not found");
 
-      source.plug(destination, outputName, inputName);
+    plugCompatibleIO(input, output);
 
-      return true;
-    });
+    return true;
+  });
 
   if (succesedConnections.every((v) => v)) {
     console.log("######## Routes succesfully applied");

package/src/types.ts

@@ -0,0 +1,3 @@
+export type AnyObject = { [Key: string]: any };
+export type AtLeast<T, K extends keyof T> = Partial<T> & Pick<T, K>;
+export type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;

package/src/utils.ts

@@ -0,0 +1,18 @@
+import CryptoJS from "crypto-js";
+
+export function deterministicId(
+  originalId: string,
+  additionalString: string
+): string {
+  const combinedString = `${originalId}:${additionalString}`;
+  const hash = CryptoJS.SHA256(combinedString).toString(CryptoJS.enc.Hex);
+
+  const newId = `${hash.substring(0, 8)}-${hash.substring(
+    8,
+    12
+  )}-4${hash.substring(13, 16)}-${
+    "89AB"[parseInt(hash.substring(17, 18), 16) % 4]
+  }${hash.substring(18, 21)}-${hash.substring(21, 33)}`;
+
+  return newId;
+}