@galacean/engine-core 0.0.0-experimental-2.0-game.4 → 0.0.0-experimental-2.0-game.6

package/dist/main.js

@@ -7826,7 +7826,6 @@ var ShaderLib = _extends({
     normal_get: normal_get
 }, ParticleShaderLib);
 
-console.log(123);
 /**
  * @internal
  */ var ShaderFactory = /*#__PURE__*/ function() {
@@ -26505,6 +26504,9 @@ Shader.create("FinalAntiAliasing", BlitVS, FinalAntiAliasingFS);
         Utils._quickSort(this.elements, 0, this.elements.length, compareFunc);
         this.batch(batcherManager);
     };
+    _proto.sort = function sort(compareFunc) {
+        Utils._quickSort(this.elements, 0, this.elements.length, compareFunc);
+    };
     _proto.batch = function batch(batcherManager) {
         batcherManager.batch(this);
     };
@@ -27453,6 +27455,16 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
         this.alphaTestQueue.sortBatch(RenderQueue.compareForOpaque, batcherManager);
         this.transparentQueue.sortBatch(RenderQueue.compareForTransparent, batcherManager);
     };
+    _proto.sort = function sort() {
+        this.opaqueQueue.sort(RenderQueue.compareForOpaque);
+        this.alphaTestQueue.sort(RenderQueue.compareForOpaque);
+        this.transparentQueue.sort(RenderQueue.compareForTransparent);
+    };
+    _proto.batch = function batch(batcherManager) {
+        this.opaqueQueue.batch(batcherManager);
+        this.alphaTestQueue.batch(batcherManager);
+        this.transparentQueue.batch(batcherManager);
+    };
     _proto.setRenderUpdateFlagTrue = function setRenderUpdateFlagTrue(rendererUpdateFlag) {
         this.opaqueQueue.rendererUpdateFlag |= rendererUpdateFlag;
         this.transparentQueue.rendererUpdateFlag |= rendererUpdateFlag;
@@ -27601,9 +27613,11 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
         // Depth use camera's view and projection matrix
         this._cullingResults.setRenderUpdateFlagTrue(ContextRendererUpdateFlag.viewProjectionMatrix);
         context.applyVirtualCamera(camera._virtualCamera, depthPassEnabled);
-        this._prepareRender(context);
+        this._prepareWorldRender(context);
         var batcherManager = engine._batcherManager;
-        cullingResults.sortBatch(batcherManager);
+        cullingResults.sort();
+        this._prepareUIRender(context);
+        cullingResults.batch(batcherManager);
         batcherManager.uploadBuffer();
         if (depthPassEnabled) {
             depthOnlyPass.onConfig(camera);
@@ -27849,10 +27863,10 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
         (pass._renderState || material.renderState)._applyStates(engine, false, pass._renderStateDataMap, material.shaderData);
         rhi.drawPrimitive(mesh._primitive, mesh.subMesh, program);
     };
-    _proto._prepareRender = function _prepareRender(context) {
+    _proto._prepareWorldRender = function _prepareWorldRender(context) {
         var camera = context.camera;
         var engine = camera.engine, enableFrustumCulling = camera.enableFrustumCulling, cullingMask = camera.cullingMask, frustum = camera._frustum;
-        var _camera_scene__componentsManager = camera.scene._componentsManager, renderers = _camera_scene__componentsManager._renderers, canvases = _camera_scene__componentsManager._canvases;
+        var renderers = camera.scene._componentsManager._renderers;
         var rendererElements = renderers._elements;
         for(var i = renderers.length - 1; i >= 0; --i){
             var renderer = rendererElements[i];
@@ -27869,9 +27883,14 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
             renderer._prepareRender(context);
             renderer._renderFrameCount = engine.time.frameCount;
         }
+    };
+    _proto._prepareUIRender = function _prepareUIRender(context) {
+        var camera = context.camera;
+        var cullingMask = camera.cullingMask;
+        var canvases = camera.scene._componentsManager._canvases;
         var canvasesElements = canvases._elements;
-        for(var i1 = canvases.length - 1; i1 >= 0; i1--){
-            var canvas = canvasesElements[i1];
+        for(var i = canvases.length - 1; i >= 0; i--){
+            var canvas = canvasesElements[i];
             // Filter by camera culling mask
             if (!(cullingMask & canvas.entity.layer)) {
                 continue;
@@ -40350,6 +40369,7 @@ var cacheDir = new engineMath.Vector3();
    * @returns A promise that resolves when the audio context is suspended
    */ AudioManager.suspend = function suspend() {
         var _AudioManager__context;
+        AudioManager._suspendActiveSourcesForInterruption();
         var _AudioManager__context_suspend;
         return (_AudioManager__context_suspend = (_AudioManager__context = AudioManager._context) == null ? void 0 : _AudioManager__context.suspend()) != null ? _AudioManager__context_suspend : Promise.resolve();
     };
@@ -40359,12 +40379,21 @@ var cacheDir = new engineMath.Vector3();
    * @returns A promise that resolves when the audio context is resumed
    */ AudioManager.resume = function resume() {
         var context = AudioManager._context;
-        if (!context || context.state === "running") {
+        if (!context) {
+            return Promise.resolve();
+        }
+        if (context.state === "running") {
+            AudioManager._clearForegroundRestore();
+            AudioManager._needsUserGestureResume = false;
+            AudioManager._resumePendingSources();
+            AudioManager._resumeInterruptedSources();
             return Promise.resolve();
         }
         return context.resume().then(function() {
+            AudioManager._clearForegroundRestore();
             AudioManager._needsUserGestureResume = false;
             AudioManager._resumePendingSources();
+            AudioManager._resumeInterruptedSources();
         });
     };
     /** @internal */ AudioManager._registerPendingSource = function _registerPendingSource(source) {
@@ -40373,6 +40402,15 @@ var cacheDir = new engineMath.Vector3();
     /** @internal */ AudioManager._unregisterPendingSource = function _unregisterPendingSource(source) {
         AudioManager._pendingSources.delete(source);
     };
+    /** @internal */ AudioManager._registerPlayingSource = function _registerPlayingSource(source) {
+        AudioManager._playingSources.add(source);
+    };
+    /** @internal */ AudioManager._unregisterPlayingSource = function _unregisterPlayingSource(source) {
+        AudioManager._playingSources.delete(source);
+    };
+    /** @internal */ AudioManager._unregisterInterruptedSource = function _unregisterInterruptedSource(source) {
+        AudioManager._interruptedSources.delete(source);
+    };
     /**
    * @internal
    */ AudioManager.getContext = function getContext() {
@@ -40380,15 +40418,11 @@ var cacheDir = new engineMath.Vector3();
         if (!context) {
             AudioManager._context = context = new window.AudioContext();
             context.onstatechange = AudioManager._onContextStateChange;
-            document.addEventListener("visibilitychange", AudioManager._onVisibilityChange);
-            // iOS Safari requires user gesture to resume AudioContext
-            document.addEventListener("touchstart", AudioManager._resumeAfterInterruption, {
-                passive: true
-            });
-            document.addEventListener("touchend", AudioManager._resumeAfterInterruption, {
-                passive: true
-            });
-            document.addEventListener("click", AudioManager._resumeAfterInterruption);
+            if (!AudioManager._eventsBound) {
+                AudioManager._eventsBound = true;
+                AudioManager._bindLifecycleEvents();
+                AudioManager._bindGestureEvents();
+            }
         }
         return context;
     };
@@ -40411,8 +40445,12 @@ var cacheDir = new engineMath.Vector3();
     AudioManager._onContextStateChange = function _onContextStateChange() {
         var _AudioManager__context;
         if (((_AudioManager__context = AudioManager._context) == null ? void 0 : _AudioManager__context.state) === "running") {
+            if (AudioManager._hidden || AudioManager._needsUserGestureResume) {
+                return;
+            }
             AudioManager._needsUserGestureResume = false;
             AudioManager._resumePendingSources();
+            AudioManager._resumeInterruptedSources();
         }
     };
     AudioManager._resumePendingSources = function _resumePendingSources() {
@@ -40425,41 +40463,131 @@ var cacheDir = new engineMath.Vector3();
             pendingSources[i]._resumePendingPlayback();
         }
     };
-    AudioManager._onVisibilityChange = function _onVisibilityChange() {
-        var context = AudioManager._context;
-        if (document.hidden || !context || AudioManager._playingCount === 0 && AudioManager._pendingSources.size === 0 || context.state === "running") {
+    AudioManager._suspendActiveSourcesForInterruption = function _suspendActiveSourcesForInterruption() {
+        if (!AudioManager._playingSources.size) {
             return;
         }
-        AudioManager.resume().then(function() {
-            var _AudioManager__context;
-            if (((_AudioManager__context = AudioManager._context) == null ? void 0 : _AudioManager__context.state) !== "running") {
-                return AudioManager._prepareGestureResume();
+        var playingSources = Array.from(AudioManager._playingSources);
+        for(var i = 0, n = playingSources.length; i < n; i++){
+            var source = playingSources[i];
+            if (source._suspendPlaybackForInterruption()) {
+                AudioManager._interruptedSources.add(source);
             }
-        }).catch(function() {
-            return AudioManager._prepareGestureResume();
-        });
+        }
+    };
+    AudioManager._resumeInterruptedSources = function _resumeInterruptedSources() {
+        if (!AudioManager._interruptedSources.size || !AudioManager.isAudioContextRunning()) {
+            return;
+        }
+        var interruptedSources = Array.from(AudioManager._interruptedSources);
+        AudioManager._interruptedSources.clear();
+        for(var i = 0, n = interruptedSources.length; i < n; i++){
+            interruptedSources[i]._resumeInterruptedPlayback();
+        }
+    };
+    AudioManager._bindLifecycleEvents = function _bindLifecycleEvents() {
+        var hiddenProp = AudioManager._getHiddenProp();
+        var visibilityEvents = [
+            "visibilitychange",
+            "mozvisibilitychange",
+            "msvisibilitychange",
+            "webkitvisibilitychange",
+            "qbrowserVisibilityChange"
+        ];
+        for(var i = 0, n = visibilityEvents.length; i < n; i++){
+            document.addEventListener(visibilityEvents[i], function(event) {
+                var hidden = hiddenProp ? Boolean(document[hiddenProp] || (event == null ? void 0 : event.hidden)) : document.hidden;
+                hidden ? AudioManager._onHidden() : AudioManager._onShown();
+            });
+        }
+        window.addEventListener("pagehide", AudioManager._onHidden);
+        window.addEventListener("pageshow", AudioManager._onShown);
+        document.addEventListener("pagehide", AudioManager._onHidden);
+        document.addEventListener("pageshow", AudioManager._onShown);
+    };
+    AudioManager._bindGestureEvents = function _bindGestureEvents() {
+        var gestureEvents = [
+            "pointerdown",
+            "pointerup",
+            "touchstart",
+            "touchend",
+            "mouseup",
+            "click"
+        ];
+        for(var i = 0, n = gestureEvents.length; i < n; i++){
+            document.addEventListener(gestureEvents[i], AudioManager._resumeAfterInterruption, {
+                passive: true
+            });
+        }
+    };
+    AudioManager._getHiddenProp = function _getHiddenProp() {
+        var doc = document;
+        if (typeof doc.hidden !== "undefined") return "hidden";
+        if (typeof doc.mozHidden !== "undefined") return "mozHidden";
+        if (typeof doc.msHidden !== "undefined") return "msHidden";
+        if (typeof doc.webkitHidden !== "undefined") return "webkitHidden";
+        return "";
+    };
+    AudioManager._hasResumeWork = function _hasResumeWork() {
+        return AudioManager._needsUserGestureResume || AudioManager._pendingSources.size > 0 || AudioManager._interruptedSources.size > 0;
+    };
+    AudioManager._onHidden = function _onHidden() {
+        if (AudioManager._hidden) {
+            return;
+        }
+        AudioManager._hidden = true;
+        AudioManager._clearForegroundRestore();
+        AudioManager.suspend().catch(function() {});
+    };
+    AudioManager._onShown = function _onShown() {
+        if (!AudioManager._hidden) {
+            return;
+        }
+        AudioManager._hidden = false;
+        if (AudioManager._hasResumeWork()) {
+            AudioManager._prepareGestureResume();
+            AudioManager._scheduleForegroundRestore();
+        }
     };
     AudioManager._resumeAfterInterruption = function _resumeAfterInterruption() {
-        if (AudioManager._needsUserGestureResume || AudioManager._pendingSources.size > 0) {
+        if (AudioManager._hasResumeWork()) {
             AudioManager.resume().catch(function(e) {
                 console.warn("Failed to resume AudioContext:", e);
             });
         }
     };
+    AudioManager._scheduleForegroundRestore = function _scheduleForegroundRestore() {
+        AudioManager._clearForegroundRestore();
+        AudioManager._foregroundRestoreTimer = window.setTimeout(function() {
+            AudioManager._foregroundRestoreTimer = undefined;
+            AudioManager.resume().catch(function() {
+                return AudioManager._prepareGestureResume();
+            });
+        }, AudioManager._foregroundRestoreDelay);
+    };
+    AudioManager._clearForegroundRestore = function _clearForegroundRestore() {
+        if (AudioManager._foregroundRestoreTimer === undefined) {
+            return;
+        }
+        window.clearTimeout(AudioManager._foregroundRestoreTimer);
+        AudioManager._foregroundRestoreTimer = undefined;
+    };
     AudioManager._prepareGestureResume = function _prepareGestureResume() {
-        // iOS WKWebView WebKit bug(Triggered in LingGuang App): AudioContext may be in a "zombie" state where
-        // state reports "suspended" but resume() alone won't restart audio rendering.
-        // Calling suspend() first forces a clean internal state reset before user gesture triggers resume.
-        // Related: https://bugs.webkit.org/show_bug.cgi?id=263627
-        return AudioManager.suspend().catch(function() {}).then(function() {
-            AudioManager._needsUserGestureResume = true;
-        });
+        // iOS WKWebView may report a resumable state while rendering is still frozen.
+        // Force a clean context edge, then let a gesture or foreground retry restore sources.
+        AudioManager._needsUserGestureResume = true;
+        return AudioManager.suspend().catch(function() {});
     };
     return AudioManager;
 }();
 /** @internal */ AudioManager._playingCount = 0;
 AudioManager._needsUserGestureResume = false;
 AudioManager._pendingSources = new Set();
+AudioManager._playingSources = new Set();
+AudioManager._interruptedSources = new Set();
+AudioManager._foregroundRestoreDelay = 300;
+AudioManager._hidden = false;
+AudioManager._eventsBound = false;
 
 /**
  * Audio Source Component.
@@ -40495,23 +40623,27 @@ AudioManager._pendingSources = new Set();
    * Stops playing the clip.
    */ _proto.stop = function stop() {
         this._cancelPendingPlayback();
+        AudioManager._unregisterInterruptedSource(this);
         if (this._isPlaying) {
             this._clearSourceNode();
             this._isPlaying = false;
-            this._pausedTime = -1;
-            this._playTime = -1;
             AudioManager._playingCount--;
+            AudioManager._unregisterPlayingSource(this);
         }
+        this._pausedTime = -1;
+        this._playTime = -1;
     };
     /**
    * Pauses playing the clip.
    */ _proto.pause = function pause() {
         this._cancelPendingPlayback();
+        AudioManager._unregisterInterruptedSource(this);
         if (this._isPlaying) {
             this._clearSourceNode();
             this._pausedTime = AudioManager.getContext().currentTime;
             this._isPlaying = false;
             AudioManager._playingCount--;
+            AudioManager._unregisterPlayingSource(this);
         }
     };
     /**
@@ -40552,29 +40684,75 @@ AudioManager._pendingSources = new Set();
         }
         this._startPlayback();
     };
+    /** @internal */ _proto._suspendPlaybackForInterruption = function _suspendPlaybackForInterruption() {
+        if (!this._isPlaying) {
+            return false;
+        }
+        var pausedTime = AudioManager.getContext().currentTime;
+        this._clearSourceNode();
+        this._pausedTime = pausedTime;
+        this._isPlaying = false;
+        AudioManager._playingCount--;
+        AudioManager._unregisterPlayingSource(this);
+        return true;
+    };
+    /** @internal */ _proto._resumeInterruptedPlayback = function _resumeInterruptedPlayback() {
+        var _this__clip;
+        if (this._destroyed || !this.enabled || this._isPlaying || this._pendingPlay || !((_this__clip = this._clip) == null ? void 0 : _this__clip._getAudioSource()) || this._playTime < 0) {
+            return;
+        }
+        if (AudioManager.isAudioContextRunning()) {
+            this._startPlayback();
+        } else {
+            this._pendingPlay = true;
+            AudioManager._registerPendingSource(this);
+        }
+    };
     _proto._startPlayback = function _startPlayback() {
         var startTime = this._pausedTime > 0 ? this._pausedTime - this._playTime : 0;
-        this._initSourceNode(startTime);
+        if (!this._initSourceNode(startTime)) {
+            this._pausedTime = -1;
+            this._playTime = -1;
+            return;
+        }
         this._playTime = AudioManager.getContext().currentTime - startTime;
         this._pausedTime = -1;
         this._isPlaying = true;
         AudioManager._playingCount++;
+        AudioManager._registerPlayingSource(this);
     };
     _proto._initSourceNode = function _initSourceNode(startTime) {
         var context = AudioManager.getContext();
         var sourceNode = context.createBufferSource();
-        sourceNode.buffer = this._clip._getAudioSource();
+        var audioBuffer = this._clip._getAudioSource();
+        var duration = audioBuffer.duration;
+        var offset = Math.max(0, startTime);
+        if (duration > 0) {
+            if (this._loop) {
+                offset %= duration;
+            } else if (offset >= duration) {
+                return false;
+            }
+        }
+        sourceNode.buffer = audioBuffer;
         sourceNode.playbackRate.value = this._playbackRate;
         sourceNode.loop = this._loop;
         sourceNode.onended = this._onPlayEnd;
         this._sourceNode = sourceNode;
         sourceNode.connect(this._gainNode);
-        sourceNode.start(0, startTime);
+        sourceNode.start(0, offset);
+        return true;
     };
     _proto._clearSourceNode = function _clearSourceNode() {
-        this._sourceNode.stop();
-        this._sourceNode.disconnect();
-        this._sourceNode.onended = null;
+        var sourceNode = this._sourceNode;
+        if (!sourceNode) {
+            return;
+        }
+        sourceNode.onended = null;
+        try {
+            sourceNode.stop();
+        } catch (e) {}
+        sourceNode.disconnect();
         this._sourceNode = null;
     };
     _proto._cancelPendingPlayback = function _cancelPendingPlayback() {