@fluex/fluexgl-dsp 0.4.7 → 0.4.8

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

@@ -22,43 +22,41 @@ export class AudioClipPlayer {
         this.outputGainNode = new GainNode(context);
     }
 
-    public AttachAudioClip(audioClip: AudioClip): void {
+    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."
+        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."
         ], ErrorCodes.AUDIO_CLIP_ALREADY_ATTACHED);
 
-        audioClip.Initialize(this);
+        audioClip.initialize(this);
         this.audioClips.push(audioClip);
     }
 
-    public DetachAudioClip(clip: AudioClip): void {
+    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.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."
         ], ErrorCodes.AUDIO_CLIP_NOT_FOUND);
 
-        clip.Stop();
+        const idx = this.audioClips.indexOf(clip);
 
-        const self = this;
+        if (idx >= 0)
+            this.audioClips.splice(idx, 1);
 
-        this.audioClips.forEach(function (_clip: AudioClip, index: number) {
-            if (clip.id === _clip.id)
-                return self.audioClips.splice(index, 1);
-        })
+        clip.detachFromAudioClipPlayer(this);
     }
 
-    public Send(channel: Channel | Master): void {
+    public send(channel: Channel | Master): void {
 
-        if (!this.outputGainNode || !channel.input) return Debug.Error("Could not send AudioClipPlayer signal to a channel/master.");
+        if (!this.outputGainNode || !channel.input) return Debug.error("Could not send AudioClipPlayer signal to a channel/master.");
 
-        this.Unsend();
+        this.unsend();
 
         this.channel = channel;
         this.outputGainNode.connect(channel.input);
     }
 
-    public Unsend(): void {
+    public unsend(): void {
 
         if (!this.outputGainNode) return;
 
@@ -71,7 +69,7 @@ export class AudioClipPlayer {
         this.channel = null;
     }
 
-    public SetVolume(value: number): void {
+    public setVolume(value: number): void {
 
         if (!this.outputGainNode) return;
 
@@ -81,17 +79,17 @@ export class AudioClipPlayer {
         this.outputGainNode.gain.value = value;
     }
 
-    public StopAll(): void {
+    public stopAll(): void {
 
         this.audioClips.forEach(function (clip: AudioClip) {
-            clip.Stop();
+            clip.stop();
         });
     }
 
-    public Dispose(): void {
+    public dispose(): void {
 
-        this.StopAll();
-        this.Unsend();
+        this.stopAll();
+        this.unsend();
         this.outputGainNode?.disconnect();
         
         this.audioClips = [];
@@ -100,7 +98,7 @@ export class AudioClipPlayer {
         this.context = null;
     }
 
-    public SetLabel(label: string): void {
+    public setLabel(label: string): void {
         this.label = label;
     }
 

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

@@ -16,15 +16,34 @@ export class AudioDevice {
     public masterChannel: Master = new Master(this.context);
     public masterChannels: Master[] = [];
 
+    readonly sampleRate: number = this.context.sampleRate;
+    readonly baseLatency: number = this.context.baseLatency;
+    readonly outputLatency: number = this.context.outputLatency;
+    readonly state: AudioContextState = this.context.state;
+    readonly currentTime: number = this.context.currentTime;
+
+    readonly maximumFrequency: number = this.context.sampleRate / 2;
+
     constructor(public deviceInfo: MediaDeviceInfo) {};
 
-    public GetMasterChannel(): Master {
+    /**
+     * Returns the master channel associated with this audio device.
+     * The master channel is the main output channel for this audio device, and is used to control the overall volume and other properties of the audio output.
+     * @returns 
+     */
+    public getMasterChannel(): Master {
         return this.masterChannel;
     }
 
-    public SetMasterChannel(channel: Master): void {
+    /**
+     * Sets the master channel for this audio device. 
+     * The master channel is normally automatically created when the audio device is initialized, but this method allows for the master channel to be changed if needed.  
+     * @param channel 
+     * @returns 
+     */
+    public setMasterChannel(channel: Master): void {
 
-        if (channel.id === this.masterChannel.id) return Debug.Error("The provided master channel is the same as the current channel.", [
+        if (channel.id === this.masterChannel.id) return Debug.error("The provided master channel is the same as the current channel.", [
             "Provide this method with a different master channel.",
             `Received master channel ID ${channel.id}.`
         ], ErrorCodes.SAME_MASTER_CHANNEL);
@@ -32,7 +51,12 @@ export class AudioDevice {
         this.masterChannel = channel;
     }
 
-    public CreateMasterChannel(): Master {
+    /**
+     * Creates a new master channel based on the this audio device's audio context, and adds it to the master channels array.
+     * Normally, an audio device should only have one master channel, but this method allows for multiple master channels to be created and used if needed.
+     * @returns 
+     */
+    public createMasterChannel(): Master {
 
         const master = new Master(this.context);
 
@@ -40,11 +64,30 @@ export class AudioDevice {
         return master;
     }
 
-    public GetContext(): AudioContext {
+    /**
+     * Returns the audio context associated with this audio device.
+     * This method is provided for ease of use, and is a wrapper for the context property.
+     * 
+     * The audio context can vary between audio devices, and is used to create channels and master channels that are associated with this audio device.
+     */
+    public getContext(): AudioContext {
         return this.context;
     }
 
-    public CreateChannel(label?: string): Channel {
+    /**
+     * Creates a new channel based on the this audio device's audio context.
+     * This method is a wrapper for the Channel constructor, and is provided for ease of use.
+     * In case you want to create a channel with a different audio context, you can use the Channel constructor directly.
+     * 
+     * @example 
+     * ```
+     * const myChannel: Channel = audioDevice.createChannel("My Channel");
+     * ```
+     * 
+     * @param label 
+     * @returns 
+     */
+    public createChannel(label?: string): Channel {
         return new Channel(this.context, label);
     }
 }

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

@@ -44,13 +44,13 @@ export class Channel {
         this.analyserNode.connect(this.gainNode);
         this.gainNode.connect(this.output);
 
-        this.audioClipPlayer.Send(this);
+        this.audioClipPlayer.send(this);
     }
 
-    private rebuildEffectChain(): void {
+    private rebuildEffectChainInternal(): void {
 
         if (!this.input || !this.stereoPannerNode) {
-            Debug.Error("Could not rebuild effect chain because one or more required audio nodes are undefined.", [
+            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}.`
@@ -140,11 +140,11 @@ export class Channel {
      * work properly.
      * @returns 
      */
-    public RebuildEffectChain() {
-        return this.rebuildEffectChain();
+    public rebuildEffectChain() {
+        return this.rebuildEffectChainInternal();
     }
 
-    public AddEffect(effect: Effector): Channel {
+    public addEffect(effect: Effector): Channel {
 
         if (!this.context)
             throw new Error(`Could not add effect (${effect.id}), to channel (${this.id}), because the channel's AudioContext is undefined.`);
@@ -153,20 +153,20 @@ export class Channel {
             throw new Error(`Could not add effect (${effect.id}), to channel (${this.id}), because it has already been added to the channel.`);
 
         this.effects.push(effect);
-        effect.InitializeOnAttachment(this.context);
-        this.rebuildEffectChain();
+        effect.initializeOnAttachment(this.context);
+        this.rebuildEffectChainInternal();
         return this;
     }
 
-    public AttachEffect(effect: Effector): Channel {
-        return this.AddEffect(effect);
+    public attachEffect(effect: Effector): Channel {
+        return this.addEffect(effect);
     }
 
-    public RemoveEffect(effect: Effector): void {
+    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."
+            Debug.error("Could not remove effect, because it is not part of this channel.", [
+                "Call .addEffect([effect Effector]) before removing effect."
             ], ErrorCodes.EFFECT_NOT_FOUND);
             return;
         }
@@ -180,48 +180,48 @@ export class Channel {
 
         effect.audioWorkletNode?.disconnect();
 
-        this.rebuildEffectChain();
+        this.rebuildEffectChainInternal();
     }
 
-    public RemoveAllEffects() {
+    public removeAllEffects() {
         for (const effect of this.effects) {
-            this.RemoveEffect(effect);
+            this.removeEffect(effect);
         }
     }
 
-    public DetachEffect(effect: Effector): void {
-        return this.RemoveEffect(effect);
+    public detachEffect(effect: Effector): void {
+        return this.removeEffect(effect);
     }
 
-    public DetachAllEffects() {
-        return this.RemoveAllEffects();
+    public detachAllEffects() {
+        return this.removeAllEffects();
     }
 
-    public Send(channel: Channel | Master) {
+    public send(channel: Channel | Master) {
 
         if (channel instanceof Master)
-            return (channel as Master).AttachChannel(this);
+            return (channel as Master).attachChannel(this);
 
-        if (channel.id === this.id) return Debug.Error("Could not link channel to itself.", [
+        if (channel.id === this.id) return Debug.error("Could not link channel to itself.", [
             `This channel id: ${this.id}`
         ], ErrorCodes.CHANNEL_CANNOT_LINK_TO_ITSELF);
 
-        if (!this.isInitialized() || !channel.isInitialized()) return Debug.Error("Could not link channels because one (or both) channels are not initialized.", [
+        if (!this.isInitialized() || !channel.isInitialized()) return Debug.error("Could not link channels because one (or both) channels are not initialized.", [
             `This channel id: ${this.id} initialized: ${this.isInitialized()}`,
             `Target channel id: ${channel.id} initialized: ${channel.isInitialized()}`
         ], ErrorCodes.CHANNEL_NOT_INITIALIZED);
 
-        if (this.context !== channel.context) return Debug.Error("Could not link channels because they do not share the same AudioContext.", [
+        if (this.context !== channel.context) return Debug.error("Could not link channels because they do not share the same AudioContext.", [
             `This channel context: ${this.context ? "set" : "null"}`,
             `Target channel context: ${channel.context ? "set" : "null"}`
         ], ErrorCodes.CHANNEL_NOT_SAME_AUDIO_CONTEXT);
 
-        if (this.sends.includes(channel)) return Debug.Error("Could not link channels, because the given channel is already linked with this one.", [
+        if (this.sends.includes(channel)) return Debug.error("Could not link channels, because the given channel is already linked with this one.", [
             `This channel id: ${this.id}`,
             `Target channel id: ${channel.id}`
         ], ErrorCodes.CHANNEL_ALREADY_LINKED);
 
-        if (channel.isReachable(this)) return Debug.Error("Could not link channels because it would create a feedback loop.", [
+        if (channel.isReachable(this)) return Debug.error("Could not link channels because it would create a feedback loop.", [
             `This channel id: ${this.id}`,
             `Target channel id: ${channel.id}`
         ], ErrorCodes.CHANNEL_POSSIBLE_FEEDBACK_LOOP);
@@ -231,10 +231,10 @@ export class Channel {
         this.sends.push(channel);
     }
 
-    public Unsend(channel: Channel | Master) {
+    public unsend(channel: Channel | Master) {
 
         if (channel instanceof Master)
-            return (channel as Master).DetachChannel(this);
+            return (channel as Master).detachChannel(this);
 
         const idx: number = this.sends.indexOf(channel);
 
@@ -246,26 +246,26 @@ export class Channel {
         this.sends.splice(idx, 1);
     }
 
-    public HasAudioClipPlayer(): boolean {
+    public hasAudioClipPlayer(): boolean {
         return !!this.audioClipPlayer;
     }
 
-    public UnsendToAllChannels() {
+    public unsendToAllChannels() {
         for (var i: number = 0; i < this.sends.length; i++) {
-            this.Unsend(this.sends[i]);
+            this.unsend(this.sends[i]);
             i--;
         }
     }
 
-    public AttachAudioClip(audioClip: AudioClip): Channel {
+    public attachAudioClip(audioClip: AudioClip): Channel {
 
         if (!this.audioClipPlayer) throw Error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
 
-        this.audioClipPlayer.AttachAudioClip(audioClip);
+        this.audioClipPlayer.attachAudioClip(audioClip);
         return this;
     }
 
-    public Volume(volume?: number): number {
+    public volume(volume?: number): number {
 
         if (!this.context) throw new Error("Could not set volume on channel, because it's context is undefined.");
         if (!this.gainNode) throw new Error("Could not set volume on channel, because it's GainNode is undefined.")
@@ -274,7 +274,7 @@ export class Channel {
         return volume ?? this.gainNode.gain.value;
     }
 
-    public Pan(pan?: number): number {
+    public pan(pan?: number): number {
 
         if (!this.context) throw new Error("Could not set pan on channel, because it's context is undefined.");
         if (!this.stereoPannerNode) throw new Error("Cannot set pan on channel, because it's StereoPannerNode is undefined.");
@@ -283,27 +283,27 @@ export class Channel {
         return pan ?? this.stereoPannerNode.pan.value;
     }
 
-    public GetEffectsByLabel(label: string): Effector[] {
+    public getEffectsByLabel(label: string): Effector[] {
         return this.effects.filter(effect => effect.label === label);
     }
 
-    public GetFirstEffectByLabel(label: string): Effector | null {
+    public getFirstEffectByLabel(label: string): Effector | null {
 
         const filteredEffects: Effector[] = this.effects.filter(effect => effect.label === label);
         return filteredEffects.length !== 0 ? filteredEffects[0] : null;
     }
 
-    public GetEffectById(id: string): Effector[] {
+    public getEffectById(id: string): Effector[] {
         return this.effects.filter(effect => effect.id === id);
     }
 
-    public GetFirstEffectById(id: string): Effector | null {
+    public getFirstEffectById(id: string): Effector | null {
 
         const filteredEffects: Effector[] = this.effects.filter(effect => effect.id === id);
         return filteredEffects.length !== 0 ? filteredEffects[0] : null;
     }
 
-    public MoveEffectToIndex(effect: Effector, index: number | ArrayPosition): void {
+    public moveEffectToIndex(effect: Effector, index: number | ArrayPosition): void {
 
         let fromIndex: number = -1,
             matches: number = 0,
@@ -368,6 +368,6 @@ export class Channel {
 
         // Initializing the effect is unnessecary because it should have been intialized already
         // otherwise it could not been found. Rebuilding the effect chain is nessecary though.
-        this.rebuildEffectChain();
+        this.rebuildEffectChainInternal();
     }
 }

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

@@ -3,7 +3,7 @@ import { v4 } from "uuid";
 import { AudioDevice } from "./AudioDevice";
 import { Debug } from "../../utilities/debugger";
 import { LoadWebAssemblyModule } from "../../utilities/web-assembly";
-import { ConstructProcessorWorklet, LoadWorkletOnAudioDevice } from "../../utilities/helpers";
+import { constructProcessorWorklet, loadWorkletOnAudioDevice } from "../../utilities/helpers";
 
 import { ErrorCodes, WarningCodes } from "../../console-codes";
 import { DspPipelineInitializationOptions } from "../../typings";
@@ -56,12 +56,12 @@ export class DspPipeline {
 
     /**
      * Initializes the DSP pipeline.
-     * This is a convenience wrapper around {@link InitializeDpsPipeline}.
+     * This is a convenience wrapper around {@link initializeDpsPipeline}.
      *
      * @returns A promise resolving to `true` if the initialization succeeded, otherwise `false`.
      */
-    public async Init(): Promise<boolean> {
-        return await this.InitializeDpsPipeline();
+    public async init(): Promise<boolean> {
+        return await this.initializeDpsPipeline();
     }
 
     /**
@@ -71,26 +71,26 @@ export class DspPipeline {
      *
      * @returns A promise resolving to `true` when initialization completes successfully, otherwise `false`.
      */
-    public async InitializeDpsPipeline(): Promise<boolean> {
-        Debug.Log("Attempting to initialize DSP pipeline...");
+    public async initializeDpsPipeline(): Promise<boolean> {
+        Debug.log("Attempting to initialize DSP pipeline...");
 
         const start: number = Date.now();
 
         if (!this.pathToWasm || !this.pathToWorklet) {
-            Debug.Error("Could not initialize DSP pipeline, because the path to the WASM, or the worklet file has not been defined.");
+            Debug.error("Could not initialize DSP pipeline, because the path to the WASM, or the worklet file has not been defined.");
             return false;
         }
 
         try {
             const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-            Debug.Log(`Found ${stream.getTracks().length} media stream tracks.`);
+            Debug.log(`Found ${stream.getTracks().length} media stream tracks.`);
 
             // Stop all tracks immediately after verification
             stream.getTracks().forEach((track: MediaStreamTrack) => {
                 track.stop();
             });
         } catch (err) {
-            Debug.Error(
+            Debug.error(
                 "Permission to access media devices has not been granted.",
                 ["Make sure the user has granted FluentGL permission to access media devices."],
                 ErrorCodes.NO_CONTEXT_PERMISSION
@@ -103,30 +103,30 @@ export class DspPipeline {
         const workletFileRequest = await fetch(this.pathToWorklet);
         const textContent: string = await workletFileRequest.text();
 
-        this.blobUrl = ConstructProcessorWorklet(textContent);
+        this.blobUrl = constructProcessorWorklet(textContent);
 
         const end: number = Date.now();
         const difference: number = end - start;
 
-        Debug.Success(`Successfully initialized DSP pipeline within ${difference}ms.`);
+        Debug.success(`Successfully initialized DSP pipeline within ${difference}ms.`);
 
         return (this.hasInitialized = true);
     }
 
     /**
-     * Resolves and initializes the system’s default audio output device.
+     * Resolves and initializes the system’s default audio output device.
      * This method can only be called after the DSP pipeline has been initialized.
      *
      * @returns A promise that resolves with the default {@link AudioDevice} instance,
      * or `null` if no default device was found or initialization failed.
      */
-    public async ResolveDefaultAudioOutputDevice() {
-        Debug.Log("Attempting to resolve default audio output device...");
+    public async resolveDefaultAudioOutputDevice() {
+        Debug.log("Attempting to resolve default audio output device...");
 
         if (!this.hasInitialized || !this.blobUrl) {
-            Debug.Error(
+            Debug.error(
                 "Could not resolve default audio output device, because the required blob URL has not been created.",
-                ["Call await .InitializeDpsPipeline() before resolving default audio output device."]
+                ["Call await .initializeDpsPipeline() before resolving default audio output device."]
             );
             return null;
         }
@@ -139,19 +139,19 @@ export class DspPipeline {
                 audioDeviceInfos.push(device);
 
         devices.length === 0 &&
-            Debug.Warn("No default audio device found.", [], WarningCodes.NO_DEFAULT_AUDIO_DEVICE_FOUND);
+            Debug.warn("No default audio device found.", [], WarningCodes.NO_DEFAULT_AUDIO_DEVICE_FOUND);
 
         const defaultAudioDevice =
             devices.length === 0 ? null : new AudioDevice(audioDeviceInfos[0]);
 
         if (!defaultAudioDevice) return null;
 
-        await LoadWorkletOnAudioDevice(defaultAudioDevice, this.blobUrl);
+        await loadWorkletOnAudioDevice(defaultAudioDevice, this.blobUrl);
 
         return defaultAudioDevice;
     }
 
-    public TellMeWhatTheFuckThisWholeLibraryActuallyDoes() {
+    public tellMeWhatTheFuckThisWholeLibraryActuallyDoes() {
         return `I wanted to create a web based game and implement advanced audio, but javascript is slow so that's why this library uses Web Assembly. You dont have to use it, unless you know what the fuck you're doing. If you do, god bless you.`
     }
 }

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

@@ -43,30 +43,30 @@ export abstract class Effector {
 
         this.hasRegisteredMessageEventListener = true;
         node.port.onmessage = this.handleIncomingMessages.bind(this);
-        Debug.Log(`Succesfully registered event listener on effector ${this.name} (${this.label}) [${this.id}]`);
+        Debug.log(`Succesfully registered event listener on effector ${this.name} (${this.label}) [${this.id}]`);
     }
 
-    public AddEventListener<K extends keyof EffectorEventMap>(event: K, cb: EffectorEventMap[K]): () => void {
+    public addEventListener<K extends keyof EffectorEventMap>(event: K, cb: EffectorEventMap[K]): () => void {
 
         this.events[event].push(cb);
 
-        return () => this.RemoveEventListener(event, cb);
+        return () => this.removeEventListener(event, cb);
     }
 
-    public Once<K extends keyof EffectorEventMap>(event: K, cb: EffectorEventMap[K]): () => void {
+    public once<K extends keyof EffectorEventMap>(event: K, cb: EffectorEventMap[K]): () => void {
 
         const wrapper = ((...args: unknown[]) => {
 
             // @ts-ignore
             cb(...args);
 
-            this.RemoveEventListener(event, wrapper as unknown as EffectorEventMap[K]);
+            this.removeEventListener(event, wrapper as unknown as EffectorEventMap[K]);
         }) as unknown as EffectorEventMap[K];
 
-        return this.AddEventListener(event, wrapper);
+        return this.addEventListener(event, wrapper);
     }
 
-    public RemoveEventListener<K extends keyof EffectorEventMap>(event: K, cb: EffectorEventMap[K]): Effector {
+    public removeEventListener<K extends keyof EffectorEventMap>(event: K, cb: EffectorEventMap[K]): Effector {
 
         const arr = this.events[event];
 
@@ -79,7 +79,7 @@ export abstract class Effector {
         return this;
     }
 
-    public ClearEventListeners(event?: keyof EffectorEventMap): Effector {
+    public clearEventListeners(event?: keyof EffectorEventMap): Effector {
 
         if (event) {
             this.events[event].length = 0;
@@ -90,5 +90,5 @@ export abstract class Effector {
         return this;
     }
 
-    public abstract InitializeOnAttachment(context: AudioContext): Promise<void>;
+    public abstract initializeOnAttachment(context: AudioContext): Promise<void>;
 }

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

@@ -36,7 +36,7 @@ export class Master {
         this.gainNode.connect(this.analyserNode);
         this.analyserNode.connect(this.context.destination);
 
-        this.audioClipPlayer.Send(this);
+        this.audioClipPlayer.send(this);
     }
 
     private disconnectAudioNodes(): void {
@@ -74,23 +74,23 @@ export class Master {
         this.analyserNode.connect(this.context.destination);
     }
 
-    public AttachEffect(effect: Effector): void {
+    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.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."
         ], ErrorCodes.EFFECT_ALREADY_ATTACHED);
 
         if(!this.context) return this.rebuildEffectChain();
 
         this.effects.push(effect);
-        effect.InitializeOnAttachment(this.context);
+        effect.initializeOnAttachment(this.context);
         this.rebuildEffectChain();
     }
 
-    public DetachEffect(effect: Effector): void {
+    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."
+        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."
         ], ErrorCodes.EFFECT_NOT_FOUND);
 
         const self = this;
@@ -105,10 +105,10 @@ export class Master {
         this.rebuildEffectChain();
     }
 
-    public AttachChannel(channel: Channel): void {
+    public attachChannel(channel: Channel): void {
 
-        if (this.channels.includes(channel)) return Debug.Error("Could not attach the channel because it is already part of this master channel.", [
-            "Call .DetachChannel([channel Channel]) before attaching the channel."
+        if (this.channels.includes(channel)) return Debug.error("Could not attach the channel because it is already part of this master channel.", [
+            "Call .detachChannel([channel Channel]) before attaching the channel."
         ], ErrorCodes.CHANNEL_ALREADY_ATTACHED);
 
         this.channels.push(channel);
@@ -119,10 +119,10 @@ export class Master {
         return;
     }
 
-    public DetachChannel(channel: Channel): void {
+    public detachChannel(channel: Channel): void {
 
-        if (!this.channels.includes(channel)) return Debug.Error("Could not detach the channel because it is not part of this master channel.", [
-            "Call .AttachChannel([channel Channel]) before detaching the channel."
+        if (!this.channels.includes(channel)) return Debug.error("Could not detach the channel because it is not part of this master channel.", [
+            "Call .attachChannel([channel Channel]) before detaching the channel."
         ], ErrorCodes.CHANNEL_NOT_FOUND);
 
         if (channel.output && this.input)
@@ -137,14 +137,14 @@ export class Master {
         });
     }
 
-    public HasAudioClipPlayer(): boolean {
+    public hasAudioClipPlayer(): boolean {
         return !!this.audioClipPlayer;
     }
 
-    public AttachAudioClip(audioClip: AudioClip) {
+    public attachAudioClip(audioClip: AudioClip) {
 
-        if (!this.audioClipPlayer) return Debug.Error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
+        if (!this.audioClipPlayer) return Debug.error("Cannot not link AudioClip to this channel because this channel's AudioClipPlayer is undefined.");
 
-        this.audioClipPlayer.AttachAudioClip(audioClip);
+        this.audioClipPlayer.attachAudioClip(audioClip);
     }
 }