@onerjs/core 8.32.0 → 8.32.2

package/Audio/sound.js

@@ -1,73 +1,146 @@
-import { Tools } from "../Misc/tools.js";
-import { Observable } from "../Misc/observable.js";
+import { _HasSpatialAudioOptions, _SpatialAudioDefaults } from "../AudioV2/abstractAudio/subProperties/abstractSpatialAudio.js";
+import { _WebAudioSoundSource } from "../AudioV2/webAudio/webAudioSoundSource.js";
+import { _WebAudioStaticSound } from "../AudioV2/webAudio/webAudioStaticSound.js";
+import { _WebAudioStreamingSound } from "../AudioV2/webAudio/webAudioStreamingSound.js";
+import { AbstractEngine } from "../Engines/abstractEngine.js";
+import { EngineStore } from "../Engines/engineStore.js";
 import { Vector3 } from "../Maths/math.vector.js";
-import { Logger } from "../Misc/logger.js";
 import { _WarnImport } from "../Misc/devTools.js";
-import { EngineStore } from "../Engines/engineStore.js";
-import { RegisterClass } from "../Misc/typeStore.js";
-import { AbstractEngine } from "../Engines/abstractEngine.js";
+import { Logger } from "../Misc/logger.js";
+import { Observable } from "../Misc/observable.js";
 import { _RetryWithInterval } from "../Misc/timingTools.js";
+import { RegisterClass } from "../Misc/typeStore.js";
+const TmpRampOptions = {
+    duration: 0,
+    shape: "linear" /* AudioParameterRampShape.Linear */,
+};
+const TmpPlayOptions = {
+    duration: 0,
+    startOffset: 0,
+    waitTime: 0,
+};
+const TmpStopOptions = {
+    waitTime: 0,
+};
+function D2r(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+function R2d(radians) {
+    return (radians * 180) / Math.PI;
+}
 /**
  * Defines a sound that can be played in the application.
  * The sound can either be an ambient track or a simple sound played in reaction to a user action.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic
+ * @see https://doc.babylonjs.com/legacy/audio
  */
 export class Sound {
+    /**
+     * The name of the sound in the scene.
+     */
+    get name() {
+        return this._soundV2.name;
+    }
+    set name(value) {
+        this._soundV2.name = value;
+    }
+    /**
+     * Does the sound autoplay once loaded.
+     */
+    get autoplay() {
+        return this._soundV2 instanceof _WebAudioSoundSource ? true : this._optionsV2.autoplay;
+    }
+    set autoplay(value) {
+        this._optionsV2.autoplay = value;
+    }
     /**
      * Does the sound loop after it finishes playing once.
      */
     get loop() {
-        return this._loop;
+        return this._soundV2 instanceof _WebAudioSoundSource ? true : this._soundV2.loop;
     }
     set loop(value) {
-        if (value === this._loop) {
+        if (this._soundV2 instanceof _WebAudioSoundSource) {
             return;
         }
-        this._loop = value;
-        this.updateOptions({ loop: value });
+        if (this._soundV2) {
+            this._soundV2.loop = value;
+        }
     }
     /**
-     * Gets the current time for the sound.
+     * Is this sound currently played.
      */
-    get currentTime() {
-        if (this._htmlAudioElement) {
-            return this._htmlAudioElement.currentTime;
+    get isPlaying() {
+        return this._soundV2 instanceof _WebAudioSoundSource ? true : this._soundV2?.state === 3 /* SoundState.Started */ || (!this.isReady() && this._optionsV2.autoplay);
+    }
+    /**
+     * Is this sound currently paused.
+     */
+    get isPaused() {
+        return this._soundV2 instanceof _WebAudioSoundSource ? false : this._soundV2.state === 5 /* SoundState.Paused */;
+    }
+    /**
+     * Define the max distance the sound should be heard (intensity just became 0 at this point).
+     * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
+     */
+    get maxDistance() {
+        return this._optionsV2.spatialMaxDistance || 100;
+    }
+    set maxDistance(value) {
+        this._optionsV2.spatialMaxDistance = value;
+        if (this.useCustomAttenuation) {
+            return;
+        }
+        if (this._soundV2) {
+            this._initSpatial();
+            this._soundV2.spatial.maxDistance = value;
         }
-        if (AbstractEngine.audioEngine?.audioContext && (this.isPlaying || this.isPaused)) {
-            // The `_currentTime` member is only updated when the sound is paused. Add the time since the last start
-            // to get the actual current time.
-            const timeSinceLastStart = this.isPaused ? 0 : AbstractEngine.audioEngine.audioContext.currentTime - this._startTime;
-            return this._currentTime + timeSinceLastStart;
+    }
+    /**
+     * Define the distance attenuation model the sound will follow.
+     * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
+     */
+    get distanceModel() {
+        return this._optionsV2.spatialDistanceModel || "linear";
+    }
+    set distanceModel(value) {
+        this._optionsV2.spatialDistanceModel = value;
+        if (this._soundV2) {
+            this._initSpatial();
+            this._soundV2.spatial.distanceModel = value;
         }
-        return 0;
+    }
+    /**
+     * Gets the current time for the sound.
+     */
+    get currentTime() {
+        return this._soundV2 instanceof _WebAudioSoundSource ? this._soundV2.engine.currentTime : this._soundV2.currentTime;
     }
     /**
      * Does this sound enables spatial sound.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
+     * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
      */
     get spatialSound() {
-        return this._spatialSound;
+        return this._soundV2?._isSpatial ?? false;
     }
     /**
      * Does this sound enables spatial sound.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
+     * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
      */
     set spatialSound(newValue) {
-        if (newValue == this._spatialSound) {
-            return;
-        }
-        const wasPlaying = this.isPlaying;
-        this.pause();
-        if (newValue) {
-            this._spatialSound = newValue;
-            this._updateSpatialParameters();
-        }
-        else {
-            this._disableSpatialSound();
+        if (this._soundV2) {
+            if (newValue) {
+                this._initSpatial();
+            }
+            else {
+                this._soundV2._isSpatial = false;
+            }
         }
-        if (wasPlaying) {
-            this.play();
+    }
+    get _onReady() {
+        if (!this._onReadyObservable) {
+            this._onReadyObservable = new Observable();
         }
+        return this._onReadyObservable;
     }
     /**
      * Create a sound and attach it to a scene
@@ -78,45 +151,26 @@ export class Sound {
      * @param options Objects to provide with the current available options: autoplay, loop, volume, spatialSound, maxDistance, rolloffFactor, refDistance, distanceModel, panningModel, streaming
      */
     constructor(name, urlOrArrayBuffer, scene, readyToPlayCallback = null, options) {
-        /**
-         * Does the sound autoplay once loaded.
-         */
-        this.autoplay = false;
-        this._loop = false;
         /**
          * Does the sound use a custom attenuation curve to simulate the falloff
          * happening when the source gets further away from the camera.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-your-own-custom-attenuation-function
+         * @see https://doc.babylonjs.com/legacy/audio#creating-your-own-custom-attenuation-function
          */
         this.useCustomAttenuation = false;
         /**
-         * Is this sound currently played.
+         * The sound track id this sound belongs to.
          */
-        this.isPlaying = false;
-        /**
-         * Is this sound currently paused.
-         */
-        this.isPaused = false;
+        this.soundTrackId = -1;
         /**
          * Define the reference distance the sound should be heard perfectly.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
+         * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
          */
         this.refDistance = 1;
         /**
          * Define the roll off factor of spatial sounds.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
+         * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
          */
         this.rolloffFactor = 1;
-        /**
-         * Define the max distance the sound should be heard (intensity just became 0 at this point).
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
-         */
-        this.maxDistance = 100;
-        /**
-         * Define the distance attenuation model the sound will follow.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
-         */
-        this.distanceModel = "linear";
         /**
          * Gets or sets an object used to store user defined information for the sound.
          */
@@ -125,32 +179,37 @@ export class Sound {
          * Observable event when the current playing sound finishes.
          */
         this.onEndedObservable = new Observable();
-        this._spatialSound = false;
-        this._panningModel = "equalpower";
-        this._playbackRate = 1;
-        this._streaming = false;
-        this._startTime = 0;
-        this._currentTime = 0;
-        this._position = Vector3.Zero();
         this._localDirection = new Vector3(1, 0, 0);
         this._volume = 1;
         this._isReadyToPlay = false;
         this._isDirectional = false;
-        // Used if you'd like to create a directional sound.
-        // If not set, the sound will be omnidirectional
-        this._coneInnerAngle = 360;
-        this._coneOuterAngle = 360;
-        this._coneOuterGain = 0;
         this._isOutputConnected = false;
-        this._urlType = "Unknown";
-        this.name = name;
+        this._url = null;
+        this._onReadyObservable = null;
+        this._onReadyToPlay = () => {
+            this._scene.mainSoundTrack.addSound(this);
+            this._isReadyToPlay = true;
+            this._readyToPlayCallback();
+            if (this._onReadyObservable) {
+                this._onReadyObservable.notifyObservers();
+            }
+            if (this._optionsV2.autoplay) {
+                this.play();
+            }
+        };
+        this._onended = () => {
+            if (this.onended) {
+                this.onended();
+            }
+            this.onEndedObservable.notifyObservers(this);
+        };
         scene = scene || EngineStore.LastCreatedScene;
         if (!scene) {
             return;
         }
         this._scene = scene;
         Sound._SceneComponentInitialization(scene);
-        this._readyToPlayCallback = readyToPlayCallback;
+        this._readyToPlayCallback = readyToPlayCallback || (() => { });
         // Default custom attenuation function is a linear attenuation
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         this._customAttenuationFunction = (currentVolume, currentDistance, maxDistance, refDistance, rolloffFactor) => {
@@ -161,232 +220,136 @@ export class Sound {
                 return 0;
             }
         };
-        if (options) {
-            this.autoplay = options.autoplay || false;
-            this._loop = options.loop || false;
-            // if volume === 0, we need another way to check this option
-            if (options.volume !== undefined) {
-                this._volume = options.volume;
-            }
-            this._spatialSound = options.spatialSound ?? false;
-            this.maxDistance = options.maxDistance ?? 100;
-            this.useCustomAttenuation = options.useCustomAttenuation ?? false;
-            this.rolloffFactor = options.rolloffFactor || 1;
-            this.refDistance = options.refDistance || 1;
-            this.distanceModel = options.distanceModel || "linear";
-            this._playbackRate = options.playbackRate || 1;
-            this._streaming = options.streaming ?? false;
-            this._length = options.length;
-            this._offset = options.offset;
-        }
-        if (AbstractEngine.audioEngine?.canUseWebAudio && AbstractEngine.audioEngine.audioContext) {
-            this._soundGain = AbstractEngine.audioEngine.audioContext.createGain();
-            this._soundGain.gain.value = this._volume;
-            this._inputAudioNode = this._soundGain;
-            this._outputAudioNode = this._soundGain;
-            if (this._spatialSound) {
-                this._createSpatialParameters();
-            }
-            this._scene.mainSoundTrack.addSound(this);
-            let validParameter = true;
-            // if no parameter is passed, you need to call setAudioBuffer yourself to prepare the sound
-            if (urlOrArrayBuffer) {
-                try {
-                    if (typeof urlOrArrayBuffer === "string") {
-                        this._urlType = "String";
-                        this._url = urlOrArrayBuffer;
-                    }
-                    else if (urlOrArrayBuffer instanceof ArrayBuffer) {
-                        this._urlType = "ArrayBuffer";
-                    }
-                    else if (urlOrArrayBuffer instanceof HTMLMediaElement) {
-                        this._urlType = "MediaElement";
-                    }
-                    else if (urlOrArrayBuffer instanceof MediaStream) {
-                        this._urlType = "MediaStream";
-                    }
-                    else if (urlOrArrayBuffer instanceof AudioBuffer) {
-                        this._urlType = "AudioBuffer";
-                    }
-                    else if (Array.isArray(urlOrArrayBuffer)) {
-                        this._urlType = "Array";
-                    }
-                    let urls = [];
-                    let codecSupportedFound = false;
-                    switch (this._urlType) {
-                        case "MediaElement":
-                            this._streaming = true;
-                            this._isReadyToPlay = true;
-                            this._streamingSource = AbstractEngine.audioEngine.audioContext.createMediaElementSource(urlOrArrayBuffer);
-                            if (this.autoplay) {
-                                this.play(0, this._offset, this._length);
-                            }
-                            if (this._readyToPlayCallback) {
-                                this._readyToPlayCallback();
-                            }
-                            break;
-                        case "MediaStream":
-                            this._streaming = true;
-                            this._isReadyToPlay = true;
-                            this._streamingSource = AbstractEngine.audioEngine.audioContext.createMediaStreamSource(urlOrArrayBuffer);
-                            if (this.autoplay) {
-                                this.play(0, this._offset, this._length);
-                            }
-                            if (this._readyToPlayCallback) {
-                                this._readyToPlayCallback();
-                            }
-                            break;
-                        case "ArrayBuffer":
-                            if (urlOrArrayBuffer.byteLength > 0) {
-                                codecSupportedFound = true;
-                                this._soundLoaded(urlOrArrayBuffer);
-                            }
-                            break;
-                        case "AudioBuffer":
-                            this._audioBufferLoaded(urlOrArrayBuffer);
-                            break;
-                        case "String":
-                            urls.push(urlOrArrayBuffer);
-                        // eslint-disable-next-line no-fallthrough
-                        case "Array":
-                            if (urls.length === 0) {
-                                urls = urlOrArrayBuffer;
-                            }
-                            // If we found a supported format, we load it immediately and stop the loop
-                            for (let i = 0; i < urls.length; i++) {
-                                const url = urls[i];
-                                codecSupportedFound =
-                                    (options && options.skipCodecCheck) ||
-                                        (url.indexOf(".mp3", url.length - 4) !== -1 && AbstractEngine.audioEngine.isMP3supported) ||
-                                        (url.indexOf(".ogg", url.length - 4) !== -1 && AbstractEngine.audioEngine.isOGGsupported) ||
-                                        url.indexOf(".wav", url.length - 4) !== -1 ||
-                                        url.indexOf(".m4a", url.length - 4) !== -1 ||
-                                        url.indexOf(".mp4", url.length - 4) !== -1 ||
-                                        url.indexOf("blob:") !== -1;
-                                if (codecSupportedFound) {
-                                    // Loading sound
-                                    if (!this._streaming) {
-                                        this._scene._loadFile(url, (data) => {
-                                            this._soundLoaded(data);
-                                        }, undefined, true, true, (exception) => {
-                                            if (exception) {
-                                                Logger.Error("XHR " + exception.status + " error on: " + url + ".");
-                                            }
-                                            Logger.Error("Sound creation aborted.");
-                                            this._scene.mainSoundTrack.removeSound(this);
-                                        });
-                                    }
-                                    // Streaming sound using HTML5 Audio tag
-                                    else {
-                                        this._htmlAudioElement = new Audio(url);
-                                        this._htmlAudioElement.controls = false;
-                                        this._htmlAudioElement.loop = this.loop;
-                                        Tools.SetCorsBehavior(url, this._htmlAudioElement);
-                                        this._htmlAudioElement.preload = "auto";
-                                        this._htmlAudioElement.addEventListener("canplaythrough", () => {
-                                            this._isReadyToPlay = true;
-                                            if (this.autoplay) {
-                                                this.play(0, this._offset, this._length);
-                                            }
-                                            if (this._readyToPlayCallback) {
-                                                this._readyToPlayCallback();
-                                            }
-                                        }, { once: true });
-                                        document.body.appendChild(this._htmlAudioElement);
-                                        this._htmlAudioElement.load();
-                                    }
-                                    break;
-                                }
-                            }
-                            break;
-                        default:
-                            validParameter = false;
-                            break;
-                    }
-                    if (!validParameter) {
-                        Logger.Error("Parameter must be a URL to the sound, an Array of URLs (.mp3 & .ogg) or an ArrayBuffer of the sound.");
-                    }
-                    else {
-                        if (!codecSupportedFound) {
-                            this._isReadyToPlay = true;
-                            // Simulating a ready to play event to avoid breaking code path
-                            if (this._readyToPlayCallback) {
-                                setTimeout(() => {
-                                    if (this._readyToPlayCallback) {
-                                        this._readyToPlayCallback();
-                                    }
-                                }, 1000);
-                            }
-                        }
-                    }
-                }
-                catch (ex) {
-                    Logger.Error("Unexpected error. Sound creation aborted.");
-                    this._scene.mainSoundTrack.removeSound(this);
-                }
-            }
+        options = options || {};
+        const optionsV2 = {
+            analyzerEnabled: false,
+            autoplay: false, // `false` for now, but will be set to given option later
+            duration: options.length || 0,
+            loop: options.loop || false,
+            loopEnd: 0,
+            loopStart: 0,
+            maxInstances: 1,
+            outBus: null,
+            outBusAutoDefault: false,
+            playbackRate: options.playbackRate || 1,
+            pitch: 0,
+            skipCodecCheck: options.skipCodecCheck || false,
+            spatialDistanceModel: options.distanceModel,
+            spatialEnabled: options.spatialSound,
+            spatialMaxDistance: options.maxDistance,
+            spatialMinDistance: options.refDistance,
+            spatialRolloffFactor: options.rolloffFactor,
+            stereoEnabled: false,
+            startOffset: options.offset || 0,
+            volume: options.volume ?? 1,
+        };
+        this._volume = options.volume ?? 1;
+        if (_HasSpatialAudioOptions(optionsV2)) {
+            optionsV2.spatialAutoUpdate = false;
+            optionsV2.spatialConeInnerAngle = _SpatialAudioDefaults.coneInnerAngle;
+            optionsV2.spatialConeOuterAngle = _SpatialAudioDefaults.coneOuterAngle;
+            optionsV2.spatialConeOuterVolume = _SpatialAudioDefaults.coneOuterVolume;
+            optionsV2.spatialMinUpdateTime = 0;
+            optionsV2.spatialOrientation = _SpatialAudioDefaults.orientation.clone();
+            optionsV2.spatialPanningModel = (this._scene.headphone ? "HRTF" : "equalpower");
+            optionsV2.spatialPosition = _SpatialAudioDefaults.position.clone();
+            optionsV2.spatialRotation = _SpatialAudioDefaults.rotation.clone();
+            optionsV2.spatialRotationQuaternion = _SpatialAudioDefaults.rotationQuaternion.clone();
+            if (optionsV2.spatialMaxDistance === undefined) {
+                optionsV2.spatialMaxDistance = 100;
+            }
+        }
+        this._optionsV2 = { ...optionsV2 };
+        this._optionsV2.autoplay = options.autoplay || false;
+        this.useCustomAttenuation = options.useCustomAttenuation ?? false;
+        if (this.useCustomAttenuation) {
+            optionsV2.spatialMaxDistance = Number.MAX_VALUE;
+            optionsV2.volume = 0;
+        }
+        let streaming = options?.streaming || false;
+        const audioEngine = AbstractEngine.audioEngine;
+        if (!audioEngine) {
+            return;
         }
-        else {
-            // Adding an empty sound to avoid breaking audio calls for non Web Audio browsers
-            this._scene.mainSoundTrack.addSound(this);
-            if (AbstractEngine.audioEngine && !AbstractEngine.audioEngine.WarnedWebAudioUnsupported) {
-                Logger.Error("Web Audio is not supported by your browser.");
-                AbstractEngine.audioEngine.WarnedWebAudioUnsupported = true;
+        const audioEngineV2 = AbstractEngine.audioEngine._v2;
+        const createSoundV2 = () => {
+            if (streaming) {
+                const streamingOptionsV2 = {
+                    preloadCount: 0,
+                    ...optionsV2,
+                };
+                const sound = new _WebAudioStreamingSound(name, audioEngineV2, streamingOptionsV2);
+                // eslint-disable-next-line github/no-then
+                void sound._initAsync(urlOrArrayBuffer, optionsV2).then(() => {
+                    // eslint-disable-next-line github/no-then
+                    void sound.preloadInstancesAsync(1).then(this._onReadyToPlay);
+                });
+                return sound;
             }
-            // Simulating a ready to play event to avoid breaking code for non web audio browsers
-            if (this._readyToPlayCallback) {
-                setTimeout(() => {
-                    if (this._readyToPlayCallback) {
-                        this._readyToPlayCallback();
-                    }
-                }, 1000);
+            else {
+                const sound = new _WebAudioStaticSound(name, audioEngineV2, optionsV2);
+                // eslint-disable-next-line github/no-then
+                void sound._initAsync(urlOrArrayBuffer, optionsV2).then(this._onReadyToPlay);
+                return sound;
             }
+        };
+        // If no parameter is passed then the setAudioBuffer should be called to prepare the sound.
+        if (!urlOrArrayBuffer) {
+            // Create the sound but don't call _initAsync on it, yet. Call it later when `setAudioBuffer` is called.
+            this._soundV2 = new _WebAudioStaticSound(name, audioEngineV2, optionsV2);
+        }
+        else if (typeof urlOrArrayBuffer === "string") {
+            this._url = urlOrArrayBuffer;
+            this._soundV2 = createSoundV2();
+        }
+        else if (urlOrArrayBuffer instanceof ArrayBuffer) {
+            streaming = false;
+            this._soundV2 = createSoundV2();
+        }
+        else if (urlOrArrayBuffer instanceof HTMLMediaElement) {
+            streaming = true;
+            this._soundV2 = createSoundV2();
+        }
+        else if (urlOrArrayBuffer instanceof MediaStream) {
+            const node = new MediaStreamAudioSourceNode(audioEngineV2._audioContext, { mediaStream: urlOrArrayBuffer });
+            this._soundV2 = new _WebAudioSoundSource(name, node, audioEngineV2, optionsV2);
+            // eslint-disable-next-line github/no-then
+            void this._soundV2._initAsync(optionsV2).then(this._onReadyToPlay);
+        }
+        else if (urlOrArrayBuffer instanceof AudioBuffer) {
+            streaming = false;
+            this._soundV2 = createSoundV2();
+        }
+        else if (Array.isArray(urlOrArrayBuffer)) {
+            this._soundV2 = createSoundV2();
+        }
+        if (!this._soundV2) {
+            Logger.Error("Parameter must be a URL to the sound, an Array of URLs (.mp3 & .ogg) or an ArrayBuffer of the sound.");
+            return;
+        }
+        if (!(this._soundV2 instanceof _WebAudioSoundSource)) {
+            this._soundV2.onEndedObservable.add(this._onended);
         }
     }
     /**
      * Release the sound and its associated resources
      */
     dispose() {
-        if (AbstractEngine.audioEngine?.canUseWebAudio) {
-            if (this.isPlaying) {
-                this.stop();
-            }
-            this._isReadyToPlay = false;
-            if (this.soundTrackId === -1) {
-                this._scene.mainSoundTrack.removeSound(this);
-            }
-            else if (this._scene.soundTracks) {
-                this._scene.soundTracks[this.soundTrackId].removeSound(this);
-            }
-            if (this._soundGain) {
-                this._soundGain.disconnect();
-                this._soundGain = null;
-            }
-            if (this._soundPanner) {
-                this._soundPanner.disconnect();
-                this._soundPanner = null;
-            }
-            if (this._soundSource) {
-                this._soundSource.disconnect();
-                this._soundSource = null;
-            }
-            this._audioBuffer = null;
-            if (this._htmlAudioElement) {
-                this._htmlAudioElement.pause();
-                this._htmlAudioElement.src = "";
-                document.body.removeChild(this._htmlAudioElement);
-                this._htmlAudioElement = null;
-            }
-            if (this._streamingSource) {
-                this._streamingSource.disconnect();
-                this._streamingSource = null;
-            }
-            if (this._connectedTransformNode && this._registerFunc) {
-                this._connectedTransformNode.unregisterAfterWorldMatrixUpdate(this._registerFunc);
-                this._connectedTransformNode = null;
-            }
-            this._clearTimeoutsAndObservers();
+        if (this.isPlaying) {
+            this.stop();
+        }
+        this._isReadyToPlay = false;
+        if (this.soundTrackId === -1) {
+            this._scene.mainSoundTrack.removeSound(this);
+        }
+        else if (this._scene.soundTracks) {
+            this._scene.soundTracks[this.soundTrackId].removeSound(this);
         }
+        if (this._connectedTransformNode && this._registerFunc) {
+            this._connectedTransformNode.unregisterAfterWorldMatrixUpdate(this._registerFunc);
+            this._connectedTransformNode = null;
+        }
+        this._soundV2.dispose();
     }
     /**
      * Gets if the sounds is ready to be played or not.
@@ -402,38 +365,17 @@ export class Sound {
     getClassName() {
         return "Sound";
     }
-    _audioBufferLoaded(buffer) {
-        if (!AbstractEngine.audioEngine?.audioContext) {
-            return;
-        }
-        this._audioBuffer = buffer;
-        this._isReadyToPlay = true;
-        if (this.autoplay) {
-            this.play(0, this._offset, this._length);
-        }
-        if (this._readyToPlayCallback) {
-            this._readyToPlayCallback();
-        }
-    }
-    _soundLoaded(audioData) {
-        if (!AbstractEngine.audioEngine?.audioContext) {
-            return;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        AbstractEngine.audioEngine.audioContext.decodeAudioData(audioData, (buffer) => {
-            this._audioBufferLoaded(buffer);
-        }, (err) => {
-            Logger.Error("Error while decoding audio data for: " + this.name + " / Error: " + err);
-        });
-    }
     /**
      * Sets the data of the sound from an audiobuffer
      * @param audioBuffer The audioBuffer containing the data
      */
     setAudioBuffer(audioBuffer) {
-        if (AbstractEngine.audioEngine?.canUseWebAudio) {
-            this._audioBuffer = audioBuffer;
-            this._isReadyToPlay = true;
+        if (this._isReadyToPlay) {
+            return;
+        }
+        if (this._soundV2 instanceof _WebAudioStaticSound) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises, github/no-then
+            this._soundV2._initAsync(audioBuffer, this._optionsV2).then(this._onReadyToPlay);
         }
     }
     /**
@@ -448,104 +390,73 @@ export class Sound {
             this.rolloffFactor = options.rolloffFactor ?? this.rolloffFactor;
             this.refDistance = options.refDistance ?? this.refDistance;
             this.distanceModel = options.distanceModel ?? this.distanceModel;
-            this._playbackRate = options.playbackRate ?? this._playbackRate;
-            this._length = options.length ?? undefined;
-            this.spatialSound = options.spatialSound ?? this._spatialSound;
-            this._setOffset(options.offset ?? undefined);
-            this.setVolume(options.volume ?? this._volume);
-            this._updateSpatialParameters();
-            if (this.isPlaying) {
-                if (this._streaming && this._htmlAudioElement) {
-                    this._htmlAudioElement.playbackRate = this._playbackRate;
-                    if (this._htmlAudioElement.loop !== this.loop) {
-                        this._htmlAudioElement.loop = this.loop;
-                    }
-                }
-                else {
-                    if (this._soundSource) {
-                        this._soundSource.playbackRate.value = this._playbackRate;
-                        if (this._soundSource.loop !== this.loop) {
-                            this._soundSource.loop = this.loop;
-                        }
-                        if (this._offset !== undefined && this._soundSource.loopStart !== this._offset) {
-                            this._soundSource.loopStart = this._offset;
-                        }
-                        if (this._length !== undefined && this._length !== this._soundSource.loopEnd) {
-                            this._soundSource.loopEnd = (this._offset | 0) + this._length;
-                        }
-                    }
-                }
+            if (options.playbackRate !== undefined) {
+                this.setPlaybackRate(options.playbackRate);
             }
-        }
-    }
-    _createSpatialParameters() {
-        if (AbstractEngine.audioEngine?.canUseWebAudio && AbstractEngine.audioEngine.audioContext) {
-            if (this._scene.headphone) {
-                this._panningModel = "HRTF";
+            if (options.spatialSound !== undefined) {
+                this.spatialSound = options.spatialSound;
             }
-            this._soundPanner = this._soundPanner ?? AbstractEngine.audioEngine.audioContext.createPanner();
-            if (this._soundPanner && this._outputAudioNode) {
-                this._updateSpatialParameters();
-                this._soundPanner.connect(this._outputAudioNode);
-                this._inputAudioNode = this._soundPanner;
+            if (options.volume !== undefined) {
+                this.setVolume(options.volume);
             }
+            if (this._soundV2 instanceof _WebAudioStaticSound) {
+                let updated = false;
+                if (options.offset !== undefined) {
+                    this._optionsV2.startOffset = options.offset;
+                    updated = true;
+                }
+                if (options.length !== undefined) {
+                    this._soundV2.duration = options.length;
+                    updated = true;
+                }
+                if (updated && this.isPaused) {
+                    this.stop();
+                }
+            }
+            this._updateSpatialParameters();
         }
     }
-    _disableSpatialSound() {
-        if (!this._spatialSound) {
-            return;
-        }
-        this._inputAudioNode = this._soundGain;
-        this._soundPanner?.disconnect();
-        this._soundPanner = null;
-        this._spatialSound = false;
-    }
     _updateSpatialParameters() {
-        if (!this._spatialSound) {
+        if (!this.spatialSound) {
             return;
         }
-        if (this._soundPanner) {
-            if (this.useCustomAttenuation) {
-                // Tricks to disable in a way embedded Web Audio attenuation
-                this._soundPanner.distanceModel = "linear";
-                this._soundPanner.maxDistance = Number.MAX_VALUE;
-                this._soundPanner.refDistance = 1;
-                this._soundPanner.rolloffFactor = 1;
-                this._soundPanner.panningModel = this._panningModel;
-            }
-            else {
-                this._soundPanner.distanceModel = this.distanceModel;
-                this._soundPanner.maxDistance = this.maxDistance;
-                this._soundPanner.refDistance = this.refDistance;
-                this._soundPanner.rolloffFactor = this.rolloffFactor;
-                this._soundPanner.panningModel = this._panningModel;
-            }
+        const spatial = this._soundV2.spatial;
+        if (this.useCustomAttenuation) {
+            // Disable WebAudio attenuation.
+            spatial.distanceModel = "linear";
+            spatial.minDistance = 1;
+            spatial.maxDistance = Number.MAX_VALUE;
+            spatial.rolloffFactor = 1;
+            spatial.panningModel = "equalpower";
         }
         else {
-            this._createSpatialParameters();
+            spatial.distanceModel = this.distanceModel;
+            spatial.minDistance = this.refDistance;
+            spatial.maxDistance = this.maxDistance;
+            spatial.rolloffFactor = this.rolloffFactor;
+            spatial.panningModel = this._optionsV2.spatialPanningModel || "equalpower";
         }
     }
     /**
      * Switch the panning model to HRTF:
      * Renders a stereo output of higher quality than equalpower — it uses a convolution with measured impulse responses from human subjects.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
+     * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
      */
     switchPanningModelToHRTF() {
-        this._panningModel = "HRTF";
-        this._switchPanningModel();
+        if (this.spatialSound) {
+            this._initSpatial();
+            this._soundV2.spatial.panningModel = "HRTF";
+        }
     }
     /**
      * Switch the panning model to Equal Power:
      * Represents the equal-power panning algorithm, generally regarded as simple and efficient. equalpower is the default value.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-a-spatial-3d-sound
+     * @see https://doc.babylonjs.com/legacy/audio#creating-a-spatial-3d-sound
      */
     switchPanningModelToEqualPower() {
-        this._panningModel = "equalpower";
-        this._switchPanningModel();
-    }
-    _switchPanningModel() {
-        if (AbstractEngine.audioEngine?.canUseWebAudio && this._spatialSound && this._soundPanner) {
-            this._soundPanner.panningModel = this._panningModel;
+        if (this.spatialSound) {
+            this._initSpatial();
+            this._soundV2.spatial.panningModel = "equalpower";
         }
     }
     /**
@@ -553,11 +464,12 @@ export class Sound {
      * @param soundTrackAudioNode the sound track audio node to connect to
      */
     connectToSoundTrackAudioNode(soundTrackAudioNode) {
-        if (AbstractEngine.audioEngine?.canUseWebAudio && this._outputAudioNode) {
+        const outputNode = this._soundV2._outNode;
+        if (outputNode) {
             if (this._isOutputConnected) {
-                this._outputAudioNode.disconnect();
+                outputNode.disconnect();
             }
-            this._outputAudioNode.connect(soundTrackAudioNode);
+            outputNode.connect(soundTrackAudioNode);
             this._isOutputConnected = true;
         }
     }
@@ -572,33 +484,39 @@ export class Sound {
             Logger.Error("setDirectionalCone(): outer angle of the cone must be superior or equal to the inner angle.");
             return;
         }
-        this._coneInnerAngle = coneInnerAngle;
-        this._coneOuterAngle = coneOuterAngle;
-        this._coneOuterGain = coneOuterGain;
+        this._optionsV2.spatialConeInnerAngle = D2r(coneInnerAngle);
+        this._optionsV2.spatialConeOuterAngle = D2r(coneOuterAngle);
+        this._optionsV2.spatialConeOuterVolume = coneOuterGain;
+        this._initSpatial();
+        this._soundV2.spatial.coneInnerAngle = this._optionsV2.spatialConeInnerAngle;
+        this._soundV2.spatial.coneOuterAngle = this._optionsV2.spatialConeOuterAngle;
+        this._soundV2.spatial.coneOuterVolume = coneOuterGain;
         this._isDirectional = true;
         if (this.isPlaying && this.loop) {
             this.stop();
-            this.play(0, this._offset, this._length);
+            this.play(0, this._optionsV2.startOffset, this._optionsV2.duration);
         }
     }
     /**
      * Gets or sets the inner angle for the directional cone.
      */
     get directionalConeInnerAngle() {
-        return this._coneInnerAngle;
+        return R2d(typeof this._optionsV2.spatialConeInnerAngle === "number" ? this._optionsV2.spatialConeInnerAngle : _SpatialAudioDefaults.coneInnerAngle);
     }
     /**
      * Gets or sets the inner angle for the directional cone.
      */
     set directionalConeInnerAngle(value) {
-        if (value != this._coneInnerAngle) {
-            if (this._coneOuterAngle < value) {
+        value = D2r(value);
+        if (value != this._optionsV2.spatialConeInnerAngle) {
+            if (this.directionalConeOuterAngle < value) {
                 Logger.Error("directionalConeInnerAngle: outer angle of the cone must be superior or equal to the inner angle.");
                 return;
             }
-            this._coneInnerAngle = value;
-            if (AbstractEngine.audioEngine?.canUseWebAudio && this._spatialSound && this._soundPanner) {
-                this._soundPanner.coneInnerAngle = this._coneInnerAngle;
+            this._optionsV2.spatialConeInnerAngle = value;
+            if (this.spatialSound) {
+                this._initSpatial();
+                this._soundV2.spatial.coneInnerAngle = value;
             }
         }
     }
@@ -606,20 +524,22 @@ export class Sound {
      * Gets or sets the outer angle for the directional cone.
      */
     get directionalConeOuterAngle() {
-        return this._coneOuterAngle;
+        return R2d(typeof this._optionsV2.spatialConeOuterAngle === "number" ? this._optionsV2.spatialConeOuterAngle : _SpatialAudioDefaults.coneOuterAngle);
     }
     /**
      * Gets or sets the outer angle for the directional cone.
      */
     set directionalConeOuterAngle(value) {
-        if (value != this._coneOuterAngle) {
-            if (value < this._coneInnerAngle) {
+        value = D2r(value);
+        if (value != this._optionsV2.spatialConeOuterAngle) {
+            if (value < this.directionalConeInnerAngle) {
                 Logger.Error("directionalConeOuterAngle: outer angle of the cone must be superior or equal to the inner angle.");
                 return;
             }
-            this._coneOuterAngle = value;
-            if (AbstractEngine.audioEngine?.canUseWebAudio && this._spatialSound && this._soundPanner) {
-                this._soundPanner.coneOuterAngle = this._coneOuterAngle;
+            this._optionsV2.spatialConeOuterAngle = value;
+            if (this.spatialSound) {
+                this._initSpatial();
+                this._soundV2.spatial.coneOuterAngle = value;
             }
         }
     }
@@ -628,19 +548,16 @@ export class Sound {
      * @param newPosition Defines the new position
      */
     setPosition(newPosition) {
-        if (newPosition.equals(this._position)) {
+        if (this._optionsV2.spatialPosition && newPosition.equals(this._optionsV2.spatialPosition)) {
             return;
         }
-        this._position.copyFrom(newPosition);
-        if (AbstractEngine.audioEngine?.canUseWebAudio &&
-            this._spatialSound &&
-            this._soundPanner &&
-            !isNaN(this._position.x) &&
-            !isNaN(this._position.y) &&
-            !isNaN(this._position.z)) {
-            this._soundPanner.positionX.value = this._position.x;
-            this._soundPanner.positionY.value = this._position.y;
-            this._soundPanner.positionZ.value = this._position.z;
+        if (!this._optionsV2.spatialPosition) {
+            this._optionsV2.spatialPosition = Vector3.Zero();
+        }
+        this._optionsV2.spatialPosition.copyFrom(newPosition);
+        if (this.spatialSound && !isNaN(newPosition.x) && !isNaN(newPosition.y) && !isNaN(newPosition.z)) {
+            this._initSpatial();
+            this._soundV2.spatial.position = newPosition;
         }
     }
     /**
@@ -649,34 +566,44 @@ export class Sound {
      */
     setLocalDirectionToMesh(newLocalDirection) {
         this._localDirection = newLocalDirection;
-        if (AbstractEngine.audioEngine?.canUseWebAudio && this._connectedTransformNode && this.isPlaying) {
+        if (this._connectedTransformNode && this.isPlaying) {
             this._updateDirection();
         }
     }
     _updateDirection() {
-        if (!this._connectedTransformNode || !this._soundPanner) {
+        if (!this._connectedTransformNode || !this.spatialSound) {
             return;
         }
         const mat = this._connectedTransformNode.getWorldMatrix();
         const direction = Vector3.TransformNormal(this._localDirection, mat);
         direction.normalize();
-        this._soundPanner.orientationX.value = direction.x;
-        this._soundPanner.orientationY.value = direction.y;
-        this._soundPanner.orientationZ.value = direction.z;
+        this._initSpatial();
+        this._soundV2.spatial.orientation = direction;
+    }
+    _initSpatial() {
+        this._soundV2._isSpatial = true;
+        if (this._optionsV2.spatialDistanceModel === undefined) {
+            this._optionsV2.spatialDistanceModel = "linear";
+            this._soundV2.spatial.distanceModel = "linear";
+        }
+        if (this._optionsV2.spatialMaxDistance === undefined) {
+            this._optionsV2.spatialMaxDistance = 100;
+            this._soundV2.spatial.maxDistance = 100;
+        }
     }
     /** @internal */
     updateDistanceFromListener() {
-        if (AbstractEngine.audioEngine?.canUseWebAudio && this._connectedTransformNode && this.useCustomAttenuation && this._soundGain && this._scene.activeCamera) {
+        if (this._soundV2._outNode && this._connectedTransformNode && this.useCustomAttenuation && this._scene.activeCamera) {
             const distance = this._scene.audioListenerPositionProvider
                 ? this._connectedTransformNode.position.subtract(this._scene.audioListenerPositionProvider()).length()
                 : this._connectedTransformNode.getDistanceToCamera(this._scene.activeCamera);
-            this._soundGain.gain.value = this._customAttenuationFunction(this._volume, distance, this.maxDistance, this.refDistance, this.rolloffFactor);
+            this._soundV2.volume = this._customAttenuationFunction(this._volume, distance, this.maxDistance, this.refDistance, this.rolloffFactor);
         }
     }
     /**
      * Sets a new custom attenuation function for the sound.
      * @param callback Defines the function used for the attenuation
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#creating-your-own-custom-attenuation-function
+     * @see https://doc.babylonjs.com/legacy/audio#creating-your-own-custom-attenuation-function
      */
     setAttenuationFunction(callback) {
         this._customAttenuationFunction = callback;
@@ -688,225 +615,63 @@ export class Sound {
      * @param length (optional) Sound duration (in seconds)
      */
     play(time, offset, length) {
-        if (this._isReadyToPlay && this._scene.audioEnabled && AbstractEngine.audioEngine?.audioContext) {
+        const audioEngine = AbstractEngine.audioEngine;
+        audioEngine?.unlock();
+        // WebAudio sound sources have no `play` function because they are always playing.
+        if (this._soundV2 instanceof _WebAudioSoundSource) {
+            return;
+        }
+        if (this._isReadyToPlay && this._scene.audioEnabled) {
+            // The sound can only resume from pause when the `time`, `offset` and `length` args are not set.
+            if (this._soundV2.state === 5 /* SoundState.Paused */ && (time !== undefined || offset !== undefined || length !== undefined)) {
+                this._soundV2.stop();
+            }
             try {
-                this._clearTimeoutsAndObservers();
-                let startTime = time ? AbstractEngine.audioEngine?.audioContext.currentTime + time : AbstractEngine.audioEngine?.audioContext.currentTime;
-                if (!this._soundSource || !this._streamingSource) {
-                    if (this._spatialSound && this._soundPanner) {
-                        if (!isNaN(this._position.x) && !isNaN(this._position.y) && !isNaN(this._position.z)) {
-                            this._soundPanner.positionX.value = this._position.x;
-                            this._soundPanner.positionY.value = this._position.y;
-                            this._soundPanner.positionZ.value = this._position.z;
-                        }
-                        if (this._isDirectional) {
-                            this._soundPanner.coneInnerAngle = this._coneInnerAngle;
-                            this._soundPanner.coneOuterAngle = this._coneOuterAngle;
-                            this._soundPanner.coneOuterGain = this._coneOuterGain;
-                            if (this._connectedTransformNode) {
-                                this._updateDirection();
-                            }
-                            else {
-                                this._soundPanner.setOrientation(this._localDirection.x, this._localDirection.y, this._localDirection.z);
-                            }
-                        }
-                    }
-                }
-                if (this._streaming) {
-                    if (!this._streamingSource && this._htmlAudioElement) {
-                        this._streamingSource = AbstractEngine.audioEngine.audioContext.createMediaElementSource(this._htmlAudioElement);
-                        this._htmlAudioElement.onended = () => {
-                            this._onended();
-                        };
-                        this._htmlAudioElement.playbackRate = this._playbackRate;
-                    }
-                    if (this._streamingSource) {
-                        this._streamingSource.disconnect();
-                        if (this._inputAudioNode) {
-                            this._streamingSource.connect(this._inputAudioNode);
-                        }
-                    }
-                    if (this._htmlAudioElement) {
-                        // required to manage properly the new suspended default state of Chrome
-                        // When the option 'streaming: true' is used, we need first to wait for
-                        // the audio engine to be unlocked by a user gesture before trying to play
-                        // an HTML Audio element
-                        const tryToPlay = () => {
-                            if (AbstractEngine.audioEngine?.unlocked) {
-                                if (!this._htmlAudioElement) {
-                                    return;
-                                }
-                                this._htmlAudioElement.currentTime = offset ?? 0;
-                                const playPromise = this._htmlAudioElement.play();
-                                // In browsers that don’t yet support this functionality,
-                                // playPromise won’t be defined.
-                                if (playPromise !== undefined) {
-                                    // eslint-disable-next-line github/no-then
-                                    playPromise.catch(() => {
-                                        // Automatic playback failed.
-                                        // Waiting for the audio engine to be unlocked by user click on unmute
-                                        AbstractEngine.audioEngine?.lock();
-                                        if (this.loop || this.autoplay) {
-                                            this._audioUnlockedObserver = AbstractEngine.audioEngine?.onAudioUnlockedObservable.addOnce(() => {
-                                                tryToPlay();
-                                            });
-                                        }
-                                    });
-                                }
-                            }
-                            else {
-                                if (this.loop || this.autoplay) {
-                                    this._audioUnlockedObserver = AbstractEngine.audioEngine?.onAudioUnlockedObservable.addOnce(() => {
-                                        tryToPlay();
-                                    });
-                                }
-                            }
-                        };
-                        tryToPlay();
-                    }
+                TmpPlayOptions.duration = length || 0;
+                TmpPlayOptions.startOffset = offset !== undefined ? offset || this._optionsV2.startOffset : this._optionsV2.startOffset;
+                TmpPlayOptions.waitTime = time || 0;
+                if (audioEngine?.unlocked) {
+                    this._soundV2.play(TmpPlayOptions);
                 }
                 else {
-                    const tryToPlay = () => {
-                        if (AbstractEngine.audioEngine?.audioContext) {
-                            length = length || this._length;
-                            if (offset !== undefined) {
-                                this._setOffset(offset);
-                            }
-                            if (this._soundSource) {
-                                const oldSource = this._soundSource;
-                                oldSource.onended = () => {
-                                    oldSource.disconnect();
-                                };
-                            }
-                            this._soundSource = AbstractEngine.audioEngine?.audioContext.createBufferSource();
-                            if (this._soundSource && this._inputAudioNode) {
-                                this._soundSource.buffer = this._audioBuffer;
-                                this._soundSource.connect(this._inputAudioNode);
-                                this._soundSource.loop = this.loop;
-                                if (offset !== undefined) {
-                                    this._soundSource.loopStart = offset;
-                                }
-                                if (length !== undefined) {
-                                    this._soundSource.loopEnd = (offset | 0) + length;
-                                }
-                                this._soundSource.playbackRate.value = this._playbackRate;
-                                this._soundSource.onended = () => {
-                                    this._onended();
-                                };
-                                startTime = time ? AbstractEngine.audioEngine?.audioContext.currentTime + time : AbstractEngine.audioEngine.audioContext.currentTime;
-                                const actualOffset = ((this.isPaused ? this.currentTime : 0) + (this._offset ?? 0)) % this._soundSource.buffer.duration;
-                                this._soundSource.start(startTime, actualOffset, this.loop ? undefined : length);
-                            }
-                        }
-                    };
-                    if (AbstractEngine.audioEngine?.audioContext.state === "suspended") {
-                        // Wait a bit for FF as context seems late to be ready.
-                        this._tryToPlayTimeout = setTimeout(() => {
-                            if (AbstractEngine.audioEngine?.audioContext.state === "suspended") {
-                                // Automatic playback failed.
-                                // Waiting for the audio engine to be unlocked by user click on unmute
-                                AbstractEngine.audioEngine.lock();
-                                if (this.loop || this.autoplay) {
-                                    this._audioUnlockedObserver = AbstractEngine.audioEngine.onAudioUnlockedObservable.addOnce(() => {
-                                        tryToPlay();
-                                    });
-                                }
-                            }
-                            else {
-                                tryToPlay();
-                            }
-                        }, 500);
-                    }
-                    else {
-                        tryToPlay();
-                    }
+                    // Wait a bit for FF as context seems late to be ready.
+                    setTimeout(() => {
+                        this._soundV2.play(TmpPlayOptions);
+                    }, 500);
                 }
-                this._startTime = startTime;
-                this.isPlaying = true;
-                this.isPaused = false;
             }
             catch (ex) {
                 Logger.Error("Error while trying to play audio: " + this.name + ", " + ex.message);
             }
         }
     }
-    _onended() {
-        this.isPlaying = false;
-        this._startTime = 0;
-        this._currentTime = 0;
-        if (this.onended) {
-            this.onended();
-        }
-        this.onEndedObservable.notifyObservers(this);
-    }
     /**
      * Stop the sound
      * @param time (optional) Stop the sound after X seconds. Stop immediately (0) by default.
      */
     stop(time) {
-        if (this.isPlaying) {
-            this._clearTimeoutsAndObservers();
-            if (this._streaming) {
-                if (this._htmlAudioElement) {
-                    this._htmlAudioElement.pause();
-                    // Test needed for Firefox or it will generate an Invalid State Error
-                    if (this._htmlAudioElement.currentTime > 0) {
-                        this._htmlAudioElement.currentTime = 0;
-                    }
-                }
-                else {
-                    this._streamingSource?.disconnect();
-                }
-                this.isPlaying = false;
-            }
-            else if (AbstractEngine.audioEngine?.audioContext && this._soundSource) {
-                const stopTime = time ? AbstractEngine.audioEngine.audioContext.currentTime + time : undefined;
-                this._soundSource.onended = () => {
-                    this.isPlaying = false;
-                    this.isPaused = false;
-                    this._startTime = 0;
-                    this._currentTime = 0;
-                    if (this._soundSource) {
-                        this._soundSource.onended = () => void 0;
-                    }
-                    this._onended();
-                };
-                this._soundSource.stop(stopTime);
-            }
-            else {
-                this.isPlaying = false;
-            }
+        if (!this._soundV2) {
+            return;
         }
-        else if (this.isPaused) {
-            this.isPaused = false;
-            this._startTime = 0;
-            this._currentTime = 0;
+        // WebAudio sound sources have no `stop` function because they are always playing.
+        if (this._soundV2 instanceof _WebAudioSoundSource) {
+            return;
         }
+        TmpStopOptions.waitTime = time || 0;
+        this._soundV2.stop(TmpStopOptions);
     }
     /**
      * Put the sound in pause
      */
     pause() {
-        if (this.isPlaying) {
-            this._clearTimeoutsAndObservers();
-            if (this._streaming) {
-                if (this._htmlAudioElement) {
-                    this._htmlAudioElement.pause();
-                }
-                else {
-                    this._streamingSource?.disconnect();
-                }
-                this.isPlaying = false;
-                this.isPaused = true;
-            }
-            else if (AbstractEngine.audioEngine?.audioContext && this._soundSource) {
-                this._soundSource.onended = () => void 0;
-                this._soundSource.stop();
-                this.isPlaying = false;
-                this.isPaused = true;
-                this._currentTime += AbstractEngine.audioEngine.audioContext.currentTime - this._startTime;
-            }
+        if (!this._soundV2) {
+            return;
         }
+        // WebAudio sound sources have no `pause` function because they are always playing.
+        if (this._soundV2 instanceof _WebAudioSoundSource) {
+            return;
+        }
+        this._soundV2.pause();
     }
     /**
      * Sets a dedicated volume for this sounds
@@ -914,16 +679,14 @@ export class Sound {
      * @param time Define time for gradual change to new volume
      */
     setVolume(newVolume, time) {
-        if (AbstractEngine.audioEngine?.canUseWebAudio && this._soundGain) {
-            if (time && AbstractEngine.audioEngine.audioContext) {
-                this._soundGain.gain.cancelScheduledValues(AbstractEngine.audioEngine.audioContext.currentTime);
-                this._soundGain.gain.setValueAtTime(this._soundGain.gain.value, AbstractEngine.audioEngine.audioContext.currentTime);
-                this._soundGain.gain.linearRampToValueAtTime(newVolume, AbstractEngine.audioEngine.audioContext.currentTime + time);
-            }
-            else {
-                this._soundGain.gain.value = newVolume;
-            }
+        if (!this.isReady()) {
+            this._onReady.addOnce(() => {
+                this.setVolume(newVolume, time);
+            });
+            return;
         }
+        TmpRampOptions.duration = time || 0;
+        this._soundV2.setVolume(newVolume, TmpRampOptions);
         this._volume = newVolume;
     }
     /**
@@ -931,14 +694,8 @@ export class Sound {
      * @param newPlaybackRate Define the playback rate the sound should be played at
      */
     setPlaybackRate(newPlaybackRate) {
-        this._playbackRate = newPlaybackRate;
-        if (this.isPlaying) {
-            if (this._streaming && this._htmlAudioElement) {
-                this._htmlAudioElement.playbackRate = this._playbackRate;
-            }
-            else if (this._soundSource) {
-                this._soundSource.playbackRate.value = this._playbackRate;
-            }
+        if (this._soundV2 instanceof _WebAudioStaticSound) {
+            this._soundV2.playbackRate = newPlaybackRate;
         }
     }
     /**
@@ -946,7 +703,10 @@ export class Sound {
      * @returns the  play back rate of the sound
      */
     getPlaybackRate() {
-        return this._playbackRate;
+        if (this._soundV2 instanceof _WebAudioStaticSound) {
+            return this._soundV2.playbackRate;
+        }
+        return 1;
     }
     /**
      * Gets the volume of the sound.
@@ -958,7 +718,7 @@ export class Sound {
     /**
      * Attach the sound to a dedicated mesh
      * @param transformNode The transform node to connect the sound with
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#attaching-a-sound-to-a-mesh
+     * @see https://doc.babylonjs.com/legacy/audio#attaching-a-sound-to-a-mesh
      */
     attachToMesh(transformNode) {
         if (this._connectedTransformNode && this._registerFunc) {
@@ -966,12 +726,11 @@ export class Sound {
             this._registerFunc = null;
         }
         this._connectedTransformNode = transformNode;
-        if (!this._spatialSound) {
-            this._spatialSound = true;
-            this._createSpatialParameters();
+        if (!this.spatialSound) {
+            this.spatialSound = true;
             if (this.isPlaying && this.loop) {
                 this.stop();
-                this.play(0, this._offset, this._length);
+                this.play(0, this._optionsV2.startOffset, this._optionsV2.duration);
             }
         }
         this._onRegisterAfterWorldMatrixUpdate(this._connectedTransformNode);
@@ -980,7 +739,7 @@ export class Sound {
     }
     /**
      * Detach the sound from the previously attached mesh
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic#attaching-a-sound-to-a-mesh
+     * @see https://doc.babylonjs.com/legacy/audio#attaching-a-sound-to-a-mesh
      */
     detachFromMesh() {
         if (this._connectedTransformNode && this._registerFunc) {
@@ -998,7 +757,7 @@ export class Sound {
             const boundingInfo = mesh.getBoundingInfo();
             this.setPosition(boundingInfo.boundingSphere.centerWorld);
         }
-        if (AbstractEngine.audioEngine?.canUseWebAudio && this._isDirectional && this.isPlaying) {
+        if (this._isDirectional && this.isPlaying) {
             this._updateDirection();
         }
     }
@@ -1007,61 +766,51 @@ export class Sound {
      * @returns the new sound clone
      */
     clone() {
-        if (!this._streaming) {
-            const setBufferAndRun = () => {
-                _RetryWithInterval(() => this._isReadyToPlay, () => {
-                    clonedSound._audioBuffer = this.getAudioBuffer();
-                    clonedSound._isReadyToPlay = true;
-                    if (clonedSound.autoplay) {
-                        clonedSound.play(0, this._offset, this._length);
-                    }
-                }, undefined, 300);
-            };
-            const currentOptions = {
-                autoplay: this.autoplay,
-                loop: this.loop,
-                volume: this._volume,
-                spatialSound: this._spatialSound,
-                maxDistance: this.maxDistance,
-                useCustomAttenuation: this.useCustomAttenuation,
-                rolloffFactor: this.rolloffFactor,
-                refDistance: this.refDistance,
-                distanceModel: this.distanceModel,
-            };
-            const clonedSound = new Sound(this.name + "_cloned", new ArrayBuffer(0), this._scene, null, currentOptions);
-            if (this.useCustomAttenuation) {
-                clonedSound.setAttenuationFunction(this._customAttenuationFunction);
-            }
-            clonedSound.setPosition(this._position);
-            clonedSound.setPlaybackRate(this._playbackRate);
-            setBufferAndRun();
-            return clonedSound;
-        }
-        // Can't clone a streaming sound
-        else {
+        if (!(this._soundV2 instanceof _WebAudioStaticSound)) {
             return null;
         }
+        const currentOptions = {
+            autoplay: this.autoplay,
+            loop: this.loop,
+            volume: this._volume,
+            spatialSound: this.spatialSound,
+            maxDistance: this.maxDistance,
+            useCustomAttenuation: this.useCustomAttenuation,
+            rolloffFactor: this.rolloffFactor,
+            refDistance: this.refDistance,
+            distanceModel: this.distanceModel,
+        };
+        const clonedSound = new Sound(this.name + "_cloned", this._soundV2.buffer, this._scene, null, currentOptions);
+        clonedSound._optionsV2 = this._optionsV2;
+        if (this.useCustomAttenuation) {
+            clonedSound.setAttenuationFunction(this._customAttenuationFunction);
+        }
+        return clonedSound;
     }
     /**
      * Gets the current underlying audio buffer containing the data
      * @returns the audio buffer
      */
     getAudioBuffer() {
-        return this._audioBuffer;
+        if (this._soundV2 instanceof _WebAudioStaticSound) {
+            return this._soundV2.buffer._audioBuffer;
+        }
+        return null;
     }
     /**
      * Gets the WebAudio AudioBufferSourceNode, lets you keep track of and stop instances of this Sound.
      * @returns the source node
      */
     getSoundSource() {
-        return this._soundSource;
+        // return this._soundSource;
+        return null;
     }
     /**
      * Gets the WebAudio GainNode, gives you precise control over the gain of instances of this Sound.
      * @returns the gain node
      */
     getSoundGain() {
-        return this._soundGain;
+        return this._soundV2._outNode;
     }
     /**
      * Serializes the Sound in a JSON representation
@@ -1074,28 +823,28 @@ export class Sound {
             autoplay: this.autoplay,
             loop: this.loop,
             volume: this._volume,
-            spatialSound: this._spatialSound,
+            spatialSound: this.spatialSound,
             maxDistance: this.maxDistance,
             rolloffFactor: this.rolloffFactor,
             refDistance: this.refDistance,
             distanceModel: this.distanceModel,
-            playbackRate: this._playbackRate,
-            panningModel: this._panningModel,
+            playbackRate: this.getPlaybackRate(),
+            panningModel: this._soundV2.spatial.panningModel,
             soundTrackId: this.soundTrackId,
             metadata: this.metadata,
         };
-        if (this._spatialSound) {
+        if (this.spatialSound) {
             if (this._connectedTransformNode) {
                 serializationObject.connectedMeshId = this._connectedTransformNode.id;
             }
-            serializationObject.position = this._position.asArray();
+            serializationObject.position = this._soundV2.spatial.position.asArray();
             serializationObject.refDistance = this.refDistance;
             serializationObject.distanceModel = this.distanceModel;
             serializationObject.isDirectional = this._isDirectional;
             serializationObject.localDirectionToMesh = this._localDirection.asArray();
-            serializationObject.coneInnerAngle = this._coneInnerAngle;
-            serializationObject.coneOuterAngle = this._coneOuterAngle;
-            serializationObject.coneOuterGain = this._coneOuterGain;
+            serializationObject.coneInnerAngle = this.directionalConeInnerAngle;
+            serializationObject.coneOuterAngle = this.directionalConeOuterAngle;
+            serializationObject.coneOuterGain = this._soundV2.spatial.coneOuterVolume;
         }
         return serializationObject;
     }
@@ -1137,10 +886,13 @@ export class Sound {
         else {
             const setBufferAndRun = () => {
                 _RetryWithInterval(() => sourceSound._isReadyToPlay, () => {
-                    newSound._audioBuffer = sourceSound.getAudioBuffer();
+                    const audioBuffer = sourceSound.getAudioBuffer();
+                    if (audioBuffer) {
+                        newSound.setAudioBuffer(audioBuffer);
+                    }
                     newSound._isReadyToPlay = true;
                     if (newSound.autoplay) {
-                        newSound.play(0, newSound._offset, newSound._length);
+                        newSound.play(0, sourceSound._optionsV2.startOffset, sourceSound._optionsV2.duration);
                     }
                 }, undefined, 300);
             };
@@ -1169,26 +921,6 @@ export class Sound {
         }
         return newSound;
     }
-    _setOffset(value) {
-        if (this._offset === value) {
-            return;
-        }
-        if (this.isPaused) {
-            this.stop();
-            this.isPaused = false;
-        }
-        this._offset = value;
-    }
-    _clearTimeoutsAndObservers() {
-        if (this._tryToPlayTimeout) {
-            clearTimeout(this._tryToPlayTimeout);
-            this._tryToPlayTimeout = null;
-        }
-        if (this._audioUnlockedObserver) {
-            AbstractEngine.audioEngine?.onAudioUnlockedObservable.remove(this._audioUnlockedObserver);
-            this._audioUnlockedObserver = null;
-        }
-    }
 }
 /**
  * @internal