@fluex/fluexgl-dsp 0.4.1 → 0.4.2

package/lib/dist/utilities/debugger.js

@@ -1,8 +1,8 @@
-import { FluexGLAudio } from "../index";
+import { DSP } from "../index";
 export var Debug;
 (function (Debug) {
     function Log(message, additionalDetails) {
-        if (!FluexGLAudio.options.debugger.showInfo)
+        if (!DSP.debugger.showInfo)
             return;
         let outputString = `%c[INFO]: %c${message} %c`;
         additionalDetails && additionalDetails.forEach(function (detail) {
@@ -12,7 +12,7 @@ export var Debug;
     }
     Debug.Log = Log;
     function Success(message, additionalDetails) {
-        if (!FluexGLAudio.options.debugger.showInfo)
+        if (!DSP.debugger.showInfo)
             return;
         let outputString = `%c[SUCCESS]: %c${message} %c`;
         additionalDetails && additionalDetails.forEach(function (detail) {
@@ -22,7 +22,7 @@ export var Debug;
     }
     Debug.Success = Success;
     function Warn(message, additionalDetails, warningCode) {
-        if (!FluexGLAudio.options.debugger.showWarnings)
+        if (!DSP.debugger.showWarnings)
             return;
         let outputString = `%c(${warningCode ? warningCode : "Unknown".toUpperCase()}) %c[WARNING]: %c${message} %c`;
         (additionalDetails && additionalDetails !== null) && additionalDetails.forEach(function (detail) {
@@ -32,14 +32,14 @@ export var Debug;
     }
     Debug.Warn = Warn;
     function Error(message, additionalDetails, errorCode) {
-        if (!FluexGLAudio.options.debugger.showErrors)
+        if (!DSP.debugger.showErrors)
             return;
         let outputString = `%c(${errorCode ? errorCode : "Unknown".toUpperCase()}) %c[ERROR]: %c${message} %c`;
         (additionalDetails && additionalDetails !== null) && additionalDetails.forEach(function (detail) {
             outputString += `\n\u0009  > ${detail}`;
         });
         console.log(outputString, "color: red", "color: red;", "color: white", "color: white; font-style: italic;");
-        if (FluexGLAudio.options.debugger.breakOnError) {
+        if (DSP.debugger.breakOnError) {
             for (let char of message)
                 outputString = outputString.replace("%c", "");
             throw new window.Error(outputString);

package/lib/dist/utilities/helpers.d.ts

@@ -42,5 +42,7 @@ export declare function LoadAudioSourceFromBlob(blob: Blob): Promise<AudioSource
 export declare function ConstructProcessorWorklet(code: string): string;
 export declare function LoadWorkletOnAudioDevice(audioDevice: AudioDevice, workletBlobUrl: string): Promise<boolean>;
 export declare function SendMessageToWorklet<T, K = any>(node: AudioWorkletNode | null, commandId: T, data: K): boolean;
+export declare function IsFiniteNumber(value: unknown): value is number;
+export declare function CoerceFiniteNumber(value: unknown, fallback: number): number;
 export declare function CreateAudioWorkletNode<T = any>(context: AudioContext, name: AudioWorkletProcessorNames | string, data: T): AudioWorkletNode | null;
 //# sourceMappingURL=helpers.d.ts.map

package/lib/dist/utilities/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/utilities/helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAS1D,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,gCAAgC,EAAE,8BAA8B,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAEnK;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,gCAAgC,GAAG,OAAO,CAAC,8BAA8B,GAAG,IAAI,CAAC,CAwCrI;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAUxE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAUvE;AAED;;;GAGG;AACH,wBAAsB,+BAA+B,CAAC,IAAI,EAAE,8BAA8B,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAmBvH;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAAC,IAAI,EAAE,8BAA8B,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAmBtH;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAO,CAAC,sBAAsB,CAAoC,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAoChK;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAYzF;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,oBAgB9F;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,WAOpG;AAED,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,0BAA0B,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC,2BAsBxH"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/utilities/helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAS1D,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,gCAAgC,EAAE,8BAA8B,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAEnK;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,gCAAgC,GAAG,OAAO,CAAC,8BAA8B,GAAG,IAAI,CAAC,CAwCrI;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAUxE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAUvE;AAED;;;GAGG;AACH,wBAAsB,+BAA+B,CAAC,IAAI,EAAE,8BAA8B,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAmBvH;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAAC,IAAI,EAAE,8BAA8B,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAmBtH;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAO,CAAC,sBAAsB,CAAoC,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAoChK;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAYzF;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,oBAgB9F;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,WAepG;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,0BAA0B,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC,2BA8BxH"}

package/lib/dist/utilities/helpers.js

@@ -161,9 +161,22 @@ export async function LoadWorkletOnAudioDevice(audioDevice, workletBlobUrl) {
 export function SendMessageToWorklet(node, commandId, data) {
     if (!node)
         return false;
+    if (typeof data === "number" && !Number.isFinite(data)) {
+        Debug.Warn("Refusing to send non-finite numeric value to AudioWorkletNode.", [
+            `Command: ${String(commandId)}`,
+            `Value: ${String(data)}`
+        ]);
+        return false;
+    }
     node.port.postMessage({ commandId, data });
     return true;
 }
+export function IsFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+export function CoerceFiniteNumber(value, fallback) {
+    return IsFiniteNumber(value) ? value : fallback;
+}
 export function CreateAudioWorkletNode(context, name, data) {
     if (!compiledWebAssemblyModule) {
         Debug.Error("Failed to create audio worklet node, because the web assembly module has not been compiled properly.", [
@@ -171,16 +184,26 @@ export function CreateAudioWorkletNode(context, name, data) {
         ]);
         return null;
     }
-    return new AudioWorkletNode(context, name, {
-        numberOfInputs: 1,
-        numberOfOutputs: 1,
-        outputChannelCount: [2],
-        parameterData: {
-            ...data,
-            sampleRate: context.sampleRate
-        },
-        processorOptions: {
-            module: compiledWebAssemblyModule
-        }
-    });
+    try {
+        return new AudioWorkletNode(context, name, {
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            outputChannelCount: [2],
+            parameterData: {
+                ...data,
+                sampleRate: context.sampleRate
+            },
+            processorOptions: {
+                module: compiledWebAssemblyModule
+            }
+        });
+    }
+    catch (err) {
+        Debug.Error("Failed to create audio worklet node.", [
+            `Request audio worklet node: ${name}.`,
+            "Make sure you called InitializeDspPipeline/InitializeDpsPipeline and loaded the worklet module on the same AudioContext.",
+            String(err)
+        ]);
+        return null;
+    }
 }

package/lib/src/core/classes/AudioClip.ts

@@ -1,10 +1,12 @@
 import { v4 } from "uuid";
 import { format } from "date-fns";
 
-import { AudioClipAnalyserProperty, AudioClipAnalyserType, AudioClipEventMap, AudioClipEvents, AudioSourceData } from "../../typings";
+import { AudioClipEventMap, AudioClipEvents, AudioSourceData } from "../../typings";
 import { Debug } from "../../utilities/debugger";
 import { Channel } from "./Channel";
 import { AudioClipPlayer } from "./AudioClipPlayer";
+import { Master } from "./Master";
+import { DSP } from "../../index";
 
 type ProgressPayload = Parameters<AudioClipEventMap["progress"]>[0];
 
@@ -248,9 +250,12 @@ export class AudioClip {
 
     public SetMaxAudioBufferSourceNodes(value: number): AudioClip {
 
-        Debug.Warn("Changing the amount of buffer source nodes may cause some properties of this class instance to work inproperly.", [
-            "The default value is 1."
-        ]);
+        if (!DSP.overrideMaxAudioBufferNodes) {
+            Debug.Warn("Cannot set maxAudioBufferSourceNodes because the option to override the current maximum value is disabled.", [
+                "Set overrideMaxAudioBufferNodes on DSP to true, in order to override the maximum audio buffer source nodes."
+            ]);
+            return this;
+        }
 
         this.maxAudioBufferSourceNodes = value;
         return this;
@@ -316,15 +321,26 @@ export class AudioClip {
         return this.data.audioBuffer.getChannelData(channel);
     }
 
-    public Send(channel: Channel) {
+    public Send(channel: Channel | Master) {
+
+        if (!channel.audioClipPlayer) return Debug.Error("Could not send AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
+            "Make sure to initialize the Channel.",
+            `Channel id: ${channel.id}.`,
+            `AudioClip id: ${this.id}.`
+        ]);
+
+        channel.audioClipPlayer.AttachAudioClip(this);
+    }
+
+    public Unsend(channel: Channel | Master) {
 
-        if(!channel.HasAudioClipPlayer()) return Debug.Error("Could not send AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
+        if (!channel.audioClipPlayer) return Debug.Error("Could not unsend AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
             "Make sure to initialize the Channel.",
             `Channel id: ${channel.id}.`,
             `AudioClip id: ${this.id}.`
         ]);
 
-        channel.AttachAudioClip(this);
+        channel.audioClipPlayer.DetachAudioClip(this);
     }
 
     public get currentPlaybackTime(): number {

package/lib/src/core/classes/AudioClipPlayer.ts

@@ -2,8 +2,8 @@ import { v4 } from "uuid";
 
 import { AudioClip } from "./AudioClip";
 import { Debug } from "../../utilities/debugger";
-import { Master } from "./Master";
 import { Channel } from "./Channel";
+import { Master } from "./Master";
 
 export class AudioClipPlayer {
 
@@ -14,14 +14,14 @@ export class AudioClipPlayer {
     public outputGainNode: GainNode | null = null;
 
     public context: AudioContext | null = null;
-    public channel: Channel | null = null;
+    public channel: Channel | Master | null = null;
 
     constructor(context: AudioContext) {
         this.context = context;
         this.outputGainNode = new GainNode(context);
     }
 
-    public AttachAudioClip(audioClip: AudioClip) {
+    public AttachAudioClip(audioClip: AudioClip): void {
 
         if (this.audioClips.includes(audioClip)) return Debug.Error("Could not attach audio clip because it is already part of this channel", [
             "Call .DetachAudioClip([clip AudioClip]) before attaching audio clip."
@@ -31,15 +31,75 @@ export class AudioClipPlayer {
         this.audioClips.push(audioClip);
     }
 
-    public Send(channel: Channel) {
+    public DetachAudioClip(clip: AudioClip): void {
+
+        if (!this.audioClips.includes(clip)) return Debug.Error("Could not detach audio clip because it is not part of this channel", [
+            "Call .AttachAudioClip([clip AudioClip]) before detaching audio clip."
+        ]);
 
-        if(!this.outputGainNode || !channel.input) return Debug.Error("Could not send AudioClipPlayer signal to a channel.");
+        clip.Stop();
+
+        const self = this;
+
+        this.audioClips.forEach(function (_clip: AudioClip, index: number) {
+            if (clip.id === _clip.id)
+                return self.audioClips.splice(index, 1);
+        })
+    }
+
+    public Send(channel: Channel | Master): void {
+
+        if (!this.outputGainNode || !channel.input) return Debug.Error("Could not send AudioClipPlayer signal to a channel/master.");
+
+        this.Unsend();
 
         this.channel = channel;
         this.outputGainNode.connect(channel.input);
     }
 
-    public SetLabel(label: string) {
+    public Unsend(): void {
+
+        if (!this.outputGainNode) return;
+
+        if (this.channel && this.channel.input) {
+            this.outputGainNode.disconnect(this.channel.input);
+        } else {
+            this.outputGainNode.disconnect();
+        }
+
+        this.channel = null;
+    }
+
+    public SetVolume(value: number): void {
+
+        if (!this.outputGainNode) return;
+
+        if (value < 0) value = 0;
+        if (value > 1) value = 1;
+
+        this.outputGainNode.gain.value = value;
+    }
+
+    public StopAll(): void {
+
+        this.audioClips.forEach(function (clip: AudioClip) {
+            clip.Stop();
+        });
+    }
+
+    public Dispose(): void {
+
+        this.StopAll();
+        this.Unsend();
+        this.outputGainNode?.disconnect();
+        
+        this.audioClips = [];
+        this.outputGainNode = null;
+        this.channel = null;
+        this.context = null;
+    }
+
+    public SetLabel(label: string): void {
         this.label = label;
     }
-}
+}

package/lib/src/core/classes/AudioDevice.ts

@@ -1,6 +1,7 @@
 import { v4 } from "uuid";
 
 import { Master } from "./Master";
+import { Channel } from "./Channel";
 
 import { ErrorCodes } from "../../console-codes";
 import { Debug } from "../../utilities/debugger";
@@ -42,4 +43,8 @@ export class AudioDevice {
     public GetContext(): AudioContext {
         return this.context;
     }
+
+    public CreateChannel(): Channel {
+        return new Channel(this.context);
+    }
 }

package/lib/src/core/classes/Channel.ts

@@ -3,6 +3,7 @@ import { Debug } from "../../utilities/debugger";
 import { AudioClipPlayer } from "./AudioClipPlayer";
 import { AudioClip } from "./AudioClip";
 import { Master } from "./Master";
+import { Effector } from "./Effector";
 
 export class Channel {
 
@@ -15,10 +16,11 @@ export class Channel {
     public gainNode: GainNode | null = null;
     public output: AudioNode | null = null;
 
+    public effects: Effector[] = [];
     public context: AudioContext | null = null;
 
-    private sends: Channel[] = [];
-    private audioClipPlayer: AudioClipPlayer | null = null;
+    public sends: Channel[] = [];
+    public audioClipPlayer: AudioClipPlayer | null = null;
 
     constructor(context: AudioContext) {
         this.context = context;
@@ -41,6 +43,92 @@ export class Channel {
         this.audioClipPlayer.Send(this);
     }
 
+    private rebuildEffectChain(): void {
+
+        if (!this.input || !this.stereoPannerNode) {
+            Debug.Error("Could not rebuild effect chain because one or more required audio nodes are undefined.", [
+                `Channel id: ${this.id}.`,
+                `Input defined: ${!!this.input}.`,
+                `StereoPannerNode defined: ${!!this.stereoPannerNode}.`
+            ]);
+            return;
+        }
+
+        this.input.disconnect();
+
+        for (const effect of this.effects)
+            effect.audioWorkletNode?.disconnect();
+
+        const activeEffects = this.effects.filter(function (e: Effector): boolean {
+            return !!e.audioWorkletNode;
+        });
+
+        if (activeEffects.length === 0) {
+            this.input.connect(this.stereoPannerNode);
+            return;
+        }
+
+        this.input.connect(activeEffects[0].audioWorkletNode as AudioNode);
+
+        for (let i: number = 0; i < activeEffects.length - 1; i++) {
+            
+            const current = activeEffects[i].audioWorkletNode as AudioNode;
+            const next = activeEffects[i + 1].audioWorkletNode as AudioNode;
+
+            current.connect(next);
+        }
+
+        (activeEffects[activeEffects.length - 1].audioWorkletNode as AudioNode).connect(this.stereoPannerNode);
+    }
+
+    public AddEffect(effect: Effector): void {
+
+        if (!this.context) {
+            Debug.Error("Could not add effect because this channel has no AudioContext.");
+            return;
+        }
+
+        if (this.effects.includes(effect)) {
+            Debug.Error("Could not add effect because it is already part of this channel", [
+                "Call .RemoveEffect([effect Effector]) before adding effect."
+            ]);
+            return;
+        }
+
+        this.effects.push(effect);
+        effect.InitializeOnAttachment(this.context);
+        this.rebuildEffectChain();
+    }
+
+    public AttachEffect(effect: Effector): void {
+        return this.AddEffect(effect);
+    }
+
+    public RemoveEffect(effect: Effector): void {
+
+        if (!this.effects.includes(effect)) {
+            Debug.Error("Could not remove effect, because it is not part of this channel.", [
+                "Call .AddEffect([effect Effector]) before removing effect."
+            ]);
+            return;
+        }
+
+        const self: Channel = this;
+
+        this.effects.forEach(function (_effect: Effector, index: number): void {
+            if (effect.id === _effect.id)
+                self.effects.splice(index, 1);
+        });
+
+        effect.audioWorkletNode?.disconnect();
+
+        this.rebuildEffectChain();
+    }
+
+    public DetachEffect(effect: Effector): void {
+        return this.RemoveEffect(effect);
+    }
+
     private disconnectAudioNodes(gc?: boolean) {
 
         this.input?.disconnect();
@@ -49,6 +137,10 @@ export class Channel {
         this.gainNode?.disconnect();
         this.output?.disconnect();
 
+        for (const effect of this.effects) {
+            effect.audioWorkletNode?.disconnect();
+        }
+
         if (gc) {
             this.input = null;
             this.stereoPannerNode = null;
@@ -88,7 +180,8 @@ export class Channel {
 
     public Send(channel: Channel | Master) {
 
-        if (channel instanceof Master) return (channel as Master).AttachChannel(this);
+        if (channel instanceof Master)
+            return (channel as Master).AttachChannel(this);
 
         if (channel.id === this.id) return Debug.Error("Could not link channel to itself.", [
             `This channel id: ${this.id}`
@@ -121,7 +214,7 @@ export class Channel {
 
     public Unsend(channel: Channel | Master) {
 
-        if(channel instanceof Master) 
+        if (channel instanceof Master)
             return (channel as Master).DetachChannel(this);
 
         const idx: number = this.sends.indexOf(channel);

package/lib/src/core/classes/DpsPipeline.ts

@@ -7,6 +7,7 @@ import { ConstructProcessorWorklet, LoadWorkletOnAudioDevice } from "../../utili
 
 import { ErrorCodes, WarningCodes } from "../../console-codes";
 import { DspPipelineInitializationOptions } from "../../typings";
+import { DSP } from "../../index";
 
 /**
  * Represents the digital signal processing (DSP) pipeline responsible for initializing
@@ -45,9 +46,12 @@ export class DspPipeline {
      * @param options - Initialization options for the DSP pipeline.
      * Must include valid paths to the WebAssembly and AudioWorklet files.
      */
-    constructor(options: DspPipelineInitializationOptions) {
-        this.pathToWasm = options.pathToWasm;
-        this.pathToWorklet = options.pathToWorklet;
+    constructor({ pathToWasm, pathToWorklet, options }: DspPipelineInitializationOptions) {
+        this.pathToWasm = pathToWasm;
+        this.pathToWorklet = pathToWorklet;
+
+        // @ts-ignore
+        for(const key in options) DSP[key] = options[key];
     }
 
     /**

package/lib/src/core/classes/Effector.ts

@@ -8,8 +8,9 @@ export abstract class Effector {
     public id: string = v4();
     public label: string | null = null;
     public name: string = "Effector";
+
     public audioWorkletNode: AudioWorkletNode | null = null;
-    public parentialContext: AudioContext | null = null;
+    public context: AudioContext | null = null;
 
     private hasRegisteredMessageEventListener: boolean = false;
 
@@ -88,5 +89,5 @@ export abstract class Effector {
         return this;
     }
 
-    public abstract InitializeOnAttachment(parentialContext: AudioContext): Promise<void>;
+    public abstract InitializeOnAttachment(context: AudioContext): Promise<void>;
 }

package/lib/src/core/classes/Master.ts

@@ -1,29 +1,107 @@
 import { v4 } from "uuid";
 
 import { Channel } from "./Channel";
-
 import { Debug } from "../../utilities/debugger";
+import { Effector } from "./Effector";
 import { AudioClipPlayer } from "./AudioClipPlayer";
+import { AudioClip } from "./AudioClip";
 
 export class Master {
 
     public id: string = v4();
+
     public channels: Channel[] = [];
+    public effects: Effector[] = [];
 
+    public input: GainNode | null = null;
     public gainNode: GainNode | null = null;
     public analyserNode: AnalyserNode | null = null;
-
     public context: AudioContext | null = null;
+    public audioClipPlayer: AudioClipPlayer | null = null;
 
     constructor(context: AudioContext) {
 
         this.context = context;
 
+        this.disconnectAudioNodes();
+
+        this.audioClipPlayer = new AudioClipPlayer(context);
+
+        this.input = new GainNode(context);
         this.gainNode = new GainNode(context);
         this.analyserNode = new AnalyserNode(context);
 
+        this.input.connect(this.gainNode);
         this.gainNode.connect(this.analyserNode);
         this.analyserNode.connect(this.context.destination);
+
+        this.audioClipPlayer.Send(this);
+    }
+
+    private disconnectAudioNodes(): void {
+
+        if (this.input) this.input.disconnect();
+        if (this.gainNode) this.gainNode.disconnect();
+        if (this.analyserNode) this.analyserNode.disconnect();
+
+        this.effects.forEach(function (effect: Effector) {
+            if (effect.audioWorkletNode)
+                effect.audioWorkletNode.disconnect();
+        });
+    }
+
+    private rebuildEffectChain(): void {
+
+        if (!this.context) return;
+        if (!this.input || !this.gainNode || !this.analyserNode) return;
+
+        this.disconnectAudioNodes();
+
+        let currentNode: AudioNode = this.input;
+
+        this.effects.forEach(function (effect: Effector) {
+
+            if (!effect.audioWorkletNode) return;
+
+            currentNode.connect(effect.audioWorkletNode);
+            currentNode = effect.audioWorkletNode;
+        });
+
+        currentNode.connect(this.gainNode);
+
+        this.gainNode.connect(this.analyserNode);
+        this.analyserNode.connect(this.context.destination);
+    }
+
+    public AttachEffect(effect: Effector): void {
+
+        if (this.effects.includes(effect)) return Debug.Error("Could not attach the effect because it is already part of this master channel.", [
+            "Call .DetachEffect([effect Effector]) before attaching the effect."
+        ]);
+
+        if(!this.context) return this.rebuildEffectChain();
+
+        this.effects.push(effect);
+        effect.InitializeOnAttachment(this.context);
+        this.rebuildEffectChain();
+    }
+
+    public DetachEffect(effect: Effector): void {
+
+        if (!this.effects.includes(effect)) return Debug.Error("Could not detach the effect because it is not part of this master channel.", [
+            "Call .AttachEffect([effect Effector]) before detaching the effect."
+        ]);
+
+        const self = this;
+
+        this.effects.forEach(function (_effect: Effector, index: number) {
+            if (effect.id === _effect.id) {
+                self.effects.splice(index, 1);
+                return;
+            }
+        });
+
+        this.rebuildEffectChain();
     }
 
     public AttachChannel(channel: Channel): void {
@@ -34,9 +112,9 @@ export class Master {
 
         this.channels.push(channel);
 
-        if (channel.output && this.gainNode)
-            channel.output.connect(this.gainNode);
-        
+        if (channel.output && this.input)
+            channel.output.connect(this.input);
+
         return;
     }
 
@@ -46,17 +124,26 @@ export class Master {
             "Call .AttachChannel([channel Channel]) before detaching the channel."
         ]);
 
-        if (channel.output && this.gainNode)
-            channel.output.disconnect(this.gainNode);
+        if (channel.output && this.input)
+            channel.output.disconnect(this.input);
 
         const self = this;
 
         this.channels.forEach(function (_channel: Channel, index: number) {
-            if (channel.id === _channel.id) {
+            if (channel.id !== _channel.id) return;
 
-                self.channels.splice(index, 1);
-                return;
-            }
+            self.channels.splice(index, 1);
         });
     }
+
+    public HasAudioClipPlayer(): boolean {
+        return !!this.audioClipPlayer;
+    }
+
+    public AttachAudioClip(audioClip: AudioClip) {
+
+        if (!this.audioClipPlayer) return Debug.Error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
+
+        this.audioClipPlayer.AttachAudioClip(audioClip);
+    }
 }