@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.10 → 1.0.11

package/dist/SpatialAudioManager.d.ts

@@ -26,6 +26,8 @@ export declare class SpatialAudioManager extends EventManager {
     private denoiseWorkletReady;
     private denoiseWorkletUrl?;
     private denoiserWasmBytes?;
+    private listenerPosition;
+    private listenerInitialized;
     private listenerDirection;
     constructor(options?: SpatialAudioOptions);
     getAudioContext(): AudioContext;
@@ -85,10 +87,14 @@ export declare class SpatialAudioManager extends EventManager {
      * @param lookAtPos Look-at position (where camera is pointing)
      */
     setListenerFromLSD(listenerPos: Position, cameraPos: Position, lookAtPos: Position): void;
+    private applyListenerTransform;
     removeParticipant(participantId: string): void;
     resumeAudioContext(): Promise<void>;
     getAudioContextState(): AudioContextState;
     private getDistanceConfig;
+    private applySpatialBoostIfNeeded;
+    private getDistanceBetween;
+    private calculateDistanceGain;
     private normalizePositionUnits;
     private isDenoiserEnabled;
     private ensureDenoiseWorklet;

package/dist/SpatialAudioManager.js

@@ -8,6 +8,8 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         this.participantNodes = new Map();
         this.monitoringIntervals = new Map();
         this.denoiseWorkletReady = null;
+        this.listenerPosition = { x: 0, y: 0, z: 0 };
+        this.listenerInitialized = false;
         this.listenerDirection = {
             forward: { x: 0, y: 1, z: 0 },
             up: { x: 0, y: 0, z: 1 },
@@ -227,11 +229,13 @@ class SpatialAudioManager extends EventManager_1.EventManager {
     updateSpatialAudio(participantId, position, direction) {
         const nodes = this.participantNodes.get(participantId);
         if (nodes?.panner) {
+            const distanceConfig = this.getDistanceConfig();
             const normalizedPosition = this.normalizePositionUnits(position);
+            const targetPosition = this.applySpatialBoostIfNeeded(normalizedPosition);
             // Update position (where the sound is coming from)
-            nodes.panner.positionX.setValueAtTime(normalizedPosition.x, this.audioContext.currentTime);
-            nodes.panner.positionY.setValueAtTime(normalizedPosition.y, this.audioContext.currentTime);
-            nodes.panner.positionZ.setValueAtTime(normalizedPosition.z, this.audioContext.currentTime);
+            nodes.panner.positionX.setValueAtTime(targetPosition.x, this.audioContext.currentTime);
+            nodes.panner.positionY.setValueAtTime(targetPosition.y, this.audioContext.currentTime);
+            nodes.panner.positionZ.setValueAtTime(targetPosition.z, this.audioContext.currentTime);
             // Update orientation (where the participant is facing)
             // This makes the audio source directional based on participant's direction
             if (direction) {
@@ -248,57 +252,23 @@ class SpatialAudioManager extends EventManager_1.EventManager {
                     nodes.panner.orientationZ.setValueAtTime(normZ, this.audioContext.currentTime);
                 }
             }
-        }
-    }
-    setListenerPosition(position, orientation) {
-        const { listener } = this.audioContext;
-        if (listener) {
-            const normalizedPosition = this.normalizePositionUnits(position);
-            // Store listener direction for reference
-            this.listenerDirection = {
-                forward: {
-                    x: orientation.forwardX,
-                    y: orientation.forwardY,
-                    z: orientation.forwardZ,
-                },
-                up: {
-                    x: orientation.upX,
-                    y: orientation.upY,
-                    z: orientation.upZ,
-                },
-            };
-            // Use setPosition and setOrientation for atomic updates if available
-            if (listener.positionX) {
-                listener.positionX.setValueAtTime(normalizedPosition.x, this.audioContext.currentTime);
-                listener.positionY.setValueAtTime(normalizedPosition.y, this.audioContext.currentTime);
-                listener.positionZ.setValueAtTime(normalizedPosition.z, this.audioContext.currentTime);
-            }
-            if (listener.forwardX) {
-                listener.forwardX.setValueAtTime(orientation.forwardX, this.audioContext.currentTime);
-                listener.forwardY.setValueAtTime(orientation.forwardY, this.audioContext.currentTime);
-                listener.forwardZ.setValueAtTime(orientation.forwardZ, this.audioContext.currentTime);
-                listener.upX.setValueAtTime(orientation.upX, this.audioContext.currentTime);
-                listener.upY.setValueAtTime(orientation.upY, this.audioContext.currentTime);
-                listener.upZ.setValueAtTime(orientation.upZ, this.audioContext.currentTime);
-            }
-            // Log spatial audio updates occasionally
-            if (Math.random() < 0.01) {
-                console.log(`🎧 [Spatial Audio] Listener updated:`, {
-                    position: { x: position.x.toFixed(1), y: position.y.toFixed(1), z: position.z.toFixed(1) },
-                    forward: {
-                        x: orientation.forwardX.toFixed(2),
-                        y: orientation.forwardY.toFixed(2),
-                        z: orientation.forwardZ.toFixed(2),
-                    },
-                    up: {
-                        x: orientation.upX.toFixed(2),
-                        y: orientation.upY.toFixed(2),
-                        z: orientation.upZ.toFixed(2),
-                    },
+            const listenerPos = this.listenerPosition;
+            const distance = this.getDistanceBetween(listenerPos, targetPosition);
+            const distanceGain = this.calculateDistanceGain(distanceConfig, distance);
+            nodes.gain.gain.setTargetAtTime(distanceGain, this.audioContext.currentTime, 0.05);
+            if (Math.random() < 0.02) {
+                console.log("🎚️ [Spatial Audio] Distance gain", {
+                    participantId,
+                    distance: distance.toFixed(2),
+                    gain: distanceGain.toFixed(2),
                 });
             }
         }
     }
+    setListenerPosition(position, orientation) {
+        const normalizedPosition = this.normalizePositionUnits(position);
+        this.applyListenerTransform(normalizedPosition, orientation);
+    }
     /**
      * Update listener orientation from LSD camera direction
      * @param cameraPos Camera position in world space
@@ -329,7 +299,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         const rightLen = Math.sqrt(rightX * rightX + rightY * rightY + rightZ * rightZ);
         if (rightLen < 0.001) {
             // Forward is parallel to world up, use fallback
-            this.setListenerPosition(normalizedListener, {
+            this.applyListenerTransform(normalizedListener, {
                 forwardX: fwdX,
                 forwardY: fwdY,
                 forwardZ: fwdZ,
@@ -346,7 +316,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         const upX = fwdY * rZ - fwdZ * rY;
         const upY = fwdZ * rX - fwdX * rZ;
         const upZ = fwdX * rY - fwdY * rX;
-        this.setListenerPosition(normalizedListener, {
+        this.applyListenerTransform(normalizedListener, {
             forwardX: fwdX,
             forwardY: fwdY,
             forwardZ: fwdZ,
@@ -355,6 +325,58 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             upZ,
         });
     }
+    applyListenerTransform(normalizedPosition, orientation) {
+        const { listener } = this.audioContext;
+        if (!listener) {
+            return;
+        }
+        this.listenerPosition = { ...normalizedPosition };
+        this.listenerInitialized = true;
+        this.listenerDirection = {
+            forward: {
+                x: orientation.forwardX,
+                y: orientation.forwardY,
+                z: orientation.forwardZ,
+            },
+            up: {
+                x: orientation.upX,
+                y: orientation.upY,
+                z: orientation.upZ,
+            },
+        };
+        if (listener.positionX) {
+            listener.positionX.setValueAtTime(normalizedPosition.x, this.audioContext.currentTime);
+            listener.positionY.setValueAtTime(normalizedPosition.y, this.audioContext.currentTime);
+            listener.positionZ.setValueAtTime(normalizedPosition.z, this.audioContext.currentTime);
+        }
+        if (listener.forwardX) {
+            listener.forwardX.setValueAtTime(orientation.forwardX, this.audioContext.currentTime);
+            listener.forwardY.setValueAtTime(orientation.forwardY, this.audioContext.currentTime);
+            listener.forwardZ.setValueAtTime(orientation.forwardZ, this.audioContext.currentTime);
+            listener.upX.setValueAtTime(orientation.upX, this.audioContext.currentTime);
+            listener.upY.setValueAtTime(orientation.upY, this.audioContext.currentTime);
+            listener.upZ.setValueAtTime(orientation.upZ, this.audioContext.currentTime);
+        }
+        if (Math.random() < 0.01) {
+            console.log(`🎧 [Spatial Audio] Listener updated:`, {
+                position: {
+                    x: normalizedPosition.x.toFixed(2),
+                    y: normalizedPosition.y.toFixed(2),
+                    z: normalizedPosition.z.toFixed(2),
+                },
+                forward: {
+                    x: orientation.forwardX.toFixed(2),
+                    y: orientation.forwardY.toFixed(2),
+                    z: orientation.forwardZ.toFixed(2),
+                },
+                up: {
+                    x: orientation.upX.toFixed(2),
+                    y: orientation.upY.toFixed(2),
+                    z: orientation.upZ.toFixed(2),
+                },
+            });
+        }
+    }
     removeParticipant(participantId) {
         // Stop monitoring
         if (this.monitoringIntervals.has(participantId)) {
@@ -392,6 +414,42 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             unit: this.options.distance?.unit ?? "auto",
         };
     }
+    applySpatialBoostIfNeeded(position) {
+        if (!this.listenerInitialized) {
+            return position;
+        }
+        const boost = (this.options.distance?.rolloffFactor || 1) * 0.85;
+        if (!isFinite(boost) || boost <= 1.01) {
+            return position;
+        }
+        const listener = this.listenerPosition;
+        return {
+            x: listener.x + (position.x - listener.x) * boost,
+            y: listener.y + (position.y - listener.y) * Math.min(boost, 1.2),
+            z: listener.z + (position.z - listener.z) * boost,
+        };
+    }
+    getDistanceBetween(a, b) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const dz = b.z - a.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    calculateDistanceGain(config, distance) {
+        if (!this.listenerInitialized) {
+            return 1;
+        }
+        if (distance <= config.refDistance) {
+            return 1;
+        }
+        if (distance >= config.maxDistance) {
+            return 0;
+        }
+        const normalized = (distance - config.refDistance) /
+            Math.max(config.maxDistance - config.refDistance, 0.001);
+        const shaped = Math.pow(Math.max(0, 1 - normalized), Math.max(1.2, config.rolloffFactor * 1.05));
+        return Math.min(1, Math.max(0.01, shaped));
+    }
     normalizePositionUnits(position) {
         const distanceConfig = this.getDistanceConfig();
         if (distanceConfig.unit === "meters") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newgameplusinc/odyssey-audio-video-sdk-dev",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Odyssey Spatial Audio & Video SDK using MediaSoup for real-time communication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",