@blibliki/engine 0.1.8 → 0.1.10

package/src/Module/Base.ts

@@ -4,6 +4,7 @@ import { InputNode } from "tone";
 import { Input, Output, IOInterface } from "./IO";
 import MidiEvent from "../MidiEvent";
 import { AudioModule, PolyModule } from "../Module";
+import Note from "../Note";
 
 export interface Connectable {
   connect: (inputNode: InputNode) => void;
@@ -14,6 +15,7 @@ export interface Connectable {
 export interface Triggerable {
   triggerAttack: Function;
   triggerRelease: Function;
+  triggerAttackRelease: Function;
 }
 
 export interface Voicable {
@@ -48,7 +50,7 @@ class Module<InternalModule extends Connectable, PropsInterface>
   outputs: Output[] = [];
   readonly voiceNo?: number;
   updatedAt: Date;
-  _props: PropsInterface;
+  _props: PropsInterface = {} as PropsInterface;
 
   constructor(internalModule: InternalModule, props: Partial<ModuleInterface>) {
     this.internalModule = internalModule;
@@ -59,7 +61,6 @@ class Module<InternalModule extends Connectable, PropsInterface>
 
   set props(value: PropsInterface) {
     if (!value) return;
-    if (!this._props) this._props = value;
 
     this.updatedAt = new Date();
 
@@ -121,27 +122,46 @@ class Module<InternalModule extends Connectable, PropsInterface>
     this.internalModule.dispose();
   }
 
-  triggerAttack(midiEvent: MidiEvent) {
+  triggerAttack(note: Note, triggeredAt: number) {
     throw Error("triggerAttack not implemented");
   }
 
-  triggerRelease(midiEvent: MidiEvent) {
+  triggerRelease(note: Note, triggeredAt: number) {
     throw Error("triggerRelease not implemented");
   }
 
-  midiTriggered = (midiEvent: MidiEvent) => {
+  triggerAttackRelease(note: Note, triggeredAt: number) {
+    throw Error("triggerAttackRelease not implemented");
+  }
+
+  midiTriggered = (midiEvent: MidiEvent, noteIndex?: number) => {
     switch (midiEvent.type) {
       case "noteOn":
-        this.triggerAttack(midiEvent);
+        this.triggerer(this.triggerAttack, midiEvent, noteIndex);
         break;
       case "noteOff":
-        this.triggerRelease(midiEvent);
+        this.triggerer(this.triggerRelease, midiEvent, noteIndex);
         break;
       default:
         throw Error("This type is not a note");
     }
   };
 
+  private triggerer(
+    trigger: Function,
+    midiEvent: MidiEvent,
+    noteIndex?: number
+  ) {
+    const { notes, triggeredAt } = midiEvent;
+
+    if (noteIndex !== undefined && this.voiceNo !== undefined) {
+      trigger(notes[noteIndex], triggeredAt);
+      return;
+    }
+
+    notes.forEach((note) => trigger(note, triggeredAt));
+  }
+
   serialize() {
     const klass = this.constructor as typeof Module;
 

package/src/Module/Envelope/Base.ts

@@ -3,6 +3,7 @@ import { Envelope as Env } from "tone";
 import Module, { Connectable, Triggerable, Voicable } from "../Base";
 import PolyModule from "../PolyModule";
 import MidiEvent from "../../MidiEvent";
+import Note from "../../Note";
 
 export const enum EnvelopeStages {
   Attack = "attack",
@@ -88,21 +89,25 @@ export default abstract class EnvelopeModule<EnvelopeLike extends Env>
     this.internalModule[stage] = calculatedValue;
   }
 
-  triggerAttack(midiEvent: MidiEvent) {
-    const { note, triggeredAt } = midiEvent;
+  triggerAttack = (note: Note, triggeredAt: number) => {
+    if (note.duration) return this.triggerAttackRelease(note, triggeredAt);
 
-    this.activeNote = note?.fullName;
+    this.activeNote = note.fullName;
     this.triggeredAt = triggeredAt;
     this.internalModule.triggerAttack(triggeredAt);
-  }
+  };
 
-  triggerRelease(midiEvent: MidiEvent) {
-    const { note, triggeredAt } = midiEvent;
+  triggerAttackRelease = (note: Note, triggeredAt: number) => {
+    this.activeNote = note.fullName;
+    this.triggeredAt = triggeredAt;
+    this.internalModule.triggerAttackRelease(note.duration, triggeredAt);
+  };
 
-    if (this.activeNote && this.activeNote !== note?.fullName) return;
+  triggerRelease = (note: Note, triggeredAt: number) => {
+    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;

package/src/Module/IO.ts

@@ -39,11 +39,11 @@ abstract class IO {
   }
 
   plug(io: IO) {
+    this.connections.push(io);
+
     if (this.onPlug) this.onPlug(io);
 
     if (this.ioType === IOType.Output) io.plug(this);
-
-    this.connections.push(io);
   }
 
   unPlug(io: IO) {

package/src/Module/Oscillator.ts

@@ -1,5 +1,5 @@
 import MidiEvent from "../MidiEvent";
-import { Oscillator as Osc, ToneOscillatorType } from "tone";
+import { now, Oscillator as Osc, ToneOscillatorType } from "tone";
 
 import Note from "../Note";
 import Module, { Voicable } from "./Base";
@@ -112,14 +112,13 @@ class MonoOscillator extends Module<Osc, OscillatorInterface> {
     this.internalModule.start();
   }
 
-  triggerAttack(midiEvent: MidiEvent) {
-    if (!midiEvent.note) return;
-    this.setNoteAt(midiEvent.note, midiEvent.triggeredAt);
-  }
+  triggerAttack = (note: Note, triggeredAt: number) => {
+    this.setNoteAt(note, triggeredAt);
+  };
 
-  triggerRelease(midiEvent: MidiEvent) {
+  triggerRelease = (note: Note) => {
     // Do nothing
-  }
+  };
 
   private updateFrequency(time?: number) {
     if (!this.note) return;

package/src/Module/PolyModule.ts

@@ -90,9 +90,13 @@ export default abstract class PolyModule<
     });
   }
 
-  midiTriggered = (midiEvent: MidiEvent, voiceNo: number = 0) => {
+  midiTriggered = (
+    midiEvent: MidiEvent,
+    voiceNo: number,
+    noteIndex?: number
+  ) => {
     const audioModule = this.findVoice(voiceNo);
-    audioModule?.midiTriggered(midiEvent);
+    audioModule?.midiTriggered(midiEvent, noteIndex);
   };
 
   serialize() {

package/src/Module/Sequencer.ts

@@ -0,0 +1,169 @@
+import { Part, Time } from "tone";
+import Module, { DummnyInternalModule } from "./Base";
+import { INote } from "../Note";
+import { Output } from "./IO";
+import MidiEvent from "../MidiEvent";
+
+export interface ISequence {
+  active: boolean;
+  time: string;
+  notes: INote[];
+}
+interface ISequencer {
+  sequences: ISequence[][];
+  length: number;
+  bars: number;
+}
+
+const InitialProps = () => ({
+  sequences: [],
+  length: 16,
+  bars: 1,
+});
+
+export default class Sequencer extends Module<
+  DummnyInternalModule,
+  ISequencer
+> {
+  static moduleName = "Sequencer";
+  midiOutput: Output;
+  private part: Part<number>;
+  private barParts: Part<ISequence>[] = [];
+
+  constructor(name: string, props: Partial<ISequencer>) {
+    super(new DummnyInternalModule(), {
+      name,
+      props: { ...InitialProps(), ...props },
+    });
+
+    this.initializePart();
+    this.start();
+    this.registerOutputs();
+  }
+
+  get length() {
+    return this._props["length"];
+  }
+
+  set length(value: number) {
+    this._props["length"] = value;
+    this.adjustNumberOfSequences();
+    this.updateBarParts();
+  }
+
+  get bars() {
+    return this.props["bars"];
+  }
+
+  set bars(value: number) {
+    this._props["bars"] = value;
+    this.adjustNumberOfBars();
+    this.adjustNumberOfSequences();
+    this.updateBarParts();
+  }
+
+  get sequences() {
+    return this._props["sequences"];
+  }
+
+  set sequences(value: ISequence[][]) {
+    const sequences = value;
+    this._props = { ...this.props, sequences };
+    this.updateBarParts();
+  }
+
+  start() {
+    this.part.start();
+  }
+
+  stop() {
+    this.part.stop();
+  }
+
+  private registerOutputs() {
+    this.midiOutput = this.registerOutput({ name: "midi out" });
+  }
+
+  private initializePart() {
+    this.part = new Part(this.onPartEvent, [] as number[]);
+    this.part.loop = true;
+    this.part.loopEnd = this.loopEnd;
+
+    this.sequences.forEach((_, i) => {
+      this.part.add(`${i}:0:0`, i);
+    });
+  }
+
+  private adjustNumberOfBars() {
+    const currentBar = this.sequences.length;
+    const num = currentBar - this.bars;
+
+    if (num === 0) return;
+
+    if (num > 0) {
+      this.part?.remove(`${currentBar}:0:0`);
+      this.sequences.pop();
+    } else {
+      this.part?.add(`${currentBar}:0:0`, currentBar);
+      this.sequences.push([]);
+    }
+
+    this.adjustNumberOfBars();
+  }
+
+  private adjustNumberOfSequences(bar = 0) {
+    if (!this.bars) return;
+
+    const sequences = this.sequences[bar];
+    const num = sequences.length - this.length;
+
+    if (num === 0) {
+      if (bar === this.bars - 1) return;
+
+      this.adjustNumberOfSequences(bar + 1);
+      return;
+    }
+
+    if (num > 0) {
+      sequences.pop();
+    } else {
+      const index = sequences.length;
+      sequences.push({ active: false, time: `${bar}:0:${index}`, notes: [] });
+    }
+
+    this.adjustNumberOfSequences(bar);
+  }
+
+  private updateBarParts() {
+    this.barParts = this.sequences.map((barSeqs, bar) => {
+      const part = new Part(this.onSequenceEvent, [] as Array<ISequence>);
+      barSeqs.forEach((seq) => part.add(seq.time, seq));
+
+      return part;
+    });
+  }
+
+  private get loopEnd() {
+    return `${this.bars}:0:0`;
+  }
+
+  private onPartEvent = (time: number, bar: number | null) => {
+    if (bar === null) return;
+
+    const part = this.barParts[bar];
+    if (!part) return;
+
+    part.start(time);
+    part.stop(time + Time("1m").toSeconds());
+  };
+
+  private onSequenceEvent = (time: number, sequence: ISequence) => {
+    if (!sequence.active) return;
+
+    const event = MidiEvent.fromSequence(sequence, time);
+
+    this.midiOutput.connections.forEach((input) => {
+      input.pluggable(event);
+    });
+  };
+}

package/src/Module/VirtualMidi.ts

@@ -1,5 +1,6 @@
 import Engine from "../Engine";
 import MidiEvent from "../MidiEvent";
+import Note from "../Note";
 import Module, { DummnyInternalModule } from "./Base";
 import { Output } from "./IO";
 
@@ -38,27 +39,22 @@ export default class VirtualMidi extends Module<
   }
 
   sendMidi(midiEvent: MidiEvent) {
-    this.midiTriggered(midiEvent);
     this.midiOutput.connections.forEach((input) => {
       input.pluggable(midiEvent);
     });
   }
 
-  triggerAttack(midiEvent: MidiEvent) {
-    if (!midiEvent.note) return;
-
-    this.activeNotes = [...this.activeNotes, midiEvent.note.fullName];
+  triggerAttack = (note: Note) => {
+    this.activeNotes = [...this.activeNotes, note.fullName];
     Engine._triggerPropsUpdate(this.id, this.props);
-  }
-
-  triggerRelease(midiEvent: MidiEvent) {
-    if (!midiEvent.note) return;
+  };
 
+  triggerRelease = (note: Note) => {
     this.activeNotes = this.activeNotes.filter(
-      (name) => name !== midiEvent.note!.fullName
+      (name) => name !== note.fullName
     );
     Engine._triggerPropsUpdate(this.id, this.props);
-  }
+  };
 
   serialize() {
     return {

package/src/Module/VoiceScheduler.ts

@@ -43,27 +43,31 @@ export default class VoiceScheduler extends PolyModule<
   }
 
   midiTriggered = (midiEvent: MidiEvent) => {
-    let voice: Voice | undefined;
+    let voices: Array<Voice | undefined>;
 
     switch (midiEvent.type) {
       case "noteOn":
-        voice = this.findFreeVoice();
+        voices = this.findFreeVoices(midiEvent.notes.length);
 
         break;
       case "noteOff":
-        voice = this.audioModules.find(
-          (v) => v.activeNote === midiEvent.note?.fullName
-        );
+        voices = midiEvent.notes.map((note) => {
+          return this.audioModules.find((v) => v.activeNote === note.fullName);
+        });
         break;
       default:
         throw Error("This type is not a note");
     }
 
-    if (voice === undefined) return;
+    if (voices.length === 0) return;
 
-    voice.midiTriggered(midiEvent);
-    this.midiOutput.connections.forEach((input) => {
-      input.pluggable(midiEvent, voice?.voiceNo);
+    voices.forEach((voice, i) => {
+      if (!voice) return;
+
+      voice.midiTriggered(midiEvent, i);
+      this.midiOutput.connections.forEach((input) => {
+        input.pluggable(midiEvent, voice.voiceNo, i);
+      });
     });
   };
 
@@ -77,18 +81,20 @@ export default class VoiceScheduler extends PolyModule<
     };
   }
 
-  private findFreeVoice(): Voice {
-    let voice = this.audioModules.find((v) => !v.activeNote);
+  private findFreeVoices(num: number = 1): Voice[] {
+    let voices = this.audioModules.filter((v) => !v.activeNote).slice(0, num);
 
-    if (!voice) {
-      voice = this.audioModules.sort((a, b) => {
-        if (!a || !b) return 0;
+    if (voices.length === 0) {
+      voices = this.audioModules
+        .sort((a, b) => {
+          if (!a || !b) return 0;
 
-        return a.triggeredAt - b.triggeredAt;
-      })[0];
+          return a.triggeredAt - b.triggeredAt;
+        })
+        .slice(0, num);
     }
 
-    return voice;
+    return voices;
   }
 
   private registerInputs() {
@@ -127,10 +133,14 @@ class Voice extends Module<DummnyInternalModule, VoiceInterface> {
     });
   }
 
-  midiTriggered = (midiEvent: MidiEvent) => {
-    const { triggeredAt, note, type } = midiEvent;
+  midiTriggered = (midiEvent: MidiEvent, noteIndex?: number) => {
+    if (this.voiceNo === undefined) throw Error("Voice without voiceNo");
+    if (noteIndex === undefined) return;
+
+    const { triggeredAt, notes, type } = midiEvent;
+    const note = notes[noteIndex];
 
-    if (!note) throw Error("No valid note on this event");
+    if (!note) return;
     const noteName = note.fullName;
 
     switch (type) {

package/src/Module/index.ts

@@ -13,6 +13,7 @@ import Reverb from "./Reverb";
 import Delay from "./Delay";
 import Distortion from "./Distortion";
 import BitCrusher from "./BitCrusher";
+import Sequencer from "./Sequencer";
 
 export { default } from "./Base";
 export { default as PolyModule } from "./PolyModule";
@@ -20,6 +21,9 @@ export type { ModuleInterface, Connectable, Triggerable } from "./Base";
 
 export { default as Filter } from "./Filter";
 export { default as Oscillator } from "./Oscillator";
+export { default as Sequencer } from "./Sequencer";
+export type { ISequence } from "./Sequencer";
+
 export {
   Envelope,
   AmpEnvelope,
@@ -73,6 +77,8 @@ function moduleClassFromType(type: string) {
       return Distortion;
     case BitCrusher.moduleName:
       return BitCrusher;
+    case Sequencer.moduleName:
+      return Sequencer;
     default:
       throw Error(`Unknown module type ${type}`);
   }

package/src/Note/index.ts

@@ -4,16 +4,26 @@ const Notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
 
 const NotesLength = Notes.length;
 
+export interface INote {
+  note: string;
+  duration: string;
+  velocity?: number;
+}
+
 export default class Note {
   static _notes: Note[];
   name: string;
   octave: number;
+  velocity: number = 1;
+  duration: string;
 
-  constructor(eventOrString: MIDIMessageEvent | string) {
+  constructor(eventOrString: Partial<INote> | MIDIMessageEvent | string) {
     if (typeof eventOrString === "string") {
       this.fromString(eventOrString);
-    } else {
+    } else if (eventOrString instanceof MIDIMessageEvent) {
       this.fromEvent(eventOrString);
+    } else {
+      this.fromProps(eventOrString);
     }
   }
 
@@ -51,6 +61,14 @@ export default class Note {
     return this.fullName;
   }
 
+  serialize(): INote {
+    return {
+      note: this.fullName,
+      velocity: this.velocity,
+      duration: this.duration,
+    };
+  }
+
   private fromString(string: string) {
     const matches = string.match(/(\w#?)(\d)?/) || [];
 
@@ -62,4 +80,11 @@ export default class Note {
     this.name = Notes[event.data[1] % 12];
     this.octave = Math.floor(event.data[1] / 12) - 2;
   }
+
+  private fromProps(props: Partial<INote>) {
+    Object.assign(this, props);
+    if (!props.note) throw Error("note props is mandatory");
+
+    this.fromString(props.note);
+  }
 }

package/src/index.ts

@@ -3,7 +3,8 @@ export { default as MidiDevice } from "./MidiDevice";
 export { default as MidiDeviceManager } from "./MidiDeviceManager";
 export { default as Note } from "./Note";
 
+export type { INote } from "./Note";
 export type { MidiDeviceInterface } from "./MidiDevice";
-export type { ModuleInterface, AudioModule } from "./Module";
+export type { ModuleInterface, AudioModule, ISequence } from "./Module";
 
 export type { SerializeInterface as IOProps } from "./Module/IO";