@blibliki/engine 0.1.9 → 0.1.10

package/src/Module/Sequencer.ts

@@ -1,16 +1,25 @@
-import { Part } from "tone";
+import { Part, Time } from "tone";
 import Module, { DummnyInternalModule } from "./Base";
-import Note, { INote } from "../Note";
+import { INote } from "../Note";
 import { Output } from "./IO";
 import MidiEvent from "../MidiEvent";
 
-interface ISequencer {
+export interface ISequence {
+  active: boolean;
+  time: string;
   notes: INote[];
 }
+interface ISequencer {
+  sequences: ISequence[][];
+  length: number;
+  bars: number;
+}
 
-const InitialProps: ISequencer = {
-  notes: [],
-};
+const InitialProps = () => ({
+  sequences: [],
+  length: 16,
+  bars: 1,
+});
 
 export default class Sequencer extends Module<
   DummnyInternalModule,
@@ -18,26 +27,49 @@ export default class Sequencer extends Module<
 > {
   static moduleName = "Sequencer";
   midiOutput: Output;
-  private _part: Part;
+  private part: Part<number>;
+  private barParts: Part<ISequence>[] = [];
 
   constructor(name: string, props: Partial<ISequencer>) {
     super(new DummnyInternalModule(), {
       name,
-      props: { ...InitialProps, ...props },
+      props: { ...InitialProps(), ...props },
     });
 
-    this.registerOutputs();
+    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 notes() {
-    return this._props["notes"];
+  get sequences() {
+    return this._props["sequences"];
   }
 
-  set notes(value: INote[]) {
-    const notes = value;
-    this._props = { ...this.props, notes };
-    this.updateNotesToPart();
+  set sequences(value: ISequence[][]) {
+    const sequences = value;
+    this._props = { ...this.props, sequences };
+    this.updateBarParts();
   }
 
   start() {
@@ -52,35 +84,83 @@ export default class Sequencer extends Module<
     this.midiOutput = this.registerOutput({ name: "midi out" });
   }
 
-  private get part() {
-    if (this._part) return this._part;
+  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);
+    });
+  }
 
-    this._part = new Part(this.onEvent, this.notes);
-    this._part.loop = true;
-    this._part.loopEnd = this.loopEnd;
+  private adjustNumberOfBars() {
+    const currentBar = this.sequences.length;
+    const num = currentBar - this.bars;
 
-    return this._part;
+    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 updateNotesToPart() {
-    this.part.clear();
+  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);
+  }
 
-    this.notes.forEach((note) => {
-      this.part.add(note.time, note);
+  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() {
-    const end =
-      Math.max(
-        ...this.notes.map((note) => parseInt(note.time.split(":")[0], 10))
-      ) + 1;
-
-    return `${end}:0:0`;
+    return `${this.bars}:0:0`;
   }
 
-  private onEvent = (time: number, note: INote) => {
-    const event = MidiEvent.fromNote(note, "noteOn", time);
+  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

@@ -21,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,

package/src/Note/index.ts

@@ -1,5 +1,3 @@
-import { TimeClass, Time } from "tone";
-import MidiEvent from "../MidiEvent";
 import frequencyTable from "./frequencyTable";
 
 const Notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
@@ -8,25 +6,18 @@ const NotesLength = Notes.length;
 
 export interface INote {
   note: string;
-  time: string;
+  duration: string;
   velocity?: number;
-  duration?: string;
 }
 
 export default class Note {
   static _notes: Note[];
   name: string;
   octave: number;
-  time: TimeClass = Time("0:0:0");
-  velocity?: number = 1;
-  duration?: string;
-
-  constructor(
-    eventOrString: INote | MIDIMessageEvent | string,
-    duration?: string
-  ) {
-    this.duration = duration;
+  velocity: number = 1;
+  duration: string;
 
+  constructor(eventOrString: Partial<INote> | MIDIMessageEvent | string) {
     if (typeof eventOrString === "string") {
       this.fromString(eventOrString);
     } else if (eventOrString instanceof MIDIMessageEvent) {
@@ -72,10 +63,9 @@ export default class Note {
 
   serialize(): INote {
     return {
-      time: this.time.toBarsBeatsSixteenths(),
       note: this.fullName,
+      velocity: this.velocity,
       duration: this.duration,
-      velocity: 1,
     };
   }
 
@@ -91,12 +81,10 @@ export default class Note {
     this.octave = Math.floor(event.data[1] / 12) - 2;
   }
 
-  private fromProps(props: INote) {
-    const { note, time, duration, velocity } = props;
+  private fromProps(props: Partial<INote>) {
+    Object.assign(this, props);
+    if (!props.note) throw Error("note props is mandatory");
 
-    this.fromString(note);
-    this.time = Time(time);
-    this.duration = duration;
-    this.velocity = velocity;
+    this.fromString(props.note);
   }
 }

package/src/index.ts

@@ -5,6 +5,6 @@ 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";