@blibliki/engine 0.1.26 → 0.3.1

package/src/modules/index.ts

@@ -1,84 +1,169 @@
-import { Envelope, AmpEnvelope, FreqEnvelope } from "./Envelope";
-import Oscillator from "./Oscillator";
-import Filter from "./Filter";
-import Master from "./Master";
-import VoiceScheduler from "./VoiceScheduler";
-import MidiSelector from "./MidiSelector";
-import Volume from "./Volume";
-import VirtualMidi from "./VirtualMidi";
-import Reverb from "./Reverb";
-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";
+import { assertNever } from "@blibliki/utils";
+import { IModule, Module, PropSchema } from "@/core";
+import { IPolyModuleConstructor } from "@/core/module/PolyModule";
+import VoiceScheduler, {
+  IVoiceSchedulerProps,
+  voiceSchedulerPropSchema,
+} from "@/core/module/VoiceScheduler";
+import BiquadFilter, {
+  biquadFilterPropSchema,
+  IBiquadFilterProps,
+} from "./BiquadFilter";
+import Constant, { constantPropSchema, IConstantProps } from "./Constant";
+import Envelope, { envelopePropSchema, IEnvelopeProps } from "./Envelope";
+import Filter, { filterPropSchema, IFilterProps } from "./Filter";
+import Gain, { gainPropSchema, IGainProps } from "./Gain";
+import Inspector, { IInspectorProps, inspectorPropSchema } from "./Inspector";
+import Master, { IMasterProps, masterPropSchema } from "./Master";
+import MidiSelector, {
+  IMidiSelectorProps,
+  midiSelectorPropSchema,
+} from "./MidiSelector";
+import Oscillator, {
+  IOscillatorProps,
+  oscillatorPropSchema,
+} from "./Oscillator";
+import Scale, { IScaleProps, scalePropSchema } from "./Scale";
+import StepSequencer, {
+  IStepSequencerProps,
+  stepSequencerPropSchema,
+} from "./StepSequencer";
+import VirtualMidi, {
+  IVirtualMidiProps,
+  virtualMidiPropSchema,
+} from "./VirtualMidi";
 
-export { default as Master } from "./Master";
-export { default as Filter } from "./Filter";
-export { default as Oscillator } from "./Oscillator";
-export { default as VirtualMidi } from "./VirtualMidi";
-export { default as VoiceScheduler } from "./VoiceScheduler";
-export { default as Sequencer } from "./Sequencer";
-export type { ISequence } from "./Sequencer";
+export enum ModuleType {
+  Master = "Master",
+  Oscillator = "Oscillator",
+  Gain = "Gain",
+  MidiSelector = "MidiSelector",
+  Envelope = "Envelope",
+  Filter = "Filter",
+  BiquadFilter = "BiquadFilter",
+  Scale = "Scale",
+  Inspector = "Inspector",
+  Constant = "Constant",
+  VirtualMidi = "VirtualMidi",
+  StepSequencer = "StepSequencer",
+  VoiceScheduler = "VoiceScheduler",
+}
+
+export type ModuleTypeToPropsMapping = {
+  [ModuleType.Oscillator]: IOscillatorProps;
+  [ModuleType.Gain]: IGainProps;
+  [ModuleType.Master]: IMasterProps;
+  [ModuleType.MidiSelector]: IMidiSelectorProps;
+  [ModuleType.Envelope]: IEnvelopeProps;
+  [ModuleType.Filter]: IFilterProps;
+  [ModuleType.BiquadFilter]: IBiquadFilterProps;
+  [ModuleType.Scale]: IScaleProps;
+  [ModuleType.Inspector]: IInspectorProps;
+  [ModuleType.Constant]: IConstantProps;
+  [ModuleType.VirtualMidi]: IVirtualMidiProps;
+  [ModuleType.StepSequencer]: IStepSequencerProps;
+  [ModuleType.VoiceScheduler]: IVoiceSchedulerProps;
+};
+
+export type ModuleTypeToModuleMapping = {
+  [ModuleType.Oscillator]: Oscillator;
+  [ModuleType.Gain]: Gain;
+  [ModuleType.Master]: Master;
+  [ModuleType.MidiSelector]: MidiSelector;
+  [ModuleType.Envelope]: Envelope;
+  [ModuleType.Filter]: Filter;
+  [ModuleType.BiquadFilter]: BiquadFilter;
+  [ModuleType.Scale]: Scale;
+  [ModuleType.Inspector]: Inspector;
+  [ModuleType.Constant]: Constant;
+  [ModuleType.VirtualMidi]: VirtualMidi;
+  [ModuleType.StepSequencer]: StepSequencer;
+  [ModuleType.VoiceScheduler]: VoiceScheduler;
+};
+
+export const moduleSchemas: {
+  [K in ModuleType]: PropSchema<Partial<ModuleTypeToPropsMapping[K]>>;
+} = {
+  [ModuleType.Oscillator]: oscillatorPropSchema,
+  [ModuleType.Gain]: gainPropSchema,
+  [ModuleType.Master]: masterPropSchema,
+  [ModuleType.MidiSelector]: midiSelectorPropSchema,
+  [ModuleType.Envelope]: envelopePropSchema,
+  [ModuleType.Filter]: filterPropSchema,
+  [ModuleType.BiquadFilter]: biquadFilterPropSchema,
+  [ModuleType.Scale]: scalePropSchema,
+  [ModuleType.Inspector]: inspectorPropSchema,
+  [ModuleType.Constant]: constantPropSchema,
+  [ModuleType.VirtualMidi]: virtualMidiPropSchema,
+  [ModuleType.StepSequencer]: stepSequencerPropSchema,
+  [ModuleType.VoiceScheduler]: voiceSchedulerPropSchema,
+};
 
-export {
-  Envelope,
-  AmpEnvelope,
-  FreqEnvelope,
-  EnvelopeStages,
-} from "./Envelope";
+export type { IOscillator } from "./Oscillator";
+export { OscillatorWave } from "./Oscillator";
+export type { IGain } from "./Gain";
+export type { IMaster } from "./Master";
+export type { IMidiSelector } from "./MidiSelector";
+export type {
+  IStepSequencer,
+  IStepSequencerProps,
+  ISequence,
+} from "./StepSequencer";
 
-export interface ICreateModule {
+export type AnyModule = Module<ModuleType>;
+export type IAnyModule = IModule<ModuleType>;
+
+export type ICreateModule<T extends ModuleType> = {
   id?: string;
   name: string;
-  numberOfVoices?: number;
-  type: string;
-  props: any;
-}
+  moduleType: T;
+  props: Partial<ModuleTypeToPropsMapping[T]>;
+};
 
-export function createModule(params: ICreateModule): AudioModule {
-  const { id, type, name, props } = params;
-  const klass = moduleClassFromType(type);
-
-  return new klass({ id, name, props });
-}
+export type ModuleParams = {
+  [K in ModuleType]: K extends
+    | ModuleType.Oscillator
+    | ModuleType.Gain
+    | ModuleType.Envelope
+    | ModuleType.Filter
+    | ModuleType.BiquadFilter
+    | ModuleType.VoiceScheduler
+    ? IPolyModuleConstructor<K>
+    : ICreateModule<K>;
+}[ModuleType];
 
-function moduleClassFromType(type: string) {
-  switch (type) {
-    case Oscillator.moduleName:
-      return Oscillator;
-    case Envelope.moduleName:
-      return Envelope;
-    case AmpEnvelope.moduleName:
-      return AmpEnvelope;
-    case FreqEnvelope.moduleName:
-      return FreqEnvelope;
-    case Filter.moduleName:
-      return Filter;
-    case Volume.moduleName:
-      return Volume;
-    case Master.moduleName:
-      return Master;
-    case VoiceScheduler.moduleName:
-      return VoiceScheduler;
-    case MidiSelector.moduleName:
-      return MidiSelector;
-    case VirtualMidi.moduleName:
-      return VirtualMidi;
-    case Reverb.moduleName:
-      return Reverb;
-    case Delay.moduleName:
-      return Delay;
-    case Distortion.moduleName:
-      return Distortion;
-    case BitCrusher.moduleName:
-      return BitCrusher;
-    case Sequencer.moduleName:
-      return Sequencer;
-    case LFO.moduleName:
-      return LFO;
+export function createModule(
+  engineId: string,
+  params: ModuleParams,
+): ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping] {
+  switch (params.moduleType) {
+    case ModuleType.Oscillator:
+      return new Oscillator(engineId, params);
+    case ModuleType.Gain:
+      return new Gain(engineId, params);
+    case ModuleType.Master:
+      return new Master(engineId, params);
+    case ModuleType.MidiSelector:
+      return new MidiSelector(engineId, params);
+    case ModuleType.Envelope:
+      return new Envelope(engineId, params);
+    case ModuleType.Filter:
+      return new Filter(engineId, params);
+    case ModuleType.BiquadFilter:
+      return new BiquadFilter(engineId, params);
+    case ModuleType.Scale:
+      return new Scale(engineId, params);
+    case ModuleType.Inspector:
+      return new Inspector(engineId, params);
+    case ModuleType.Constant:
+      return new Constant(engineId, params);
+    case ModuleType.VirtualMidi:
+      return new VirtualMidi(engineId, params);
+    case ModuleType.StepSequencer:
+      return new StepSequencer(engineId, params);
+    case ModuleType.VoiceScheduler:
+      return new VoiceScheduler(engineId, params);
     default:
-      throw Error(`Unknown module type ${type}`);
+      assertNever(params);
   }
 }

package/src/nodePolyfill.ts

@@ -0,0 +1,25 @@
+import {
+  AudioContext,
+  AnalyserNode,
+  AudioParam,
+  AudioNode,
+  AudioWorkletNode,
+  BiquadFilterNode,
+  GainNode,
+  OfflineAudioContext,
+  OscillatorNode,
+  ConstantSourceNode,
+  WaveShaperNode,
+} from "node-web-audio-api";
+
+globalThis.AudioContext = AudioContext;
+globalThis.OfflineAudioContext = OfflineAudioContext;
+globalThis.AudioParam = AudioParam;
+globalThis.AudioNode = AudioNode;
+globalThis.AudioWorkletNode = AudioWorkletNode;
+globalThis.AnalyserNode = AnalyserNode;
+globalThis.GainNode = GainNode;
+globalThis.OscillatorNode = OscillatorNode;
+globalThis.BiquadFilterNode = BiquadFilterNode;
+globalThis.ConstantSourceNode = ConstantSourceNode;
+globalThis.WaveShaperNode = WaveShaperNode;

package/src/processors/filter-processor.ts

@@ -0,0 +1,82 @@
+export const filterProcessorURL = URL.createObjectURL(
+  new Blob(
+    [
+      "(",
+      (() => {
+        class FilterProcessor extends AudioWorkletProcessor {
+          s0: number;
+          s1: number;
+
+          constructor() {
+            super();
+            this.s0 = 0;
+            this.s1 = 0;
+          }
+
+          static get parameterDescriptors() {
+            return [
+              {
+                name: "cutoff",
+                defaultValue: 1000,
+                minValue: 20,
+                maxValue: 20000,
+              },
+              {
+                name: "resonance",
+                defaultValue: 0.0,
+                minValue: 0.0,
+                maxValue: 4.0,
+              },
+            ];
+          }
+
+          process(
+            inputs: Float32Array[][],
+            outputs: Float32Array[][],
+            parameters: Record<string, Float32Array>,
+          ): boolean {
+            const input = inputs[0];
+            const output = outputs[0];
+
+            const cutoff = parameters.cutoff;
+            const resonance = parameters.resonance;
+
+            for (let channelNum = 0; channelNum < input.length; channelNum++) {
+              const inputChannel = input[channelNum];
+              const outputChannel = output[channelNum];
+
+              for (let i = 0; i < inputChannel.length; i++) {
+                const s = inputChannel[i];
+                // Convert Hz to normalized frequency using logarithmic scale
+                // This better matches human hearing perception
+                const cutoffHz = cutoff.length > 1 ? cutoff[i] : cutoff[0];
+                const clampedHz = Math.max(20, Math.min(20000, cutoffHz));
+                const normalizedCutoff =
+                  Math.log(clampedHz / 20) / Math.log(20000 / 20);
+                const c = Math.pow(0.5, (1 - normalizedCutoff) / 0.125);
+                const r = Math.pow(
+                  0.5,
+                  ((resonance.length > 1 ? resonance[i] : resonance[0]) +
+                    0.125) /
+                    0.125,
+                );
+                const mrc = 1 - r * c;
+
+                this.s0 = mrc * this.s0 - c * this.s1 + c * s;
+                this.s1 = mrc * this.s1 + c * this.s0;
+
+                outputChannel[i] = this.s1;
+              }
+            }
+
+            return true;
+          }
+        }
+
+        registerProcessor("filter-processor", FilterProcessor);
+      }).toString(),
+      ")()",
+    ],
+    { type: "application/javascript" },
+  ),
+);

package/src/processors/index.ts

@@ -0,0 +1,28 @@
+import { assertNever } from "@blibliki/utils";
+import { IAnyAudioContext } from "@/core";
+import { filterProcessorURL } from "./filter-processor";
+import { scaleProcessorURL } from "./scale-processor";
+
+export enum CustomWorklet {
+  ScaleProcessor = "ScaleProcessor",
+  FilterProcessor = "FilterProcessor",
+}
+
+export async function loadProcessors(context: IAnyAudioContext) {
+  await context.audioWorklet.addModule(scaleProcessorURL);
+  await context.audioWorklet.addModule(filterProcessorURL);
+}
+
+export function newAudioWorklet(
+  context: IAnyAudioContext,
+  worklet: CustomWorklet,
+) {
+  switch (worklet) {
+    case CustomWorklet.ScaleProcessor:
+      return new AudioWorkletNode(context, "scale-processor");
+    case CustomWorklet.FilterProcessor:
+      return new AudioWorkletNode(context, "filter-processor");
+    default:
+      assertNever(worklet);
+  }
+}

package/src/processors/scale-processor.ts

@@ -0,0 +1,81 @@
+export const scaleProcessorURL = URL.createObjectURL(
+  new Blob(
+    [
+      "(",
+      (() => {
+        class ScaleProcessor extends AudioWorkletProcessor {
+          static get parameterDescriptors() {
+            return [
+              {
+                name: "min",
+                defaultValue: 1e-10,
+              },
+              {
+                name: "max",
+                defaultValue: 1,
+              },
+              {
+                name: "current",
+                defaultValue: 0.5,
+              },
+            ];
+          }
+
+          process(
+            inputs: Float32Array[][],
+            outputs: Float32Array[][],
+            parameters: Record<string, Float32Array>,
+          ) {
+            const input = inputs[0];
+            const output = outputs[0];
+
+            const minValues = parameters.min;
+            const maxValues = parameters.max;
+            const currentValues = parameters.current;
+
+            if (!input.length || input[0].length === 0) {
+              for (const outputChannel of output) {
+                const current =
+                  parameters.current.length > 1
+                    ? parameters.current[0]
+                    : parameters.current[0];
+
+                outputChannel.fill(current);
+              }
+
+              return true;
+            }
+
+            for (let channel = 0; channel < input.length; channel++) {
+              const inputChannel = input[channel];
+              const outputChannel = output[channel];
+
+              for (let i = 0; i < inputChannel.length; i++) {
+                const x = inputChannel[i];
+
+                const min = minValues.length > 1 ? minValues[i] : minValues[0];
+                const max = maxValues.length > 1 ? maxValues[i] : maxValues[0];
+                const current =
+                  currentValues.length > 1
+                    ? currentValues[i]
+                    : currentValues[0];
+
+                if (x < 0) {
+                  outputChannel[i] = current * Math.pow(min / current, -x);
+                } else {
+                  outputChannel[i] = current * Math.pow(max / current, x);
+                }
+              }
+            }
+
+            return true;
+          }
+        }
+
+        registerProcessor("scale-processor", ScaleProcessor);
+      }).toString(),
+      ")()",
+    ],
+    { type: "application/javascript" },
+  ),
+);

package/dist/build/Engine.d.ts

@@ -1,82 +0,0 @@
-import { MidiDeviceManager } from "./core/midi";
-import { AudioModule } from "./core/Module";
-import { RouteInterface } from "./routes";
-import { AnyObject, Optional } from "./types";
-type LatencyHint = "interactive" | "playback" | "balanced";
-interface ContextInterface {
-    latencyHint: LatencyHint;
-    lookAhead: number;
-}
-interface InitializeInterface {
-    context?: Partial<ContextInterface>;
-}
-export interface UpdateModuleProps {
-    id: string;
-    changes: {
-        name?: string;
-        numberOfVoices?: number;
-        props?: AnyObject;
-    };
-}
-declare class Engine {
-    midiDeviceManager: MidiDeviceManager;
-    private static instance;
-    private context;
-    private propsUpdateCallbacks;
-    private _isStarted;
-    modules: {
-        [Identifier: string]: AudioModule;
-    };
-    routes: {
-        [Identifier: string]: RouteInterface;
-    };
-    private constructor();
-    static getInstance(): Engine;
-    initialize(props: InitializeInterface): Promise<unknown>;
-    addModule(params: {
-        id?: string;
-        name: string;
-        numberOfVoices?: number;
-        type: string;
-        props?: AnyObject;
-    }): {
-        id: string;
-        name: string;
-        type: string;
-        props: any;
-        inputs: import(".").IOProps[];
-        outputs: import(".").IOProps[];
-    };
-    removeModule(id: string): string[];
-    updateModule(params: UpdateModuleProps): {
-        id: string;
-        name: string;
-        type: string;
-        props: any;
-        inputs: import(".").IOProps[];
-        outputs: import(".").IOProps[];
-    };
-    onPropsUpdate(callback: (id: string, props: AnyObject) => void): void;
-    _triggerPropsUpdate(id: string, props: AnyObject): void;
-    addRoute(props: Optional<RouteInterface, "id">): {
-        id: string;
-        sourceId: string;
-        destinationId: string;
-        sourceIOId: string;
-        destinationIOId: string;
-    };
-    validRoute(props: Optional<RouteInterface, "id">): boolean;
-    removeRoute(id: string): void;
-    triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff"): void;
-    dispose(): void;
-    findById(id: string): AudioModule;
-    get isStarted(): boolean;
-    start(): void;
-    stop(): void;
-    get bpm(): number;
-    set bpm(value: number);
-    updateRoutes(): void;
-    private moduleRouteIds;
-}
-declare const _default: Engine;
-export default _default;

package/dist/build/core/IO/AudioNode.d.ts

@@ -1,35 +0,0 @@
-import { InputNode } from "tone";
-import IONode, { IOType, IIONode } from "./Node";
-import MonoModule, { Connectable } from "../Module/index";
-import { AnyObject } from "../../types";
-import { AnyAudioInput, AnyAudioOuput } from ".";
-export type AudioIO = AudioInput | AudioOutput;
-export interface IAudioInput extends IIONode {
-    ioType: IOType.AudioInput;
-    internalModule: InputNode;
-}
-export interface IAudioOutput extends IIONode {
-    ioType: IOType.AudioOutput;
-    internalModule: IInternalModule;
-}
-interface IInternalModule extends Connectable {
-}
-export declare class AudioInput extends IONode implements IAudioInput {
-    ioType: IOType.AudioInput;
-    internalModule: InputNode;
-    connections: AudioOutput[];
-    constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioInput);
-    plug(io: AnyAudioOuput, plugOther?: boolean): void;
-    unPlug(io: AnyAudioOuput, plugOther?: boolean): void;
-    unPlugAll(): void;
-}
-export declare class AudioOutput extends IONode implements IAudioOutput {
-    ioType: IOType.AudioOutput;
-    internalModule: IInternalModule;
-    connections: AudioInput[];
-    constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioOutput);
-    plug(io: AnyAudioInput, plugOther?: boolean): void;
-    unPlug(io: AnyAudioInput, plugOther?: boolean): void;
-    unPlugAll(): void;
-}
-export {};

package/dist/build/core/IO/Collection.d.ts

@@ -1,13 +0,0 @@
-import { AudioModule } from "../Module";
-import IO from "./Node";
-import { IAnyIO } from ".";
-export default class IOCollection<AnyIO extends IO> {
-    plugableModule: AudioModule;
-    collection: AnyIO[];
-    constructor(plugableModule: AudioModule);
-    add<CurrentIO extends AnyIO>(props: IAnyIO): CurrentIO;
-    unPlugAll(): void;
-    find(id: string): AnyIO | undefined;
-    findByName(name: string): AnyIO | undefined;
-    serialize(): import("./Node").IIOSerialize[];
-}

package/dist/build/core/IO/ForwardNode/Base.d.ts

@@ -1,18 +0,0 @@
-import IONode, { IIONode } from "../Node";
-import Module, { Connectable, PolyModule } from "../../Module";
-import { AnyObject } from "../../../types";
-import { AnyIO } from "..";
-export default class ForwardBaseNode extends IONode {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IIONode);
-    get voices(): number;
-    get subModules(): Module<Connectable, AnyObject>[];
-    subModule(voiceNo: number): Module<Connectable, AnyObject>;
-    get subIOs(): IONode[];
-    subIO(voiceNo: number): import("..").AudioInput | import("..").MidiInput | import("..").AudioOutput | import("..").MidiOutput;
-    plug(io: AnyIO, plugOther?: boolean): void;
-    unPlug(io: AnyIO, plugOther?: boolean): void;
-    unPlugAll(): void;
-    private plugUnplug;
-    private checkNameValidity;
-}

package/dist/build/core/IO/ForwardNode/index.d.ts

@@ -1,27 +0,0 @@
-import { IOType, IIONode } from "../Node";
-import Module, { Connectable, PolyModule } from "../../Module";
-import { AnyObject } from "../../../types";
-import { AnyAudioInput, AnyAudioOuput, AnyInput, AnyOuput } from "..";
-import ForwardBaseNode from "./Base";
-export interface IForwardAudioInput extends IIONode {
-    ioType: IOType.ForwardAudioInput;
-}
-export interface IForwardAudioOutput extends IIONode {
-    ioType: IOType.ForwardAudioOutput;
-}
-export declare class ForwardAudioInput extends ForwardBaseNode implements IForwardAudioInput {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    ioType: IOType.ForwardAudioInput;
-    connections: AnyAudioOuput[];
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardAudioInput);
-    plug(io: AnyOuput, plugOther?: boolean): void;
-    unPlug(io: AnyOuput, plugOther?: boolean): void;
-}
-export declare class ForwardAudioOutput extends ForwardBaseNode implements IForwardAudioOutput {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    ioType: IOType.ForwardAudioOutput;
-    connections: AnyAudioInput[];
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardAudioOutput);
-    plug(io: AnyInput, plugOther?: boolean): void;
-    unPlug(io: AnyInput, plugOther?: boolean): void;
-}