@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.75 → 1.0.78

package/dist/SpatialAudioManager.d.ts

@@ -135,14 +135,19 @@ export declare class SpatialAudioManager extends EventManager {
         upZ: number;
     }): void;
     /**
-     * Update listener orientation from LSD camera direction
+     * POSITION-ONLY MODE: Set listener HEAD position (no direction needed)
      * IMPORTANT: Uses CAMERA position (head) as listener, not body position!
      *
      * @param listenerPos Player body position (for reference, not used as listener)
      * @param cameraPos Camera/HEAD position - THIS is the actual listener position for audio
-     * @param lookAtPos Look-at position (where camera is pointing)
+     * @param lookAtPos Look-at position (where camera is pointing) - stored but not used for panning
+     * @param rot Rotation data (pitch, yaw, roll) - stored but not used for panning
      */
-    setListenerFromLSD(listenerPos: Position, cameraPos: Position, lookAtPos: Position): void;
+    setListenerFromLSD(listenerPos: Position, cameraPos: Position, lookAtPos: Position, rot?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
     private applyListenerTransform;
     removeParticipant(participantId: string): void;
     resumeAudioContext(): Promise<void>;
@@ -172,6 +177,13 @@ export declare class SpatialAudioManager extends EventManager {
      */
     private computeHeadPosition;
     /**
+     * Calculate stereo panning based on X-axis position difference ONLY
+     * @param dx Horizontal difference (speaker.x - listener.x)
+     * @returns { left: 0-100, right: 0-100 }
+     */
+    private calculatePositionBasedPanning;
+    /**
+     * OLD METHOD - Kept for reference but not used in position-only mode
      * Calculate angle between listener and sound source in degrees (0-360)
      * 0° = front, 90° = right, 180° = back, 270° = left
      */

package/dist/SpatialAudioManager.js

@@ -122,6 +122,9 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         const monoGainR = this.audioContext.createGain();
         monoGainL.gain.value = 0.5;
         monoGainR.gain.value = 0.5;
+        // CRITICAL: Convert mono back to stereo for StereoPanner
+        // monoMerger outputs 1 channel, but StereoPanner needs 2 channels
+        const stereoUpmixer = this.audioContext.createChannelMerger(2);
         const analyser = this.audioContext.createAnalyser();
         const gain = this.audioContext.createGain();
         const proximityGain = this.audioContext.createGain();
@@ -228,13 +231,16 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         voiceBandFilter.connect(lowpassFilter);
         lowpassFilter.connect(dynamicLowpass);
         dynamicLowpass.connect(proximityGain);
-        // Base routing (always): proximityGain -> mono downmix -> analyser
+        // Base routing (always): proximityGain -> mono downmix -> stereo upmix -> analyser
         proximityGain.connect(monoSplitter);
         monoSplitter.connect(monoGainL, 0);
         monoSplitter.connect(monoGainR, 1);
         monoGainL.connect(monoMerger, 0, 0);
         monoGainR.connect(monoMerger, 0, 0);
-        monoMerger.connect(analyser);
+        // Convert mono to stereo (same signal on both channels) for StereoPanner
+        monoMerger.connect(stereoUpmixer, 0, 0); // mono -> left channel
+        monoMerger.connect(stereoUpmixer, 0, 1); // mono -> right channel
+        stereoUpmixer.connect(analyser);
         // Output routing depends on spatialization mode:
         // - Spatial: analyser -> stereoPanner -> gain -> master
         // - Non-spatial: analyser -> gain -> master
@@ -254,6 +260,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             monoGainL,
             monoGainR,
             monoMerger,
+            stereoUpmixer,
             analyser,
             gain,
             proximityGain,
@@ -348,17 +355,20 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             return;
         }
         if (nodes?.panner) {
-            // CRITICAL FIX: position is BODY position (feet), not head position
-            // Compute speaker's head/mouth position for accurate spatial audio
+            // POSITION-ONLY SPATIAL AUDIO
+            // Compute speaker's head position from body position
             const normalizedBodyPosition = this.normalizePositionUnits(position);
             const speakerHeadPosition = this.computeHeadPosition(normalizedBodyPosition);
-            const listenerPos = this.listenerPosition; // This is HEAD position (from setListenerFromLSD)
-            // Calculate distance (in meters) - from listener HEAD to speaker HEAD
+            const listenerPos = this.listenerPosition; // This is listener HEAD position
+            // 🎧 [SDK Rx] Log received data
+            console.log(`🎧 [SDK Rx] ${participantId.substring(0, 8)} ` +
+                `bodyPos=(${normalizedBodyPosition.x.toFixed(2)}, ${normalizedBodyPosition.y.toFixed(2)}, ${normalizedBodyPosition.z.toFixed(2)}) ` +
+                `rot=(${direction?.x.toFixed(1) || 'N/A'}, ${direction?.y.toFixed(1) || 'N/A'}, ${direction?.z.toFixed(1) || 'N/A'})`);
+            // Calculate 3D distance (includes all axes)
             const distance = this.getDistanceBetween(listenerPos, speakerHeadPosition);
-            // Calculate angle between listener HEAD and speaker HEAD
-            const angle = this.calculateAngle(listenerPos, speakerHeadPosition, this.listenerDirection.forward);
-            // Calculate stereo panning based on angle
-            const panning = this.calculatePanning(angle);
+            // Calculate panning based ONLY on X-axis position difference
+            const dx = speakerHeadPosition.x - listenerPos.x;
+            const panning = this.calculatePositionBasedPanning(dx);
             // Calculate logarithmic gain based on distance
             const gain = this.calculateLogarithmicGain(distance);
             // Apply panning
@@ -383,46 +393,15 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             // Log every 1000ms (1 second) for easier debugging
             if (now - lastLog > 1000) {
                 this.lastLogTime.set(participantId, now);
+                // Position-based spatial audio log (already calculated dx above)
                 const panValue = ((panning.right - panning.left) / 100).toFixed(2);
-                const dx = speakerHeadPosition.x - listenerPos.x;
-                const dz = speakerHeadPosition.z - listenerPos.z;
-                const fwd = this.listenerDirection.forward;
-                const fLen = Math.hypot(fwd.x, fwd.z);
-                const fx = fLen > 1e-4 ? fwd.x / fLen : 0;
-                const fz = fLen > 1e-4 ? fwd.z / fLen : 1;
-                const vLen = Math.hypot(dx, dz);
-                const nx = vLen > 1e-4 ? dx / vLen : 0;
-                const nz = vLen > 1e-4 ? dz / vLen : 1;
-                const dot = fx * nx + fz * nz;
-                const cross = fx * nz - fz * nx;
-                // Right vector in X/Z plane (clockwise rotation of forward)
-                const rx = fz;
-                const rz = -fx;
-                const dotRight = rx * nx + rz * nz;
-                const dotForward = dot;
-                const side = Math.abs(dotRight) < 0.15 && dotForward > 0.35
-                    ? "front"
-                    : Math.abs(dotRight) < 0.15 && dotForward < -0.35
-                        ? "back"
-                        : dotRight > 0
-                            ? "right"
-                            : "left";
-                let rawDeg = (Math.atan2(cross, dot) * 180) / Math.PI;
-                if (rawDeg < 0)
-                    rawDeg += 360;
-                const computedAngle = (360 - rawDeg) % 360;
-                // Avoid console.group() because some consoles hide/collapse it.
                 console.log(`🎧 SPATIAL AUDIO [${participantId.substring(0, 8)}] ` +
-                    `dist=${distance.toFixed(2)}m angle=${angle.toFixed(0)}° ` +
+                    `dist=${distance.toFixed(2)}m ` +
+                    `dx=${dx.toFixed(2)}m ` +
                     `pan(L=${panning.left.toFixed(0)}%,R=${panning.right.toFixed(0)}%,v=${panValue}) ` +
                     `gain=${gain.toFixed(0)}% ` +
-                    `fwdXZ=(${fx.toFixed(2)},${fz.toFixed(2)}) ` +
-                    `dXZ=(${dx.toFixed(2)},${dz.toFixed(2)}) ` +
-                    `dotF=${dotForward.toFixed(2)} dotR=${dotRight.toFixed(2)} side=${side} ` +
-                    `raw=${rawDeg.toFixed(0)}° calc=${computedAngle.toFixed(0)}° ` +
-                    `you=(${listenerPos.x.toFixed(1)},${listenerPos.y.toFixed(1)},${listenerPos.z.toFixed(1)}) ` +
-                    `them=(${speakerHeadPosition.x.toFixed(1)},${speakerHeadPosition.y.toFixed(1)},${speakerHeadPosition.z.toFixed(1)}) ` +
-                    `body=(${normalizedBodyPosition.x.toFixed(1)},${normalizedBodyPosition.y.toFixed(1)},${normalizedBodyPosition.z.toFixed(1)})`);
+                    `you=(${listenerPos.x.toFixed(2)},${listenerPos.y.toFixed(2)},${listenerPos.z.toFixed(2)}) ` +
+                    `them=(${speakerHeadPosition.x.toFixed(2)},${speakerHeadPosition.y.toFixed(2)},${speakerHeadPosition.z.toFixed(2)})`);
             }
         }
     }
@@ -455,65 +434,77 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         this.applyListenerTransform(normalizedPosition, orientation);
     }
     /**
-     * Update listener orientation from LSD camera direction
+     * POSITION-ONLY MODE: Set listener HEAD position (no direction needed)
      * IMPORTANT: Uses CAMERA position (head) as listener, not body position!
      *
      * @param listenerPos Player body position (for reference, not used as listener)
      * @param cameraPos Camera/HEAD position - THIS is the actual listener position for audio
-     * @param lookAtPos Look-at position (where camera is pointing)
+     * @param lookAtPos Look-at position (where camera is pointing) - stored but not used for panning
+     * @param rot Rotation data (pitch, yaw, roll) - stored but not used for panning
      */
-    setListenerFromLSD(listenerPos, cameraPos, lookAtPos) {
+    setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot) {
         // USE CAMERA POSITION AS LISTENER (head position, not body!)
-        const normalizedListener = this.normalizePositionUnits(cameraPos); // ✅ Changed from listenerPos
-        const normalizedCamera = this.normalizePositionUnits(cameraPos);
-        const normalizedLookAt = this.normalizePositionUnits(lookAtPos);
-        // Calculate forward vector (from camera to look-at point)
-        const forwardX = normalizedLookAt.x - normalizedCamera.x;
-        const forwardY = normalizedLookAt.y - normalizedCamera.y;
-        const forwardZ = normalizedLookAt.z - normalizedCamera.z;
-        // Normalize forward vector
-        const forwardLen = Math.sqrt(forwardX * forwardX + forwardY * forwardY + forwardZ * forwardZ);
-        if (forwardLen < 0.001) {
-            return;
-        }
-        const fwdX = forwardX / forwardLen;
-        const fwdY = forwardY / forwardLen;
-        const fwdZ = forwardZ / forwardLen;
-        // Calculate right vector (cross product of world up and forward)
-        // Web Audio API uses Y-up coordinate system, Unreal uses Z-up
-        // We need to transform: Unreal (X,Y,Z) -> WebAudio (X,Z,-Y)
-        const worldUp = { x: 0, y: 1, z: 0 }; // Web Audio Y-up
-        const rightX = worldUp.y * fwdZ - worldUp.z * fwdY;
-        const rightY = worldUp.z * fwdX - worldUp.x * fwdZ;
-        const rightZ = worldUp.x * fwdY - worldUp.y * fwdX;
-        const rightLen = Math.sqrt(rightX * rightX + rightY * rightY + rightZ * rightZ);
-        if (rightLen < 0.001) {
-            // Forward is parallel to world up, use fallback
+        const normalizedListener = this.normalizePositionUnits(cameraPos);
+        // Store listener position (used for X-axis panning and distance calculation)
+        this.listenerPosition = normalizedListener;
+        // 📍 [SDK Listener] Log listener position update
+        console.log(`📍 [SDK Listener] ` +
+            `pos=(${normalizedListener.x.toFixed(2)}, ${normalizedListener.y.toFixed(2)}, ${normalizedListener.z.toFixed(2)}) ` +
+            `rot=(${rot?.x.toFixed(1) || 'N/A'}, ${rot?.y.toFixed(1) || 'N/A'}, ${rot?.z.toFixed(1) || 'N/A'})`);
+        // Position-only mode: No forward vector calculations needed
+        // Panning is calculated purely from X-axis position difference in updateSpatialAudio()
+        // LEGACY CODE BELOW - Kept for reference but not executed
+        if (false) {
+            const normalizedCamera = this.normalizePositionUnits(cameraPos);
+            const normalizedLookAt = this.normalizePositionUnits(lookAtPos);
+            // Calculate forward vector (from camera to look-at point)
+            const forwardX = normalizedLookAt.x - normalizedCamera.x;
+            const forwardY = normalizedLookAt.y - normalizedCamera.y;
+            const forwardZ = normalizedLookAt.z - normalizedCamera.z;
+            // Normalize forward vector
+            const forwardLen = Math.sqrt(forwardX * forwardX + forwardY * forwardY + forwardZ * forwardZ);
+            if (forwardLen < 0.001) {
+                return;
+            }
+            const fwdX = forwardX / forwardLen;
+            const fwdY = forwardY / forwardLen;
+            const fwdZ = forwardZ / forwardLen;
+            // Calculate right vector (cross product of world up and forward)
+            // Web Audio API uses Y-up coordinate system, Unreal uses Z-up
+            // We need to transform: Unreal (X,Y,Z) -> WebAudio (X,Z,-Y)
+            const worldUp = { x: 0, y: 1, z: 0 }; // Web Audio Y-up
+            const rightX = worldUp.y * fwdZ - worldUp.z * fwdY;
+            const rightY = worldUp.z * fwdX - worldUp.x * fwdZ;
+            const rightZ = worldUp.x * fwdY - worldUp.y * fwdX;
+            const rightLen = Math.sqrt(rightX * rightX + rightY * rightY + rightZ * rightZ);
+            if (rightLen < 0.001) {
+                // Forward is parallel to world up, use fallback
+                this.applyListenerTransform(normalizedListener, {
+                    forwardX: fwdX,
+                    forwardY: fwdY,
+                    forwardZ: fwdZ,
+                    upX: 0,
+                    upY: 1,
+                    upZ: 0,
+                });
+                return;
+            }
+            const rX = rightX / rightLen;
+            const rY = rightY / rightLen;
+            const rZ = rightZ / rightLen;
+            // Calculate true up vector (cross product of forward and right)
+            const upX = fwdY * rZ - fwdZ * rY;
+            const upY = fwdZ * rX - fwdX * rZ;
+            const upZ = fwdX * rY - fwdY * rX;
             this.applyListenerTransform(normalizedListener, {
                 forwardX: fwdX,
                 forwardY: fwdY,
                 forwardZ: fwdZ,
-                upX: 0,
-                upY: 1,
-                upZ: 0,
+                upX,
+                upY,
+                upZ,
             });
-            return;
-        }
-        const rX = rightX / rightLen;
-        const rY = rightY / rightLen;
-        const rZ = rightZ / rightLen;
-        // Calculate true up vector (cross product of forward and right)
-        const upX = fwdY * rZ - fwdZ * rY;
-        const upY = fwdZ * rX - fwdX * rZ;
-        const upZ = fwdX * rY - fwdY * rX;
-        this.applyListenerTransform(normalizedListener, {
-            forwardX: fwdX,
-            forwardY: fwdY,
-            forwardZ: fwdZ,
-            upX,
-            upY,
-            upZ,
-        });
+        } // End of legacy code block
     }
     applyListenerTransform(normalizedPosition, orientation) {
         const { listener } = this.audioContext;
@@ -563,6 +554,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             nodes.monoGainL.disconnect();
             nodes.monoGainR.disconnect();
             nodes.monoMerger.disconnect();
+            nodes.stereoUpmixer.disconnect();
             nodes.stereoPanner.disconnect();
             nodes.analyser.disconnect();
             nodes.gain.disconnect();
@@ -760,6 +752,27 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         };
     }
     /**
+     * Calculate stereo panning based on X-axis position difference ONLY
+     * @param dx Horizontal difference (speaker.x - listener.x)
+     * @returns { left: 0-100, right: 0-100 }
+     */
+    calculatePositionBasedPanning(dx) {
+        const threshold = 0.1; // 10cm threshold for "centered"
+        if (dx > threshold) {
+            // Speaker is to the RIGHT → Pan RIGHT
+            return { left: 0, right: 100 };
+        }
+        else if (dx < -threshold) {
+            // Speaker is to the LEFT → Pan LEFT
+            return { left: 100, right: 0 };
+        }
+        else {
+            // Centered (same X position)
+            return { left: 100, right: 100 };
+        }
+    }
+    /**
+     * OLD METHOD - Kept for reference but not used in position-only mode
      * Calculate angle between listener and sound source in degrees (0-360)
      * 0° = front, 90° = right, 180° = back, 270° = left
      */

package/dist/index.d.ts

@@ -48,6 +48,11 @@ export declare class OdysseySpatialComms extends EventManager {
             x: number;
             y: number;
         } | null;
+        rot?: {
+            x: number;
+            y: number;
+            z: number;
+        };
     }): void;
     updateMediaState(mediaState: MediaState): void;
     setListenerPosition(position: Position, orientation: {
@@ -58,7 +63,11 @@ export declare class OdysseySpatialComms extends EventManager {
         upY: number;
         upZ: number;
     }): void;
-    setListenerFromLSD(listenerPos: Position, cameraPos: Position, lookAtPos: Position): void;
+    setListenerFromLSD(listenerPos: Position, cameraPos: Position, lookAtPos: Position, rot?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
     private listenForEvents;
     /**
      * Send huddle invite to another participant

package/dist/index.js

@@ -201,6 +201,7 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
                 roomId: this.room.id,
                 position,
                 direction,
+                rot: spatialData?.rot,
                 cameraDistance: spatialData?.cameraDistance,
                 screenPos: spatialData?.screenPos,
             };
@@ -221,8 +222,8 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
     setListenerPosition(position, orientation) {
         this.spatialAudioManager.setListenerPosition(position, orientation);
     }
-    setListenerFromLSD(listenerPos, cameraPos, lookAtPos) {
-        this.spatialAudioManager.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
+    setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot) {
+        this.spatialAudioManager.setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot);
     }
     listenForEvents() {
         // CRITICAL: Register all-participants-update listener at initialization
@@ -453,8 +454,9 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
                 const participantChannel = participant.currentChannel;
                 const isInHuddle = participantChannel === "odyssey-huddle";
                 if (!isInHuddle) {
-                    // Update spatial audio with BOTH position AND direction from socket
-                    this.spatialAudioManager.updateSpatialAudio(data.participantId, data.position, data.direction);
+                    // Update spatial audio with position, direction, AND rotation
+                    this.spatialAudioManager.updateSpatialAudio(data.participantId, data.position, data.rot || data.direction // Prefer rot, fallback to direction
+                    );
                 }
                 this.emit("participant-position-updated", participant);
             }

package/package.json

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