cacophony 0.1.3 → 0.1.5

package/README.md

@@ -32,7 +32,7 @@ async function playSampleSound() {
   const sound = await cacophony.createSound('path/to/your/audio/file.mp3');
 
   sound.play();
-  sound.moveTo(1, 1, 1); // Position the sound in 3D space
+  sound.position = [1, 1, 1]; // Position the sound in 3D space
 }
 
 playSampleSound();
@@ -94,7 +94,7 @@ All classes representing sound sources (`Sound`, `Playback`, `Group`) offer the
 - `resume()`
 - `addFilter(filter: BiquadFilterNode)`
 - `removeFilter(filter: BiquadFilterNode)`
-- `moveTo(x: number, y: number, z: number)`
+- `position`: A tuple `[x: number, y: number, z: number]` representing the position of the sound in 3D space, with both getter and setter.
 - `loop(loopCount?: LoopCount)`: `LoopCount` can be a finite number or 'infinite'.
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacophony",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Typescript audio library with caching",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cacophony.ts

@@ -8,7 +8,9 @@ type BiquadFilterNode = IBiquadFilterNode<AudioContext>;
 type AudioBufferSourceNode = IAudioBufferSourceNode<AudioContext>;
 type PannerNode = IPannerNode<AudioContext>;
 
-type LoopCount = number | 'infinite';
+export type Position = [number, number, number];
+
+export type LoopCount = number | 'infinite';
 
 export type FadeType = 'linear' | 'exponential'
 
@@ -20,9 +22,8 @@ export interface BaseSound {
     resume(): void;
     addFilter(filter: BiquadFilterNode): void;
     removeFilter(filter: BiquadFilterNode): void;
-    moveTo(x: number, y: number, z: number): void;
     volume: number;
-
+    position: Position;
     loop(loopCount?: LoopCount): LoopCount;
 }
 
@@ -138,7 +139,7 @@ export class Sound extends FilterManager implements BaseSound {
     context: AudioContext;
     playbacks: Playback[] = [];
     globalGainNode: GainNode;
-    position: number[] = [0, 0, 0];
+    private _position: Position = [0, 0, 0];
     loopCount: LoopCount = 0;
 
     constructor(buffer: AudioBuffer, context: AudioContext, globalGainNode: IGainNode<AudioContext>) {
@@ -146,6 +147,7 @@ export class Sound extends FilterManager implements BaseSound {
         this.buffer = buffer;
         this.context = context;
         this.globalGainNode = globalGainNode;
+        this._position = [0, 0, 0];
     }
 
     preplay(): Playback[] {
@@ -156,14 +158,14 @@ export class Sound extends FilterManager implements BaseSound {
         gainNode.connect(this.globalGainNode);
         const playback = new Playback(source, gainNode, this.context, this.loopCount);
         this.filters.forEach(filter => playback.addFilter(filter));
-        playback.moveTo(this.position[0], this.position[1], this.position[2]);
+        playback.position = this.position;
         this.playbacks.push(playback);
         return [playback];
     }
 
     play(): Playback[] {
         const playback = this.preplay();
-        playback.forEach(p => p.source.start());
+        playback.forEach(p => p.source!.start());
         return playback;
     }
 
@@ -183,9 +185,13 @@ export class Sound extends FilterManager implements BaseSound {
         }
     }
 
-    moveTo(x: number, y: number, z: number): void {
-        this.position = [x, y, z];
-        this.playbacks.forEach(p => p.moveTo(x, y, z));
+    set position(position: Position) {
+        this._position = position;
+        this.playbacks.forEach(p => p.position = this._position);
+    }
+
+    get position(): Position {
+        return this._position;
     }
 
     loop(loopCount?: LoopCount): LoopCount {
@@ -193,7 +199,7 @@ export class Sound extends FilterManager implements BaseSound {
             return this.loopCount;
         }
         this.loopCount = loopCount;
-        this.playbacks.forEach(p => p.source.loop = true);
+        this.playbacks.forEach(p => p.source!.loop = true);
         return this.loopCount;
     }
 
@@ -219,9 +225,9 @@ export class Sound extends FilterManager implements BaseSound {
 
 class Playback extends FilterManager implements BaseSound {
     context: AudioContext;
-    source: AudioBufferSourceNode;
-    gainNode: GainNode;
-    panner: PannerNode;
+    source?: AudioBufferSourceNode;
+    gainNode?: GainNode;
+    panner?: PannerNode;
     loopCount: LoopCount = 0;
     currentLoop: number = 0;
     buffer: IAudioBuffer | null = null;
@@ -250,36 +256,68 @@ class Playback extends FilterManager implements BaseSound {
     }
 
     play() {
+        if (!this.source) {
+            throw new Error('Cannot play a sound that has been cleaned up');
+        }
         this.source.start();
         return [this];
     }
 
     get volume(): number {
+        if (!this.gainNode) {
+            throw new Error('Cannot get volume of a sound that has been cleaned up');
+        }
         return this.gainNode.gain.value;
     }
 
     set volume(v: number) {
+        if (!this.gainNode) {
+            throw new Error('Cannot set volume of a sound that has been cleaned up');
+        }
         this.gainNode.gain.value = v;
     }
 
-    fadeIn(time: number, FfadeType: FadeType = 'linear'): Promise<void> {
+    fadeIn(time: number, fadeType: FadeType = 'linear'): Promise<void> {
         return new Promise(resolve => {
-            let volume = 0;
-            const increment = this.gainNode.gain.value / (time * 60); // Assuming time is in seconds
-            const interval = setInterval(() => {
-                volume += increment;
-                this.gainNode.gain.value = volume;
-                if (volume >= this.gainNode.gain.value) {
-                    clearInterval(interval);
-                    resolve();
+            if (!this.gainNode) {
+                throw new Error('Cannot fade in a sound that has been cleaned up');
+            }
+
+            const initialVolume = this.gainNode.gain.value;
+            const targetVolume = 1; // Assuming the target volume after fade-in is 1 (full volume)
+
+            // Reset volume to 0 to start the fade-in process
+            this.gainNode.gain.value = 0;
+
+            switch (fadeType) {
+                case 'exponential':
+                    // Start at a low value (0.01) because exponentialRampToValueAtTime cannot ramp from 0
+                    this.gainNode.gain.setValueAtTime(0.01, this.context.currentTime);
+                    this.gainNode.gain.exponentialRampToValueAtTime(targetVolume, this.context.currentTime + time);
+                    break;
+                case 'linear':
+                    this.gainNode.gain.linearRampToValueAtTime(targetVolume, this.context.currentTime + time);
+                    break;
+            }
+
+            // Resolve the Promise after the fade-in time
+            setTimeout(() => {
+                // Ensure the final volume is set to the target volume
+                if (!this.gainNode) {
+                    throw new Error('Cannot fade in a sound that has been cleaned up');
                 }
-            }, 1000 / 60); // 60 times per second
+                this.gainNode.gain.value = targetVolume;
+                resolve();
+            }, time * 1000);
         });
     }
 
     fadeOut(time: number, fadeType: FadeType = 'linear'): Promise<void> {
         return new Promise(resolve => {
             // Storing the current gain value
+            if (!this.gainNode) {
+                throw new Error('Cannot fade out a sound that has been cleaned up');
+            }
             const initialVolume = this.gainNode.gain.value;
             switch (fadeType) {
                 case 'exponential':
@@ -296,7 +334,23 @@ class Playback extends FilterManager implements BaseSound {
         });
     }
 
+    cleanup(): void {
+        if (this.source) {
+            this.source.disconnect();
+            this.source = undefined;
+        }
+        if (this.gainNode) {
+            this.gainNode.disconnect();
+            this.gainNode = undefined;
+        }
+        this.filters.forEach(filter => filter.disconnect());
+        this.filters = [];
+    }
+
     loop(loopCount?: LoopCount): LoopCount {
+        if (!this.source) {
+            throw new Error('Cannot loop a sound that has been cleaned up');
+        }
         if (loopCount === undefined) {
             return this.source.loop === true ? 'infinite' : 0;
         }
@@ -307,16 +361,25 @@ class Playback extends FilterManager implements BaseSound {
     }
 
     stop(): void {
+        if (!this.source) {
+            throw new Error('Cannot stop a sound that has been cleaned up');
+        }
         this.source.stop();
     }
 
     pause(): void {
+        if (!this.source) {
+            throw new Error('Cannot pause a sound that has been cleaned up');
+        }
         if ('suspend' in this.source.context) {
             this.source.context.suspend();
         }
     }
 
     resume(): void {
+        if (!this.source) {
+            throw new Error('Cannot resume a sound that has been cleaned up');
+        }
         if ('resume' in this.source.context) {
             this.source.context.resume();
         }
@@ -332,13 +395,27 @@ class Playback extends FilterManager implements BaseSound {
         this.refreshFilters();
     }
 
-    moveTo(x: number, y: number, z: number): void {
+    set position(position: Position) {
+        if (!this.panner) {
+            throw new Error('Cannot move a sound that has been cleaned up');
+        }
+        const [x, y, z] = position;
         this.panner.positionX.value = x;
         this.panner.positionY.value = y;
         this.panner.positionZ.value = z;
     }
 
+    get position(): Position {
+        if (!this.panner) {
+            throw new Error('Cannot get position of a sound that has been cleaned up');
+        }
+        return [this.panner.positionX.value, this.panner.positionY.value, this.panner.positionZ.value];
+    }
+
     private refreshFilters(): void {
+        if (!this.source || !this.gainNode) {
+            throw new Error('Cannot update filters on a sound that has been cleaned up');
+        }
         let connection = this.source;
         this.source.disconnect();
         connection = this.applyFilters(connection);
@@ -349,7 +426,7 @@ class Playback extends FilterManager implements BaseSound {
 
 export class Group implements BaseSound {
     sounds: Sound[] = [];
-    position: number[] = [0, 0, 0];
+    private _position: Position = [0, 0, 0];
     loopCount: LoopCount = 0;
 
     addSound(sound: Sound): void {
@@ -403,18 +480,21 @@ export class Group implements BaseSound {
         this.sounds.forEach(sound => sound.removeFilter(filter));
     }
 
-    moveTo(x: number, y: number, z: number): void {
-        this.position = [x, y, z];
-        this.sounds.forEach(sound => sound.moveTo(x, y, z));
+    set position(position: [number, number, number]) {
+        this._position = position;
+        this.sounds.forEach(sound => sound.position = this._position);
+    }
+
+    get position(): [number, number, number] {
+        return this._position;
     }
 
     get volume(): number {
-        return this.sounds[0].volume;
+        return this.sounds.map(sound => sound.volume).reduce((a, b) => a + b, 0) / this.sounds.length;
     }
 
     set volume(volume: number) {
         this.sounds.forEach(sound => sound.volume = volume);
     }
-
 }