@blibliki/engine 0.1.27 → 0.3.1

package/src/modules/Gain.ts

@@ -0,0 +1,78 @@
+import { IAnyAudioContext, IModule, Module } from "@/core";
+import { IModuleConstructor } from "@/core/module/Module";
+import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
+import { PropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
+
+export type IGain = IModule<ModuleType.Gain>;
+export type IGainProps = {
+  gain: number;
+};
+
+export const gainPropSchema: PropSchema<IGainProps> = {
+  gain: {
+    kind: "number",
+    min: 0,
+    max: Infinity,
+    step: 0.01,
+    label: "Gain",
+  },
+};
+
+const DEFAULT_PROPS: IGainProps = { gain: 1 };
+
+export class MonoGain extends Module<ModuleType.Gain> {
+  declare audioNode: GainNode;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.Gain>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      new GainNode(context);
+
+    super(engineId, {
+      ...params,
+      audioNodeConstructor,
+      props,
+    });
+
+    this.registerDefaultIOs();
+    this.registerAdditionalInputs();
+  }
+
+  protected onSetGain(value: IGainProps["gain"]) {
+    this.audioNode.gain.value = value;
+  }
+
+  private registerAdditionalInputs() {
+    this.registerAudioInput({
+      name: "gain",
+      getAudioNode: () => this.audioNode.gain,
+    });
+  }
+}
+
+export default class Gain extends PolyModule<ModuleType.Gain> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.Gain>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.Gain>,
+    ) => new MonoGain(engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
+    });
+
+    this.registerAdditionalInputs();
+    this.registerDefaultIOs();
+  }
+
+  private registerAdditionalInputs() {
+    this.registerAudioInput({ name: "gain" });
+  }
+}

package/src/modules/Inspector.ts

@@ -0,0 +1,59 @@
+import { IAnyAudioContext, IModule, Module } from "@/core";
+import { PropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
+
+export type IInspector = IModule<ModuleType.Inspector>;
+export type IInspectorProps = {
+  fftSize: number;
+};
+
+export const inspectorPropSchema: PropSchema<IInspectorProps> = {
+  fftSize: {
+    kind: "enum",
+    options: [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768],
+    label: "FFT size",
+  },
+};
+
+const DEFAULT_PROPS: IInspectorProps = { fftSize: 512 };
+
+export default class Inspector extends Module<ModuleType.Inspector> {
+  declare audioNode: AnalyserNode;
+  private _buffer?: Float32Array<ArrayBuffer>;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.Inspector>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      new AnalyserNode(context);
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
+
+    this.registerDefaultIOs("in");
+  }
+
+  protected onSetFftSize(value: number) {
+    this._buffer = new Float32Array(value);
+  }
+
+  get buffer() {
+    if (this._buffer) return this._buffer;
+
+    this._buffer = new Float32Array(this.props.fftSize);
+
+    return this._buffer;
+  }
+
+  getValue(): number {
+    return this.getValues()[0];
+  }
+
+  getValues(): Float32Array {
+    this.audioNode.getFloatTimeDomainData(this.buffer);
+
+    return this.buffer;
+  }
+}

package/src/modules/Master.ts

@@ -1,28 +1,25 @@
-import { Destination, getDestination } from "tone";
-import Module from "../core/Module";
+import { EmptyObject } from "@blibliki/utils";
+import { IAnyAudioContext, IModule, Module } from "@/core";
+import { PropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
 
-export interface MasterInterface {}
+export type IMaster = IModule<ModuleType.Master>;
+export type IMasterProps = EmptyObject;
 
-export default class Master extends Module<
-  typeof Destination,
-  MasterInterface
-> {
-  static moduleName = "Master";
+const DEFAULT_PROPS: IMasterProps = {};
 
-  constructor({ id }: { id?: string }) {
-    super(getDestination(), {
-      id,
-      name: "Master",
-    });
+export const masterPropSchema: PropSchema<IMasterProps> = {};
 
-    this.registerAudioInput({
-      name: "input",
-      internalModule: this.internalModule,
-    });
-  }
+export default class Master extends Module<ModuleType.Master> {
+  declare audioNode: AudioDestinationNode;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.Master>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: IAnyAudioContext) =>
+      context.destination;
+
+    super(engineId, { ...params, audioNodeConstructor, props });
 
-  dispose(): void {
-    this.inputs.unPlugAll();
-    this.outputs.unPlugAll();
+    this.registerDefaultIOs("in");
   }
 }

package/src/modules/MidiSelector.ts

@@ -1,75 +1,75 @@
-import Engine from "../Engine";
-import { MidiEvent } from "../core/midi";
-import Module, { DummnyInternalModule } from "../core/Module";
-import { MidiOutput } from "../core/IO";
-
-export interface MidiSelectorInterface {
-  selectedId: string | null;
-}
+import { IModule, Module, MidiOutput } from "@/core";
+import MidiEvent from "@/core/midi/MidiEvent";
+import { PropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
+
+export type IMidiSelector = IModule<ModuleType.MidiSelector>;
+export type IMidiSelectorProps = {
+  selectedId: string | undefined | null;
+};
 
-const InitialProps: MidiSelectorInterface = {
-  selectedId: null,
+export const midiSelectorPropSchema: PropSchema<IMidiSelectorProps> = {
+  selectedId: {
+    kind: "string",
+    label: "Midi device ID",
+  },
 };
 
-export default class MidiSelector extends Module<
-  DummnyInternalModule,
-  MidiSelectorInterface
-> {
-  static moduleName = "MidiSelector";
-  midiOutput: MidiOutput;
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<MidiSelectorInterface>;
-  }) {
-    const { id, name, props } = params;
-    super(new DummnyInternalModule(), {
-      id,
-      name,
-      props: { ...InitialProps, ...props },
+const DEFAULT_PROPS: IMidiSelectorProps = { selectedId: undefined };
+
+export default class MidiSelector extends Module<ModuleType.MidiSelector> {
+  declare audioNode: undefined;
+  midiOutput!: MidiOutput;
+  _forwardMidiEvent?: (midiEvent: MidiEvent) => void;
+
+  constructor(
+    engineId: string,
+    params: ICreateModule<ModuleType.MidiSelector>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+
+    super(engineId, {
+      ...params,
+      props,
     });
 
+    this.addEventListener(this.props.selectedId);
+
     this.registerOutputs();
-    this.addEventListener(this.selectedId);
   }
 
-  get selectedId() {
-    return this._props["selectedId"];
-  }
+  protected onSetSelectedId(value: string | null) {
+    if (!this.superInitialized) return;
 
-  set selectedId(value: string | null) {
     this.removeEventListener();
-
-    this._props = { ...this.props, selectedId: value };
-
     this.addEventListener(value);
   }
 
-  dispose() {
-    this.removeEventListener();
-    super.dispose();
-  }
+  private get forwardMidiEvent() {
+    if (this._forwardMidiEvent) return this._forwardMidiEvent;
 
-  private registerOutputs() {
-    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
+    this._forwardMidiEvent = (midiEvent: MidiEvent) => {
+      this.midiOutput.onMidiEvent(midiEvent);
+    };
+
+    return this._forwardMidiEvent;
   }
 
-  private addEventListener(midiId: string | null) {
-    if (!this.onMidiEvent || !midiId) return; // Ugly hack because of weird super bug
+  private addEventListener(midiId: string | undefined | null) {
+    if (!midiId) return;
 
-    const midiDevice = Engine.midiDeviceManager.find(midiId);
+    const midiDevice = this.engine.findMidiDevice(midiId);
     midiDevice?.addEventListener(this.forwardMidiEvent);
   }
 
-  private forwardMidiEvent = (midiEvent: MidiEvent) => {
-    this.midiOutput.onMidiEvent(midiEvent);
-  };
-
   private removeEventListener() {
-    if (!this.selectedId) return;
+    if (!this.props.selectedId) return;
 
-    const midiDevice = Engine.midiDeviceManager.find(this.selectedId);
+    const midiDevice = this.engine.findMidiDevice(this.props.selectedId);
     midiDevice?.removeEventListener(this.forwardMidiEvent);
   }
+
+  private registerOutputs() {
+    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
+  }
 }