@blibliki/engine 0.3.4 → 0.3.6

package/src/modules/Envelope.ts

@@ -1,10 +1,10 @@
 import { ContextTime } from "@blibliki/transport";
-import { Context, createScaleNormalized } from "@blibliki/utils";
+import { Context, cancelAndHoldAtTime } from "@blibliki/utils";
 import { Module } from "@/core";
 import Note from "@/core/Note";
 import { IModuleConstructor } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
-import { PropSchema } from "@/core/schema";
+import { ModulePropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
 export type IEnvelopeProps = {
@@ -15,25 +15,27 @@ export type IEnvelopeProps = {
 };
 
 const DEFAULT_PROPS: IEnvelopeProps = {
-  attack: 0.1,
-  decay: 0.2,
-  sustain: 0,
-  release: 0.3,
+  attack: 0.01,
+  decay: 0,
+  sustain: 1,
+  release: 0,
 };
 
-export const envelopePropSchema: PropSchema<IEnvelopeProps> = {
+export const envelopePropSchema: ModulePropSchema<IEnvelopeProps> = {
   attack: {
     kind: "number",
     min: 0.0001,
-    max: 1,
+    max: 20,
     step: 0.01,
+    exp: 3,
     label: "Attack",
   },
   decay: {
     kind: "number",
     min: 0,
-    max: 1,
+    max: 20,
     step: 0.01,
+    exp: 3,
     label: "Decay",
   },
   sustain: {
@@ -46,22 +48,13 @@ export const envelopePropSchema: PropSchema<IEnvelopeProps> = {
   release: {
     kind: "number",
     min: 0,
-    max: 1,
+    max: 20,
     step: 0.01,
+    exp: 3,
     label: "Release",
   },
 };
 
-const scaleToTen = createScaleNormalized({
-  min: 0.001,
-  max: 10,
-});
-
-const scaleToFive = createScaleNormalized({
-  min: 0.001,
-  max: 5,
-});
-
 class MonoEnvelope extends Module<ModuleType.Envelope> {
   declare audioNode: GainNode;
 
@@ -85,11 +78,11 @@ class MonoEnvelope extends Module<ModuleType.Envelope> {
   triggerAttack(note: Note, triggeredAt: ContextTime) {
     super.triggerAttack(note, triggeredAt);
 
-    const attack = this.scaledAttack();
-    const decay = this.scaledDecay();
+    const attack = this.props.attack;
+    const decay = this.props.decay;
     const sustain = this.props.sustain;
 
-    this.audioNode.gain.cancelAndHoldAtTime(triggeredAt);
+    cancelAndHoldAtTime(this.audioNode.gain, triggeredAt);
 
     // Always start from a tiny value, can't ramp from 0
     if (this.audioNode.gain.value === 0) {
@@ -118,11 +111,13 @@ class MonoEnvelope extends Module<ModuleType.Envelope> {
     super.triggerRelease(note, triggeredAt);
     if (this.activeNotes.length > 0) return;
 
-    const release = this.scaledRelease();
+    const release = this.props.release;
 
     // Cancel scheduled automations and set gain to the ACTUAL value at this moment
-    this.audioNode.gain.cancelAndHoldAtTime(triggeredAt);
-    const currentGainValue = this.audioNode.gain.value;
+    const currentGainValue = cancelAndHoldAtTime(
+      this.audioNode.gain,
+      triggeredAt,
+    );
 
     if (currentGainValue >= 0.0001) {
       // Always set the value at the release time to ensure a smooth ramp from here
@@ -137,18 +132,6 @@ class MonoEnvelope extends Module<ModuleType.Envelope> {
     // Set to zero at the very end
     this.audioNode.gain.setValueAtTime(0, triggeredAt + release);
   }
-
-  private scaledAttack() {
-    return scaleToTen(this.props.attack);
-  }
-
-  private scaledDecay() {
-    return scaleToFive(this.props.decay);
-  }
-
-  private scaledRelease() {
-    return scaleToTen(this.props.release);
-  }
 }
 
 export default class Envelope extends PolyModule<ModuleType.Envelope> {

package/src/modules/Filter.ts

@@ -1,9 +1,7 @@
 import { Context } from "@blibliki/utils";
-import { Module } from "@/core";
-import { IModuleConstructor } from "@/core/module/Module";
+import { EnumProp, ModulePropSchema } from "@/core";
+import { IModuleConstructor, Module, SetterHooks } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
-import { PropSchema } from "@/core/schema";
-import { CustomWorklet, newAudioWorklet } from "@/processors";
 import { createModule, ICreateModule, ModuleType } from ".";
 import { MonoGain } from "./Gain";
 import Scale from "./Scale";
@@ -11,24 +9,32 @@ import Scale from "./Scale";
 export type IFilterProps = {
   cutoff: number;
   envelopeAmount: number;
-  resonance: number;
+  type: BiquadFilterType;
+  Q: number;
 };
 
 const MIN_FREQ = 20;
-const MAX_FREQ = 22050;
+const MAX_FREQ = 20000;
 
 const DEFAULT_PROPS: IFilterProps = {
   cutoff: MAX_FREQ,
   envelopeAmount: 0,
-  resonance: 0,
+  type: "lowpass",
+  Q: 1,
 };
 
-export const filterPropSchema: PropSchema<IFilterProps> = {
+export const filterPropSchema: ModulePropSchema<
+  IFilterProps,
+  {
+    type: EnumProp<BiquadFilterType>;
+  }
+> = {
   cutoff: {
     kind: "number",
     min: MIN_FREQ,
     max: MAX_FREQ,
-    step: 0.0001,
+    step: 1,
+    exp: 5,
     label: "Cutoff",
   },
   envelopeAmount: {
@@ -38,17 +44,33 @@ export const filterPropSchema: PropSchema<IFilterProps> = {
     step: 0.01,
     label: "Envelope Amount",
   },
-  resonance: {
+  type: {
+    kind: "enum",
+    options: ["lowpass", "highpass", "bandpass"] satisfies BiquadFilterType[],
+    label: "Type",
+  },
+  Q: {
     kind: "number",
-    min: 0,
-    max: 4,
-    step: 0.01,
-    label: "resonance",
+    min: 0.0001,
+    max: 1000,
+    step: 0.1,
+    exp: 5,
+    label: "Q",
   },
 };
 
-class MonoFilter extends Module<ModuleType.Filter> {
-  declare audioNode: AudioWorkletNode;
+class MonoFilter
+  extends Module<ModuleType.Filter>
+  implements
+    Pick<
+      SetterHooks<IFilterProps>,
+      | "onAfterSetType"
+      | "onAfterSetCutoff"
+      | "onAfterSetQ"
+      | "onAfterSetEnvelopeAmount"
+    >
+{
+  declare audioNode: BiquadFilterNode;
   private scale: Scale;
   private amount: MonoGain;
 
@@ -56,7 +78,11 @@ class MonoFilter extends Module<ModuleType.Filter> {
     const props = { ...DEFAULT_PROPS, ...params.props };
 
     const audioNodeConstructor = (context: Context) =>
-      newAudioWorklet(context, CustomWorklet.FilterProcessor);
+      new BiquadFilterNode(context.audioContext, {
+        type: props.type,
+        frequency: 0,
+        Q: props.Q,
+      });
 
     super(engineId, {
       ...params,
@@ -77,40 +103,33 @@ class MonoFilter extends Module<ModuleType.Filter> {
     }) as Scale;
 
     this.amount.plug({ audioModule: this.scale, from: "out", to: "in" });
-    this.scale.audioNode.connect(this.cutoff);
+    this.scale.audioNode.connect(this.audioNode.frequency);
 
     this.registerDefaultIOs();
     this.registerInputs();
   }
 
-  get cutoff() {
-    return this.audioNode.parameters.get("cutoff")!;
-  }
-
-  get resonance() {
-    return this.audioNode.parameters.get("resonance")!;
-  }
-
-  protected onSetCutoff(value: IFilterProps["cutoff"]) {
-    if (!this.superInitialized) return;
+  onAfterSetType: SetterHooks<IFilterProps>["onAfterSetType"] = (value) => {
+    this.audioNode.type = value;
+  };
 
+  onAfterSetCutoff: SetterHooks<IFilterProps>["onAfterSetCutoff"] = (value) => {
     this.scale.props = { current: value };
-  }
+  };
 
-  protected onSetResonance(value: IFilterProps["resonance"]) {
-    this.resonance.value = value;
-  }
+  onAfterSetQ: SetterHooks<IFilterProps>["onAfterSetQ"] = (value) => {
+    this.audioNode.Q.value = value;
+  };
 
-  protected onSetEnvelopeAmount(value: IFilterProps["envelopeAmount"]) {
-    if (!this.superInitialized) return;
-
-    this.amount.props = { gain: value };
-  }
+  onAfterSetEnvelopeAmount: SetterHooks<IFilterProps>["onAfterSetEnvelopeAmount"] =
+    (value) => {
+      this.amount.props = { gain: value };
+    };
 
   private registerInputs() {
     this.registerAudioInput({
       name: "cutoff",
-      getAudioNode: () => this.scale.audioNode,
+      getAudioNode: () => this.audioNode.frequency,
     });
 
     this.registerAudioInput({
@@ -120,7 +139,7 @@ class MonoFilter extends Module<ModuleType.Filter> {
 
     this.registerAudioInput({
       name: "Q",
-      getAudioNode: () => this.resonance,
+      getAudioNode: () => this.audioNode.Q,
     });
   }
 }

package/src/modules/Gain.ts

@@ -1,8 +1,7 @@
 import { Context } from "@blibliki/utils";
-import { IModule, Module } from "@/core";
+import { IModule, Module, ModulePropSchema, SetterHooks } 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>;
@@ -10,7 +9,7 @@ export type IGainProps = {
   gain: number;
 };
 
-export const gainPropSchema: PropSchema<IGainProps> = {
+export const gainPropSchema: ModulePropSchema<IGainProps> = {
   gain: {
     kind: "number",
     min: 0,
@@ -22,7 +21,10 @@ export const gainPropSchema: PropSchema<IGainProps> = {
 
 const DEFAULT_PROPS: IGainProps = { gain: 1 };
 
-export class MonoGain extends Module<ModuleType.Gain> {
+export class MonoGain
+  extends Module<ModuleType.Gain>
+  implements Pick<SetterHooks<IGainProps>, "onAfterSetGain">
+{
   declare audioNode: GainNode;
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Gain>) {
@@ -40,9 +42,9 @@ export class MonoGain extends Module<ModuleType.Gain> {
     this.registerAdditionalInputs();
   }
 
-  protected onSetGain(value: IGainProps["gain"]) {
+  onAfterSetGain: SetterHooks<IGainProps>["onAfterSetGain"] = (value) => {
     this.audioNode.gain.value = value;
-  }
+  };
 
   private registerAdditionalInputs() {
     this.registerAudioInput({

package/src/modules/Inspector.ts

@@ -1,6 +1,6 @@
 import { Context } from "@blibliki/utils";
-import { IModule, Module } from "@/core";
-import { PropSchema } from "@/core/schema";
+import { IModule, Module, SetterHooks } from "@/core";
+import { EnumProp, ModulePropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
 export type IInspector = IModule<ModuleType.Inspector>;
@@ -8,7 +8,12 @@ export type IInspectorProps = {
   fftSize: number;
 };
 
-export const inspectorPropSchema: PropSchema<IInspectorProps> = {
+export const inspectorPropSchema: ModulePropSchema<
+  IInspectorProps,
+  {
+    fftSize: EnumProp<number>;
+  }
+> = {
   fftSize: {
     kind: "enum",
     options: [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768],
@@ -18,7 +23,10 @@ export const inspectorPropSchema: PropSchema<IInspectorProps> = {
 
 const DEFAULT_PROPS: IInspectorProps = { fftSize: 512 };
 
-export default class Inspector extends Module<ModuleType.Inspector> {
+export default class Inspector
+  extends Module<ModuleType.Inspector>
+  implements Pick<SetterHooks<IInspectorProps>, "onAfterSetFftSize">
+{
   declare audioNode: AnalyserNode;
   private _buffer?: Float32Array<ArrayBuffer>;
 
@@ -36,9 +44,11 @@ export default class Inspector extends Module<ModuleType.Inspector> {
     this.registerDefaultIOs("in");
   }
 
-  protected onSetFftSize(value: number) {
+  onAfterSetFftSize: SetterHooks<IInspectorProps>["onAfterSetFftSize"] = (
+    value,
+  ) => {
     this._buffer = new Float32Array(value);
-  }
+  };
 
   get buffer() {
     if (this._buffer) return this._buffer;

package/src/modules/Master.ts

@@ -1,6 +1,5 @@
 import { Context, EmptyObject } from "@blibliki/utils";
-import { IModule, Module } from "@/core";
-import { PropSchema } from "@/core/schema";
+import { IModule, Module, ModulePropSchema } from "@/core";
 import { ICreateModule, ModuleType } from ".";
 
 export type IMaster = IModule<ModuleType.Master>;
@@ -8,7 +7,7 @@ export type IMasterProps = EmptyObject;
 
 const DEFAULT_PROPS: IMasterProps = {};
 
-export const masterPropSchema: PropSchema<IMasterProps> = {};
+export const masterPropSchema: ModulePropSchema<IMasterProps> = {};
 
 export default class Master extends Module<ModuleType.Master> {
   declare audioNode: AudioDestinationNode;

package/src/modules/MidiMapper.ts

@@ -0,0 +1,292 @@
+import { ContextTime } from "@blibliki/transport";
+import { IModule, MidiEvent, Module, SetterHooks } from "@/core";
+import { ModulePropSchema, NumberProp, PropSchema } from "@/core/schema";
+import { ICreateModule, moduleSchemas, ModuleType } from ".";
+
+export type IMidiMapper = IModule<ModuleType.MidiMapper>;
+export type IMidiMapperProps = {
+  pages: MidiMappingPage[];
+  activePage: number;
+  globalMappings: MidiMapping<ModuleType>[];
+};
+
+export type MidiMappingPage = {
+  name?: string;
+  mappings: MidiMapping<ModuleType>[];
+};
+
+export enum MidiMappingMode {
+  direct = "direct",
+  directRev = "directRev",
+  toggleInc = "toggleInc",
+  toggleDec = "toggleDec",
+  incDec = "incDec",
+  incDecRev = "incDecRev",
+}
+
+export type MidiMapping<T extends ModuleType> = {
+  cc?: number;
+  moduleId?: string;
+  moduleType?: T;
+  propName?: string;
+  autoAssign?: boolean;
+  mode?: MidiMappingMode;
+  threshold?: number; // For incDec mode (default: 64)
+  step?: number;
+};
+
+export const midiMapperPropSchema: ModulePropSchema<IMidiMapperProps> = {
+  pages: {
+    kind: "array",
+    label: "Midi mapping pages",
+  },
+  activePage: {
+    kind: "number",
+    label: "Active page",
+    min: 0,
+    max: 100,
+    step: 1,
+  },
+  globalMappings: {
+    kind: "array",
+    label: "Global midi mappings",
+  },
+};
+
+const DEFAULT_PROPS: IMidiMapperProps = {
+  pages: [{ name: "Page 1", mappings: [{}] }],
+  activePage: 0,
+  globalMappings: [{}],
+};
+
+function getMidiFromMappedValue({
+  value,
+  midiValue,
+  propSchema,
+  mapping,
+}: {
+  value: number;
+  propSchema: NumberProp;
+  midiValue: number;
+  mapping: MidiMapping<ModuleType>;
+}): number {
+  const min = propSchema.min ?? 0;
+  const max = propSchema.max ?? 1;
+  const exp = propSchema.exp ?? 1;
+
+  const { threshold = 64, mode } = mapping;
+
+  // Reverse the range mapping: get curvedValue
+  const curvedValue = (value - min) / (max - min);
+
+  // Reverse the exponential curve: get normalizedMidi
+  const normalizedMidi = Math.pow(curvedValue, 1 / exp);
+
+  // Reverse the MIDI normalization: get midiValue
+  let newMidiValue = normalizedMidi * 127;
+  newMidiValue =
+    (midiValue >= threshold && mode === MidiMappingMode.incDec) ||
+    (midiValue <= threshold && mode === MidiMappingMode.incDecRev)
+      ? newMidiValue + 1
+      : newMidiValue - 1;
+  return Math.round(Math.max(0, Math.min(127, newMidiValue))); // Valid MIDI range
+}
+
+type MidiMapperSetterHooks = Pick<
+  SetterHooks<IMidiMapperProps>,
+  "onSetActivePage"
+>;
+
+export default class MidiMapper
+  extends Module<ModuleType.MidiMapper>
+  implements MidiMapperSetterHooks
+{
+  declare audioNode: undefined;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.MidiMapper>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+
+    super(engineId, {
+      ...params,
+      props,
+    });
+
+    this.registerMidiInput({
+      name: "midi in",
+      onMidiEvent: this.onMidiEvent,
+    });
+  }
+
+  onSetActivePage: MidiMapperSetterHooks["onSetActivePage"] = (value) => {
+    return Math.max(Math.min(value, this.props.pages.length - 1), 0);
+  };
+
+  handleCC = (event: MidiEvent, triggeredAt: ContextTime) => {
+    this.checkAutoAssign(event);
+
+    const activePage = this.props.pages[this.props.activePage];
+
+    [
+      ...this.props.globalMappings.filter((m) => m.cc === event.cc),
+      ...activePage.mappings.filter((m) => m.cc === event.cc),
+    ].forEach((mapping) => {
+      this.forwardMapping(event, mapping, triggeredAt);
+    });
+  };
+
+  forwardMapping = (
+    event: MidiEvent,
+    mapping: MidiMapping<ModuleType>,
+    _triggeredAt: ContextTime,
+  ) => {
+    if (
+      mapping.moduleId === undefined ||
+      mapping.moduleType === undefined ||
+      mapping.propName === undefined
+    )
+      return;
+
+    const propName = mapping.propName;
+    let midiValue = event.ccValue;
+    if (midiValue === undefined) return;
+
+    const mode = mapping.mode ?? "direct";
+
+    // Toggle mode: only respond to 127 (button press), ignore 0
+    if (
+      (mode === MidiMappingMode.toggleInc ||
+        mode === MidiMappingMode.toggleDec) &&
+      midiValue !== 127
+    ) {
+      return;
+    }
+
+    const mappedModule = this.engine.findModule(mapping.moduleId);
+    // @ts-expect-error TS7053 ignore this error
+    const propSchema = moduleSchemas[mappedModule.moduleType][
+      propName
+    ] as PropSchema;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let mappedValue: any;
+
+    // Direct mode (default) or Toggle mode: map value directly
+    switch (propSchema.kind) {
+      case "number": {
+        // @ts-expect-error TS7053 ignore this error
+        const currentValue = mappedModule.props[propName] as number;
+
+        if (
+          mode === MidiMappingMode.incDec ||
+          mode === MidiMappingMode.incDecRev
+        ) {
+          midiValue = getMidiFromMappedValue({
+            value: currentValue,
+            propSchema,
+            mapping,
+            midiValue,
+          });
+        } else if (mode === MidiMappingMode.directRev) {
+          midiValue = 127 - midiValue;
+        }
+
+        if (mode === MidiMappingMode.toggleInc) {
+          mappedValue = currentValue + (propSchema.step ?? 1);
+        } else if (mode === MidiMappingMode.toggleDec) {
+          mappedValue = currentValue - (propSchema.step ?? 1);
+        } else {
+          const min = propSchema.min ?? 0;
+          const max = propSchema.max ?? 1;
+          const normalizedMidi = midiValue / 127;
+          const curvedValue = Math.pow(normalizedMidi, propSchema.exp ?? 1);
+          mappedValue = min + curvedValue * (max - min);
+
+          // Round to step if defined
+          if (
+            propSchema.step !== undefined &&
+            (!propSchema.exp || propSchema.exp === 1)
+          ) {
+            const steps = Math.round((mappedValue - min) / propSchema.step);
+            mappedValue = min + steps * propSchema.step;
+          }
+        }
+
+        break;
+      }
+      case "enum": {
+        const optionIndex = Math.floor(
+          (midiValue / 127) * propSchema.options.length,
+        );
+        const clampedIndex = Math.min(
+          optionIndex,
+          propSchema.options.length - 1,
+        );
+        mappedValue = propSchema.options[clampedIndex];
+        break;
+      }
+      case "boolean":
+        mappedValue = midiValue >= 64;
+        break;
+      case "string":
+        throw Error("MidiMapper not support string type of values");
+      case "array":
+        throw Error("MidiMapper not support array type of values");
+
+      default:
+        throw Error("MidiMapper unknown type");
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    mappedModule.props = { [propName]: mappedValue };
+    mappedModule.triggerPropsUpdate();
+  };
+
+  private checkAutoAssign(event: MidiEvent) {
+    if (event.cc === undefined) return;
+
+    const activePage = this.props.pages[this.props.activePage];
+    const hasGlobalAutoAssign = this.props.globalMappings.some(
+      ({ autoAssign }) => autoAssign,
+    );
+    const hasPageAutoAssign = activePage.mappings.some(
+      ({ autoAssign }) => autoAssign,
+    );
+
+    if (!hasGlobalAutoAssign && !hasPageAutoAssign) return;
+
+    // Update global mappings if needed
+    const updatedGlobalMappings = hasGlobalAutoAssign
+      ? this.props.globalMappings.map((mapping) => {
+          if (!mapping.autoAssign) return mapping;
+
+          return {
+            ...mapping,
+            cc: event.cc,
+            autoAssign: false,
+          };
+        })
+      : this.props.globalMappings;
+
+    // Update page mappings if needed
+    const updatedPageMappings = hasPageAutoAssign
+      ? activePage.mappings.map((mapping) => {
+          if (!mapping.autoAssign) return mapping;
+
+          return {
+            ...mapping,
+            cc: event.cc,
+            autoAssign: false,
+          };
+        })
+      : activePage.mappings;
+
+    const updatedPages = this.props.pages.map((page, index) =>
+      index === this.props.activePage
+        ? { ...page, mappings: updatedPageMappings }
+        : page,
+    );
+
+    this.props = { pages: updatedPages, globalMappings: updatedGlobalMappings };
+    this.triggerPropsUpdate();
+  }
+}