@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.17 → 1.0.18

package/dist/SpatialAudioManager.d.ts

@@ -96,6 +96,13 @@ export declare class SpatialAudioManager extends EventManager {
     private getDistanceBetween;
     private calculateDistanceGain;
     private normalizePositionUnits;
+    private getVectorFromListener;
+    private applyDirectionalSuppression;
+    private calculateClarityScore;
+    private calculateProximityWeight;
+    private calculateDirectionFocus;
+    private normalizeVector;
+    private clamp;
     private isDenoiserEnabled;
     private ensureDenoiseWorklet;
     private resolveOptions;

package/dist/SpatialAudioManager.js

@@ -69,6 +69,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         const panner = this.audioContext.createPanner();
         const analyser = this.audioContext.createAnalyser();
         const gain = this.audioContext.createGain();
+        const proximityGain = this.audioContext.createGain();
         let denoiseNode;
         if (this.isDenoiserEnabled() && typeof this.audioContext.audioWorklet !== "undefined") {
             try {
@@ -102,6 +103,11 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         lowpassFilter.type = "lowpass";
         lowpassFilter.frequency.value = 7500; // Below 8kHz to avoid flat/muffled sound
         lowpassFilter.Q.value = 1.0; // Quality factor
+        const dynamicLowpass = this.audioContext.createBiquadFilter();
+        dynamicLowpass.type = "lowpass";
+        dynamicLowpass.frequency.value = 7600;
+        dynamicLowpass.Q.value = 0.8;
+        proximityGain.gain.value = 1.0;
         // Configure Panner for realistic 3D spatial audio
         const distanceConfig = this.getDistanceConfig();
         panner.panningModel = "HRTF"; // Head-Related Transfer Function for realistic 3D
@@ -121,15 +127,17 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         }
         currentNode.connect(highpassFilter);
         highpassFilter.connect(lowpassFilter);
+        lowpassFilter.connect(dynamicLowpass);
+        dynamicLowpass.connect(proximityGain);
         if (bypassSpatialization) {
             console.log(`🔊 TESTING: Connecting audio directly to destination (bypassing spatial audio) for ${participantId}`);
-            lowpassFilter.connect(analyser);
+            proximityGain.connect(analyser);
             analyser.connect(this.masterGainNode);
         }
         else {
             // Standard spatialized path with full audio chain
             // Audio Chain: source -> filters -> panner -> analyser -> gain -> masterGain -> compressor -> destination
-            lowpassFilter.connect(panner);
+            proximityGain.connect(panner);
             panner.connect(analyser);
             analyser.connect(gain);
             gain.connect(this.masterGainNode);
@@ -139,8 +147,10 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             panner,
             analyser,
             gain,
+            proximityGain,
             highpassFilter,
             lowpassFilter,
+            dynamicLowpass,
             denoiseNode,
             stream,
         });
@@ -253,7 +263,9 @@ class SpatialAudioManager extends EventManager_1.EventManager {
                 }
             }
             const listenerPos = this.listenerPosition;
+            const vectorToSource = this.getVectorFromListener(targetPosition);
             const distance = this.getDistanceBetween(listenerPos, targetPosition);
+            this.applyDirectionalSuppression(participantId, distance, vectorToSource);
             const distanceGain = this.calculateDistanceGain(distanceConfig, distance);
             nodes.gain.gain.setTargetAtTime(distanceGain, this.audioContext.currentTime, 0.05);
             if (Math.random() < 0.02) {
@@ -473,6 +485,75 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         }
         return { ...position };
     }
+    getVectorFromListener(targetPosition) {
+        if (!this.listenerInitialized) {
+            return { ...targetPosition };
+        }
+        return {
+            x: targetPosition.x - this.listenerPosition.x,
+            y: targetPosition.y - this.listenerPosition.y,
+            z: targetPosition.z - this.listenerPosition.z,
+        };
+    }
+    applyDirectionalSuppression(participantId, distance, vectorToSource) {
+        const nodes = this.participantNodes.get(participantId);
+        if (!nodes) {
+            return;
+        }
+        const clarityScore = this.calculateClarityScore(distance, vectorToSource);
+        const targetGain = 0.55 + clarityScore * 0.6; // 0.55 → 1.15
+        const targetLowpass = 3200 + clarityScore * 4200; // 3.2kHz → ~7.4kHz
+        nodes.proximityGain.gain.setTargetAtTime(targetGain, this.audioContext.currentTime, 0.08);
+        nodes.dynamicLowpass.frequency.setTargetAtTime(targetLowpass, this.audioContext.currentTime, 0.12);
+        if (Math.random() < 0.005) {
+            console.log("🎚️ [Spatial Audio] Directional tuning", {
+                participantId,
+                distance: distance.toFixed(2),
+                clarityScore: clarityScore.toFixed(2),
+                targetGain: targetGain.toFixed(2),
+                lowpassHz: targetLowpass.toFixed(0),
+            });
+        }
+    }
+    calculateClarityScore(distance, vectorToSource) {
+        const proximityWeight = this.calculateProximityWeight(distance);
+        const focusWeight = this.calculateDirectionFocus(vectorToSource);
+        return this.clamp(0.2 + proximityWeight * 0.6 + focusWeight * 0.2, 0, 1);
+    }
+    calculateProximityWeight(distance) {
+        const closeRange = 1.2;
+        const fadeRange = 12;
+        if (distance <= closeRange) {
+            return 1;
+        }
+        if (distance >= fadeRange) {
+            return 0;
+        }
+        return 1 - (distance - closeRange) / (fadeRange - closeRange);
+    }
+    calculateDirectionFocus(vectorToSource) {
+        if (!this.listenerInitialized) {
+            return 0.5;
+        }
+        const forward = this.normalizeVector(this.listenerDirection.forward);
+        const source = this.normalizeVector(vectorToSource, { x: 0, y: 0, z: 1 });
+        const dot = forward.x * source.x + forward.y * source.y + forward.z * source.z;
+        return this.clamp((dot + 1) / 2, 0, 1);
+    }
+    normalizeVector(vector, fallback = { x: 0, y: 0, z: 1 }) {
+        const length = Math.hypot(vector.x, vector.y, vector.z);
+        if (length < 1e-4) {
+            return { ...fallback };
+        }
+        return {
+            x: vector.x / length,
+            y: vector.y / length,
+            z: vector.z / length,
+        };
+    }
+    clamp(value, min, max) {
+        return Math.min(max, Math.max(min, value));
+    }
     isDenoiserEnabled() {
         return this.options.denoiser?.enabled !== false;
     }

package/package.json

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