@blibliki/engine 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "source": "src/index.ts",
   "main": "dist/main.cjs.js",
   "module": "dist/main.esm.js",

package/src/core/IO/ForwardNode.ts

@@ -42,7 +42,8 @@ export class ForwardInput extends IONode implements IForwardInput {
   }
 
   subModule(voiceNo: number) {
-    const mod = this.subModules.find((m) => m.voiceNo === voiceNo);
+    const adjustedVoiceNo = voiceNo % this.subModules.length;
+    const mod = this.subModules.find((m) => m.voiceNo === adjustedVoiceNo);
     if (!mod) throw Error(`Submodule with voiceNo ${voiceNo} not found`);
 
     return mod;
@@ -129,7 +130,8 @@ export class ForwardOutput extends IONode implements IForwardOutput {
   }
 
   subModule(voiceNo: number) {
-    const mod = this.subModules.find((m) => m.voiceNo === voiceNo);
+    const adjustedVoiceNo = voiceNo % this.subModules.length;
+    const mod = this.subModules.find((m) => m.voiceNo === adjustedVoiceNo);
     if (!mod) throw Error(`Submodule with voiceNo ${voiceNo} not found`);
 
     return mod;

package/src/modules/Filter.ts

@@ -34,7 +34,7 @@ class MonoFilter extends Module<InternalFilter, FilterInterface> {
       props: { ...InitialProps, ...props },
     });
 
-    this._cutoff = new Add(this.cutoff);
+    this._cutoff = new Add();
     this._cutoff.connect(this.internalModule.frequency);
 
     this._amount = new Multiply();

package/src/modules/LFO.ts

@@ -0,0 +1,150 @@
+import { now, LFO as LFOInternal, ToneOscillatorType } from "tone";
+import Engine from "../Engine";
+import Module, { PolyModule, Startable } from "../core/Module";
+import { TWave } from "./Oscillator";
+import Note from "../core/Note";
+
+export interface LFOInterface {
+  wave: TWave;
+  frequency: number;
+  min: number;
+  max: number;
+  amount: number;
+}
+
+const InitialProps: LFOInterface = {
+  wave: "sine",
+  frequency: 0.1,
+  min: 0,
+  max: 1,
+  amount: 1,
+};
+
+class MonoLFO extends Module<LFOInternal, LFOInterface> implements Startable {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<LFOInterface>;
+  }) {
+    const { id, name, props } = params;
+
+    super(new LFOInternal(), {
+      id,
+      name,
+      props: { ...InitialProps, ...props },
+    });
+
+    this.registerBasicOutputs();
+    this.registerInputs();
+    this.start(now());
+  }
+
+  get wave() {
+    return this._props["wave"];
+  }
+
+  set wave(value: TWave) {
+    this._props = { ...this.props, wave: value };
+    this.internalModule.type = this.wave as ToneOscillatorType;
+  }
+
+  get min() {
+    return this._props["min"];
+  }
+
+  set min(value: number) {
+    this._props = { ...this.props, min: value };
+    this.internalModule.min = this.min;
+  }
+
+  get max() {
+    return this._props["max"];
+  }
+
+  set max(value: number) {
+    this._props = { ...this.props, max: value };
+    this.internalModule.max = this.max;
+  }
+
+  get frequency() {
+    return this._props["frequency"];
+  }
+
+  set frequency(value: number) {
+    this._props = { ...this.props, frequency: value };
+    this.internalModule.frequency.value = this.frequency;
+  }
+
+  get amount() {
+    return this._props["amount"];
+  }
+
+  set amount(value: number) {
+    this._props = { ...this.props, amount: value };
+    this.internalModule.amplitude.value = this.amount;
+  }
+
+  start(time: number) {
+    if (!Engine.isStarted) return;
+
+    const oscState = this.internalModule.state;
+
+    if (oscState === "started") {
+      this.internalModule.stop(time - 2);
+      this.internalModule.start(time);
+    } else {
+      this.internalModule.start(time);
+    }
+  }
+
+  stop(time?: number) {
+    this.internalModule.stop(time);
+  }
+
+  triggerAttack = (_: Note, triggeredAt: number) => {
+    this.start(triggeredAt);
+  };
+
+  triggerRelease = () => {
+    // Do nothing
+  };
+
+  private registerInputs() {
+    this.registerDefaultMidiInput();
+    this.registerAudioInput({
+      name: "amount",
+      internalModule: this.internalModule.amplitude,
+    });
+  }
+}
+
+export default class LFO extends PolyModule<MonoLFO, LFOInterface> {
+  static moduleName = "LFO";
+
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<LFOInterface>;
+  }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      child: MonoLFO,
+      props: { ...InitialProps, ...props },
+    });
+
+    this.registerBasicOutputs();
+    this.registerInput({ name: "midi in" });
+    this.registerInput({ name: "amount" });
+  }
+
+  start(time: number) {
+    this.audioModules.forEach((audioModule) => audioModule.start(time));
+  }
+
+  stop(time?: number) {
+    this.audioModules.forEach((audioModule) => audioModule.stop(time));
+  }
+}

package/src/modules/Oscillator.ts

@@ -1,14 +1,16 @@
-import { now, Oscillator as Osc, ToneOscillatorType } from "tone";
+import { Multiply, now, Oscillator as Osc, ToneOscillatorType } from "tone";
 import Engine from "../Engine";
 
 import Note from "../core/Note";
 import Module, { PolyModule, Startable } from "../core/Module";
 
+export type TWave = "sine" | "triangle" | "square" | "sawtooth";
+
 export interface OscillatorInterface {
   noteName: string;
   fine: number;
   coarse: number;
-  wave: string;
+  wave: TWave;
   volume: number;
   range: number;
 }
@@ -27,6 +29,7 @@ class MonoOscillator
   implements Startable
 {
   private _note: Note;
+  private _fineSignal: Multiply;
 
   constructor(params: {
     id?: string;
@@ -41,8 +44,8 @@ class MonoOscillator
       props: { ...InitialProps, ...props },
     });
 
+    this.registerInputs();
     this.registerBasicOutputs();
-    this.registerDefaultMidiInput();
     this.start(now());
   }
 
@@ -69,13 +72,23 @@ class MonoOscillator
     this.note = new Note(this.noteName);
   }
 
+  get fineSingal() {
+    if (this._fineSignal) return this._fineSignal;
+
+    this._fineSignal = new Multiply(100);
+    this._fineSignal.connect(this.internalModule.detune);
+
+    return this._fineSignal;
+  }
+
   get fine() {
     return this._props["fine"];
   }
 
   set fine(value: number) {
-    this._props = { ...this.props, fine: Math.floor(value) };
-    this.internalModule.detune.value = this.fine;
+    this._props = { ...this.props, fine: value };
+
+    this.fineSingal.value = this.fine;
   }
 
   get coarse() {
@@ -92,7 +105,7 @@ class MonoOscillator
     return this._props["wave"];
   }
 
-  set wave(value: string) {
+  set wave(value: TWave) {
     this._props = { ...this.props, wave: value };
     this.internalModule.type = this.wave as ToneOscillatorType;
   }
@@ -156,6 +169,14 @@ class MonoOscillator
   private getNote(note: Note | string): Note {
     return note instanceof Note ? note : new Note(note);
   }
+
+  private registerInputs() {
+    this.registerDefaultMidiInput();
+    this.registerAudioInput({
+      name: "fine",
+      internalModule: this.fineSingal,
+    });
+  }
 }
 
 export default class Oscillator extends PolyModule<
@@ -180,6 +201,7 @@ export default class Oscillator extends PolyModule<
 
     this.registerBasicOutputs();
     this.registerInput({ name: "midi in" });
+    this.registerInput({ name: "fine" });
   }
 
   start(time: number) {

package/src/modules/index.ts

@@ -1,4 +1,3 @@
-import { camelCase, upperFirst } from "lodash";
 import { Envelope, AmpEnvelope, FreqEnvelope } from "./Envelope";
 import Oscillator from "./Oscillator";
 import Filter from "./Filter";
@@ -12,6 +11,7 @@ import Delay from "./Delay";
 import Distortion from "./Distortion";
 import BitCrusher from "./BitCrusher";
 import Sequencer from "./Sequencer";
+import LFO from "./LFO";
 import { AudioModule } from "../core/Module";
 
 export { default as Master } from "./Master";
@@ -45,8 +45,6 @@ export function createModule(params: ICreateModule): AudioModule {
 }
 
 function moduleClassFromType(type: string) {
-  type = upperFirst(camelCase(type));
-
   switch (type) {
     case Oscillator.moduleName:
       return Oscillator;
@@ -78,6 +76,8 @@ function moduleClassFromType(type: string) {
       return BitCrusher;
     case Sequencer.moduleName:
       return Sequencer;
+    case LFO.moduleName:
+      return LFO;
     default:
       throw Error(`Unknown module type ${type}`);
   }