@blibliki/engine 0.1.4 → 0.1.6

package/src/Module/Filter.ts

@@ -1,12 +1,12 @@
 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";
+import { FreqEnvelope, MonoFreqEnvelope } from "./Envelope";
+import Module, { Voicable } from "./Base";
+import PolyModule from "./PolyModule";
 
-interface FilterInterface {
+interface FilterInterface extends Voicable {
   cutoff: number;
+  filterType: BiquadFilterType;
   resonance: number;
   envelopeAmount: number;
   voiceNo?: number;
@@ -18,16 +18,16 @@ const InitialProps: FilterInterface = {
   cutoff: 20000,
   resonance: 0,
   envelopeAmount: 0,
+  filterType: "lowpass",
 };
 
-export default class Filter extends Module<InternalFilter, FilterInterface> {
-  private _envelope: FreqEnvelope;
+class MonoFilter extends Module<InternalFilter, FilterInterface> {
+  private _envelope: MonoFreqEnvelope;
 
   constructor(name: string, props: FilterProps) {
     super(new InternalFilter({ type: "lowpass" }), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Filter,
     });
   }
 
@@ -71,19 +71,19 @@ export default class Filter extends Module<InternalFilter, FilterInterface> {
     this._envelope.amount = value;
   }
 
-  conntectedEnvelope(envelope: FreqEnvelope) {
+  conntectedEnvelope(envelope: MonoFreqEnvelope) {
     this._envelope = envelope;
     this._envelope.frequency = this.cutoff;
     this._envelope.amount = this.envelopeAmount;
   }
 }
 
-export class PolyFilter extends PolyModule<Filter, FilterInterface> {
+export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
   constructor(name: string, props: Partial<FilterInterface>) {
-    super(PolyModuleType.Filter, {
+    super({
       name,
+      child: MonoFilter,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Filter,
     });
 
     this.registerBasicInputs();
@@ -96,13 +96,13 @@ export class PolyFilter extends PolyModule<Filter, FilterInterface> {
       name: "frequency",
       pluggable: "frequency",
       onPlug: (output) => {
-        this.conntectedEnvelope(output.audioModule as PolyFreqEnvelope);
+        this.conntectedEnvelope(output.audioModule as FreqEnvelope);
       },
     });
   }
 
-  conntectedEnvelope(polyFreqEnvelope: PolyFreqEnvelope) {
-    polyFreqEnvelope.audioModules.forEach((envelope) => {
+  conntectedEnvelope(freqEnvelope: FreqEnvelope) {
+    freqEnvelope.audioModules.forEach((envelope) => {
       if (envelope.voiceNo === undefined) return;
 
       const filter = this.findVoice(envelope.voiceNo);

package/src/Module/Master.ts

@@ -1,5 +1,5 @@
 import { Destination, getDestination } from "tone";
-import Module, { ModuleType } from "../Module";
+import Module from "./Base";
 
 export interface MasterInterface {}
 
@@ -10,7 +10,6 @@ export default class Master extends Module<
   constructor() {
     super(getDestination(), {
       name: "Master",
-      type: ModuleType.Master,
     });
 
     this.registerBasicInputs();

package/src/Module/MidiSelector.ts

@@ -1,6 +1,6 @@
 import Engine from "../Engine";
 import MidiEvent from "../MidiEvent";
-import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import Module, { DummnyInternalModule } from "./Base";
 import { Output } from "./IO";
 
 export interface MidiSelectorInterface {
@@ -21,7 +21,6 @@ export default class MidiSelector extends Module<
     super(new DummnyInternalModule(), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.MidiSelector,
     });
 
     this.registerOutputs();
@@ -33,16 +32,18 @@ export default class MidiSelector extends Module<
   }
 
   set selectedId(value: string | null) {
-    if (this.selectedId) {
-      const prevMidiDevice = Engine.midiDeviceManager.find(this.selectedId);
-      prevMidiDevice?.removeEventListener(this.onMidiEvent);
-    }
+    this.removeEventListener();
 
     this._props = { ...this.props, selectedId: value };
 
     this.addEventListener(value);
   }
 
+  dispose() {
+    this.removeEventListener();
+    super.dispose();
+  }
+
   private registerOutputs() {
     this.midiOutput = this.registerOutput({ name: "midi out" });
   }
@@ -59,4 +60,11 @@ export default class MidiSelector extends Module<
     const midiDevice = Engine.midiDeviceManager.find(midiId);
     midiDevice?.addEventListener(this.onMidiEvent);
   }
+
+  private removeEventListener() {
+    if (!this.selectedId) return;
+
+    const midiDevice = Engine.midiDeviceManager.find(this.selectedId);
+    midiDevice?.removeEventListener(this.onMidiEvent);
+  }
 }

package/src/Module/Oscillator.ts

@@ -1,18 +1,17 @@
 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";
+import Module, { Voicable } from "./Base";
+import PolyModule from "./PolyModule";
 
-export interface OscillatorInterface {
+export interface OscillatorInterface extends Voicable {
   noteName: string;
   fine: number;
   coarse: number;
   wave: string;
   volume: number;
   range: number;
-  voiceNo?: number;
 }
 
 const InitialProps: OscillatorInterface = {
@@ -24,14 +23,13 @@ const InitialProps: OscillatorInterface = {
   volume: 0,
 };
 
-export default class Oscillator extends Module<Osc, OscillatorInterface> {
+class MonoOscillator 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");
@@ -142,15 +140,15 @@ export default class Oscillator extends Module<Osc, OscillatorInterface> {
   }
 }
 
-export class PolyOscillator extends PolyModule<
-  Oscillator,
+export default class Oscillator extends PolyModule<
+  MonoOscillator,
   OscillatorInterface
 > {
   constructor(name: string, props: Partial<OscillatorInterface>) {
-    super(PolyModuleType.Oscillator, {
+    super({
       name,
+      child: MonoOscillator,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Oscillator,
     });
 
     this.registerBasicOutputs();

package/src/Module/PolyModule.ts

@@ -1,42 +1,33 @@
 import MidiEvent from "../MidiEvent";
 import { v4 as uuidv4 } from "uuid";
-import { createModule } from ".";
-import Module, { ModuleInterface, ModuleType, Connectable } from "./Base";
+import Module, { Connectable, Voicable } 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<MonoAudioModule, PropsInterface> {
+  name: string;
+  child: new (name: string, props: PropsInterface) => MonoAudioModule;
+  props: PropsInterface;
 }
 
-interface PolyModuleInterface extends ModuleInterface {}
-
 export default abstract class PolyModule<
   MonoAudioModule extends Module<Connectable, any>,
-  PropsInterface
+  PropsInterface extends Voicable
 > {
   readonly id: string;
+  readonly child: new (name: string, props: PropsInterface) => MonoAudioModule;
   _name: string;
   audioModules: MonoAudioModule[];
   inputs: Input[] = [];
   outputs: Output[] = [];
-  readonly _type: PolyModuleType;
-  readonly childrenType: ModuleType;
   private _numberOfVoices: number;
 
-  constructor(type: PolyModuleType, props: PolyModuleInterface) {
+  constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>) {
     this.id = uuidv4();
-    this._type = type;
-    this.childrenType = props.type;
     this.audioModules = [];
 
-    const { props: extraProps, ...basicProps } = props;
+    const { child, props: extraProps, ...basicProps } = params;
+    this.child = child;
     Object.assign(this, basicProps);
 
     this.numberOfVoices = 1;
@@ -45,10 +36,6 @@ export default abstract class PolyModule<
     this.registerNumberOfVoicesInput();
   }
 
-  get type() {
-    return this._type;
-  }
-
   get name() {
     return this._name;
   }
@@ -58,10 +45,6 @@ export default abstract class PolyModule<
     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");
@@ -117,7 +100,7 @@ export default abstract class PolyModule<
     return {
       ...this.audioModules[0].serialize(),
       id: this.id,
-      type: this.type,
+      type: this.constructor.name,
       inputs: this.inputs.map((i) => i.serialize()),
       outputs: this.outputs.map((i) => i.serialize()),
     };
@@ -224,8 +207,10 @@ export default abstract class PolyModule<
       const audioModule = this.audioModules.pop();
       audioModule?.dispose();
     } else {
-      const props = this.audioModules.length ? this.props : {};
-      const audioModule = createModule(this.name, this.childrenType, {
+      const props = this.audioModules.length
+        ? this.props
+        : ({} as PropsInterface);
+      const audioModule = new this.child(this.name, {
         ...props,
         voiceNo: this.audioModules.length,
       });

package/src/Module/Reverb.ts

@@ -0,0 +1,40 @@
+import { Reverb as InternalReverb } from "tone";
+
+import Effect, { EffectInterface } from "./Effect";
+
+interface ReverbInterface extends EffectInterface {
+  decay: number;
+  preDelay: number;
+}
+
+const InitialProps: Partial<ReverbInterface> = {
+  decay: 1.5,
+  preDelay: 0.025,
+};
+
+export default class Reverb extends Effect<InternalReverb, ReverbInterface> {
+  constructor(name: string, props: Partial<ReverbInterface>) {
+    super(name, new InternalReverb(), {
+      ...InitialProps,
+      ...props,
+    });
+  }
+
+  get decay() {
+    return this._props["decay"];
+  }
+
+  set decay(value: number) {
+    this._props = { ...this.props, decay: value };
+    this.internalModule.decay = this.decay;
+  }
+
+  get preDelay() {
+    return this._props["preDelay"];
+  }
+
+  set preDelay(value: number) {
+    this._props = { ...this.props, preDelay: value };
+    this.internalModule.preDelay = this.preDelay;
+  }
+}

package/src/Module/VirtualMidi.ts

@@ -1,6 +1,6 @@
 import Engine from "../Engine";
 import MidiEvent from "../MidiEvent";
-import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import Module, { DummnyInternalModule } from "./Base";
 import { Output } from "./IO";
 
 export interface VirtualMidiInterface {
@@ -21,7 +21,6 @@ export default class VirtualMidi extends Module<
     super(new DummnyInternalModule(), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.VirtualMidi,
     });
 
     this.registerInputs();

package/src/Module/VoiceScheduler.ts

@@ -1,9 +1,9 @@
-import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import Module, { DummnyInternalModule, Voicable } from "./Base";
 import MidiEvent from "../MidiEvent";
 import { Input, Output } from "./IO";
-import PolyModule, { PolyModuleType } from "./PolyModule";
+import PolyModule from "./PolyModule";
 
-export interface VoiceSchedulerInterface {
+export interface VoiceSchedulerInterface extends Voicable {
   polyNumber: number;
 }
 
@@ -15,10 +15,10 @@ export default class VoiceScheduler extends PolyModule<
   numberOfVoicesOut: Output;
 
   constructor(name: string, props: VoiceSchedulerInterface) {
-    super(PolyModuleType.VoiceScheduler, {
+    super({
       name,
+      child: Voice,
       props,
-      type: ModuleType.Voice,
     });
 
     this.registerInputs();
@@ -111,11 +111,9 @@ export default class VoiceScheduler extends PolyModule<
   }
 }
 
-export interface VoiceInterface {
-  voiceNo?: number;
-}
+export interface VoiceInterface extends Voicable {}
 
-export class Voice extends Module<DummnyInternalModule, VoiceInterface> {
+class Voice extends Module<DummnyInternalModule, VoiceInterface> {
   midiEvent: MidiEvent | null;
   activeNote: string | null;
   triggeredAt: number;
@@ -124,7 +122,6 @@ export class Voice extends Module<DummnyInternalModule, VoiceInterface> {
   constructor(name: string, props: VoiceInterface) {
     super(new DummnyInternalModule(), {
       name,
-      type: ModuleType.Voice,
       props,
     });
   }

package/src/Module/Volume.ts

@@ -1,23 +1,21 @@
 import { Volume as Vol } from "tone";
 
-import Module, { ModuleType } from "../Module";
-import PolyModule, { PolyModuleType } from "./PolyModule";
+import Module, { Voicable } from "./Base";
+import PolyModule from "./PolyModule";
 
-export interface VolumeInterface {
+export interface VolumeInterface extends Voicable {
   volume: number;
-  voiceNo?: number;
 }
 
 const InitialProps: VolumeInterface = {
   volume: -100,
 };
 
-export default class Volume extends Module<Vol, VolumeInterface> {
+class MonoVolume extends Module<Vol, VolumeInterface> {
   constructor(name: string, props: Partial<VolumeInterface>) {
     super(new Vol(), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Volume,
     });
   }
 
@@ -32,12 +30,12 @@ export default class Volume extends Module<Vol, VolumeInterface> {
   }
 }
 
-export class PolyVolume extends PolyModule<Volume, VolumeInterface> {
+export default class Volume extends PolyModule<MonoVolume, VolumeInterface> {
   constructor(name: string, props: Partial<VolumeInterface>) {
-    super(PolyModuleType.Volume, {
+    super({
       name,
+      child: MonoVolume,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Volume,
     });
 
     this.registerBasicInputs();

package/src/Module/index.ts

@@ -1,19 +1,21 @@
-import Module, { Connectable, ModuleType } from "./Base";
-import PolyModule, { PolyModuleType } from "./PolyModule";
-import Oscillator, { PolyOscillator } from "./Oscillator";
+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 Filter, { PolyFilter } from "./Filter";
+import Filter from "./Filter";
 import Master from "./Master";
-import VoiceScheduler, { Voice } from "./VoiceScheduler";
+import VoiceScheduler from "./VoiceScheduler";
 import MidiSelector from "./MidiSelector";
-import { PolyAmpEnvelope } from "./Envelope/AmpEnvelope";
-import { PolyFreqEnvelope } from "./Envelope/FreqEnvelope";
-import { PolyEnvelope } from "./Envelope/Base";
-import Volume, { PolyVolume } from "./Volume";
+import Volume from "./Volume";
 import VirtualMidi from "./VirtualMidi";
+import Reverb from "./Reverb";
+import Delay from "./Delay";
+import Distortion from "./Distortion";
+import BitCrusher from "./BitCrusher";
 
-export { default, ModuleType } from "./Base";
-export { default as PolyModule, PolyModuleType } from "./PolyModule";
+export { default } from "./Base";
+export { default as PolyModule } from "./PolyModule";
 export type { ModuleInterface, Connectable, Triggerable } from "./Base";
 
 export { default as Filter } from "./Filter";
@@ -39,43 +41,39 @@ export function createModule(
   return new klass(name, props);
 }
 
-export function moduleClassFromType(type: string) {
+function moduleClassFromType(type: string) {
+  type = upperFirst(camelCase(type));
+
   switch (type) {
-    case ModuleType.Oscillator:
+    case Oscillator.name:
       return Oscillator;
-    case ModuleType.Envelope:
+    case Envelope.name:
       return Envelope;
-    case ModuleType.AmpEnvelope:
+    case AmpEnvelope.name:
       return AmpEnvelope;
-    case ModuleType.FreqEnvelope:
+    case FreqEnvelope.name:
       return FreqEnvelope;
-    case ModuleType.Filter:
+    case Filter.name:
       return Filter;
-    case ModuleType.Volume:
+    case Volume.name:
       return Volume;
-    case PolyModuleType.Oscillator:
-      return PolyOscillator;
-    case PolyModuleType.Envelope:
-      return PolyEnvelope;
-    case PolyModuleType.AmpEnvelope:
-      return PolyAmpEnvelope;
-    case PolyModuleType.FreqEnvelope:
-      return PolyFreqEnvelope;
-    case PolyModuleType.Filter:
-      return PolyFilter;
-    case PolyModuleType.Volume:
-      return PolyVolume;
-    case ModuleType.Master:
+    case Master.name:
       return Master;
-    case ModuleType.Voice:
-      return Voice;
-    case PolyModuleType.VoiceScheduler:
+    case VoiceScheduler.name:
       return VoiceScheduler;
-    case ModuleType.MidiSelector:
+    case MidiSelector.name:
       return MidiSelector;
-    case ModuleType.VirtualMidi:
+    case VirtualMidi.name:
       return VirtualMidi;
+    case Reverb.name:
+      return Reverb;
+    case Delay.name:
+      return Delay;
+    case Distortion.name:
+      return Distortion;
+    case BitCrusher.name:
+      return BitCrusher;
     default:
-      throw Error("Unknown module type");
+      throw Error(`Unknown module type ${type}`);
   }
 }

package/src/index.ts

@@ -1,5 +1,4 @@
 export { default } from "./Engine";
-export { ModuleType, PolyModuleType } from "./Module";
 export { default as MidiDevice } from "./MidiDevice";
 export { default as MidiDeviceManager } from "./MidiDeviceManager";
 export { default as Note } from "./Note";

package/src/routes.ts

@@ -22,16 +22,23 @@ export function createRoute(props: RouteProps) {
 export function applyRoutes(routes: RouteInterface[]) {
   Object.values(Engine.modules).forEach((m) => m.unplugAll());
 
-  const succesedConnections = routes.map((route) => {
-    const { sourceId, outputName, destinationId, inputName } = route;
+  const succesedConnections = routes
+    .sort((r1, r2) => {
+      if (r1.outputName === "number of voices") return -1;
+      if (r2.outputName === "number of voices") return 1;
 
-    const source = Engine.findById(sourceId);
-    const destination = Engine.findById(destinationId);
+      return 0;
+    })
+    .map((route) => {
+      const { sourceId, outputName, destinationId, inputName } = route;
 
-    source.plug(destination, outputName, inputName);
+      const source = Engine.findById(sourceId);
+      const destination = Engine.findById(destinationId);
 
-    return true;
-  });
+      source.plug(destination, outputName, inputName);
+
+      return true;
+    });
 
   if (succesedConnections.every((v) => v)) {
     console.log("######## Routes succesfully applied");