@blibliki/engine 0.1.27 → 0.3.1

package/src/modules/index.ts

@@ -1,84 +1,169 @@
-import { Envelope, AmpEnvelope, FreqEnvelope } from "./Envelope";
-import Oscillator, { MonoOscillator } 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, MonoOscillator } 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" },
+  ),
+);