@galacean/engine-core 2.0.0-alpha.36 → 2.0.0-alpha.38

package/dist/main.js

@@ -3852,7 +3852,7 @@ exports.TiledSpriteAssembler = __decorate([
                 sprite.name === name && outSprites.push(sprite);
             }
         } else {
-            console.warn("The name of the sprite you want to find is not exit in SpriteAtlas.");
+            console.warn("There is no sprite named " + name + " in the atlas.");
         }
         return outSprites;
     };
@@ -6063,6 +6063,9 @@ __decorate([
 __decorate([
     ignoreClone
 ], Transform.prototype, "_isParentDirty", void 0);
+__decorate([
+    ignoreClone
+], Transform.prototype, "_parentTransformCache", void 0);
 __decorate([
     ignoreClone
 ], Transform.prototype, "_dirtyFlag", void 0);
@@ -17075,9 +17078,10 @@ var ComponentCloner = /*#__PURE__*/ function() {
     };
     /**
    * Get the components which match the type of the entity and it's children.
+   * @remarks The components are returned in depth-first pre-order: the entity itself first, then each child's subtree in sibling order.
    * @param type - The component type
    * @param results - The components collection
-   * @returns	The components collection which match the type
+   * @returns The components collection which match the type
    */ _proto.getComponentsIncludeChildren = function getComponentsIncludeChildren(type, results) {
         results.length = 0;
         this._getComponentsInChildren(type, results);
@@ -17382,14 +17386,16 @@ var ComponentCloner = /*#__PURE__*/ function() {
         }
     };
     _proto._getComponentsInChildren = function _getComponentsInChildren(type, results) {
-        for(var i = this._components.length - 1; i >= 0; i--){
-            var component = this._components[i];
+        var components = this._components;
+        for(var i = 0, n = components.length; i < n; i++){
+            var component = components[i];
             if (_instanceof(component, type)) {
                 results.push(component);
             }
         }
-        for(var i1 = this._children.length - 1; i1 >= 0; i1--){
-            this._children[i1]._getComponentsInChildren(type, results);
+        var children = this._children;
+        for(var i1 = 0, n1 = children.length; i1 < n1; i1++){
+            children[i1]._getComponentsInChildren(type, results);
         }
     };
     _proto._setActiveComponents = function _setActiveComponents(isActive, activeChangeFlag) {
@@ -18821,37 +18827,39 @@ var MultiExecutor = /*#__PURE__*/ function() {
         this._contentRestorerPool = null;
         this._loadingPromises = null;
     };
-    _proto._assignDefaultOptions = function _assignDefaultOptions(assetInfo) {
-        var _assetInfo_type;
-        assetInfo.type = (_assetInfo_type = assetInfo.type) != null ? _assetInfo_type : ResourceManager._getTypeByUrl(assetInfo.url);
+    _proto._resolveLoadItemOptions = function _resolveLoadItemOptions(assetInfo, virtualResourceEntry) {
+        var _assetInfo;
+        var _virtualResourceEntry_type, _ref;
+        assetInfo.type = (_ref = (_virtualResourceEntry_type = virtualResourceEntry == null ? void 0 : virtualResourceEntry.type) != null ? _virtualResourceEntry_type : assetInfo.type) != null ? _ref : ResourceManager._getTypeByUrl(assetInfo.url);
         if (assetInfo.type === undefined) {
             throw "asset type should be specified: " + assetInfo.url;
         }
+        var _params;
+        (_params = (_assetInfo = assetInfo).params) != null ? _params : _assetInfo.params = virtualResourceEntry == null ? void 0 : virtualResourceEntry.params;
         var _assetInfo_retryCount;
         assetInfo.retryCount = (_assetInfo_retryCount = assetInfo.retryCount) != null ? _assetInfo_retryCount : this.retryCount;
         var _assetInfo_timeout;
         assetInfo.timeout = (_assetInfo_timeout = assetInfo.timeout) != null ? _assetInfo_timeout : this.timeout;
         var _assetInfo_retryInterval;
         assetInfo.retryInterval = (_assetInfo_retryInterval = assetInfo.retryInterval) != null ? _assetInfo_retryInterval : this.retryInterval;
-        var _assetInfo_url;
-        assetInfo.url = (_assetInfo_url = assetInfo.url) != null ? _assetInfo_url : assetInfo.urls.join(",");
-        return assetInfo;
     };
     _proto._loadSingleItem = function _loadSingleItem(itemOrURL) {
         var _this = this;
-        var item = this._assignDefaultOptions(typeof itemOrURL === "string" ? {
+        var item = typeof itemOrURL === "string" ? {
             url: itemOrURL
-        } : itemOrURL);
-        var url = item.url;
-        // Not absolute and base url is set
-        if (!Utils.isAbsoluteUrl(url) && this.baseUrl) url = Utils.resolveAbsoluteUrl(this.baseUrl, url);
+        } : itemOrURL;
+        var _item_url;
+        item.url = (_item_url = item.url) != null ? _item_url : item.urls.join(",");
         // Parse url
-        var _this__parseURL = this._parseURL(url), assetBaseURL = _this__parseURL.assetBaseURL, queryPath = _this__parseURL.queryPath;
+        var _this__parseURL = this._parseURL(item.url), assetBaseURL = _this__parseURL.assetBaseURL, queryPath = _this__parseURL.queryPath;
         var paths = queryPath ? this._parseQueryPath(queryPath) : [];
         // Get remote asset base url
-        var remoteConfig = this._virtualPathResourceMap[assetBaseURL];
-        var _remoteConfig_path;
-        var remoteAssetBaseURL = (_remoteConfig_path = remoteConfig == null ? void 0 : remoteConfig.path) != null ? _remoteConfig_path : assetBaseURL;
+        var virtualResourceEntry = this._virtualPathResourceMap[assetBaseURL];
+        this._resolveLoadItemOptions(item, virtualResourceEntry);
+        // Not absolute and base url is set
+        item.url = !Utils.isAbsoluteUrl(assetBaseURL) && this.baseUrl ? Utils.resolveAbsoluteUrl(this.baseUrl, assetBaseURL) : assetBaseURL;
+        var _virtualResourceEntry_path;
+        var remoteAssetBaseURL = (_virtualResourceEntry_path = virtualResourceEntry == null ? void 0 : virtualResourceEntry.path) != null ? _virtualResourceEntry_path : item.url;
         // Check cache
         var cacheObject = this._assetUrlPool[remoteAssetBaseURL];
         if (cacheObject) {
@@ -18885,25 +18893,24 @@ var MultiExecutor = /*#__PURE__*/ function() {
         if (!loader) {
             throw "loader not found: " + item.type;
         }
-        var subpackageName = remoteConfig == null ? void 0 : remoteConfig.subpackageName;
+        var subpackageName = virtualResourceEntry == null ? void 0 : virtualResourceEntry.subpackageName;
         // Check sub asset
         if (queryPath) {
             // Check whether load main asset
-            var mainPromise = loadingPromises[remoteAssetBaseURL] || this._loadSubpackageAndMainAsset(loader, item, remoteAssetBaseURL, assetBaseURL, subpackageName);
+            var mainPromise = loadingPromises[remoteAssetBaseURL] || this._loadSubpackageAndMainAsset(loader, item, remoteAssetBaseURL, subpackageName);
             mainPromise.catch(function(e) {
                 _this._onSubAssetFail(remoteAssetBaseURL, queryPath, e);
             });
             return this._createSubAssetPromiseCallback(remoteAssetBaseURL, remoteAssetURL, queryPath);
         }
-        return this._loadSubpackageAndMainAsset(loader, item, remoteAssetBaseURL, assetBaseURL, subpackageName);
+        return this._loadSubpackageAndMainAsset(loader, item, remoteAssetBaseURL, subpackageName);
     };
     // For adapter mini-game platform
-    _proto._loadSubpackageAndMainAsset = function _loadSubpackageAndMainAsset(loader, item, remoteAssetBaseURL, assetBaseURL, subpackageName) {
-        return this._loadMainAsset(loader, item, remoteAssetBaseURL, assetBaseURL);
+    _proto._loadSubpackageAndMainAsset = function _loadSubpackageAndMainAsset(loader, item, remoteAssetBaseURL, subpackageName) {
+        return this._loadMainAsset(loader, item, remoteAssetBaseURL);
     };
-    _proto._loadMainAsset = function _loadMainAsset(loader, item, remoteAssetBaseURL, assetBaseURL) {
+    _proto._loadMainAsset = function _loadMainAsset(loader, item, remoteAssetBaseURL) {
         var _this = this;
-        item.url = assetBaseURL;
         var loadingPromises = this._loadingPromises;
         var promise = loader.load(item, this);
         loadingPromises[remoteAssetBaseURL] = promise;
@@ -19030,10 +19037,9 @@ var MultiExecutor = /*#__PURE__*/ function() {
             return AssetPromise.resolve(null);
         }
         var loadUrl = key ? url + "?q=" + key : url;
+        // type and params omitted: resolved from the virtualPath map, the single source of truth
         var promise = this.load({
-            url: loadUrl,
-            type: mapped.type,
-            params: mapped.params
+            url: loadUrl
         });
         return isClone ? promise.then(function(item) {
             return item.clone();
@@ -20440,6 +20446,13 @@ __decorate([
         this._phasedActiveInScene && this._nativeCollider.addForce(force);
     };
     /**
+   * Apply a force to the DynamicCollider at a given position in world space.
+   * @param force - The force to apply, in world space
+   * @param position - The position where the force is applied, in world space
+   */ _proto.applyForceAtPosition = function applyForceAtPosition(force, position) {
+        this._phasedActiveInScene && this._nativeCollider.addForceAtPosition(force, position);
+    };
+    /**
    * Apply a torque to the DynamicCollider.
    * @param torque - The force make the collider rotate
    */ _proto.applyTorque = function applyTorque(torque) {
@@ -26792,6 +26805,7 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
             depthOnlyPass.release();
             camera.shaderData.setTexture(exports.Camera._cameraDepthTextureProperty, engine._basicResources.whiteTexture2D);
         }
+        var pool = engine._renderTargetPool;
         // Check if need to create internal color texture or grab texture
         if (independentCanvasEnabled) {
             var depthFormat;
@@ -26807,26 +26821,12 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
                 depthFormat = null;
             }
             var viewport = camera.pixelViewport;
-            var internalColorTarget = PipelineUtils.recreateRenderTargetIfNeeded(engine, this._internalColorTarget, viewport.width, viewport.height, camera._getInternalColorTextureFormat(), depthFormat, false, false, !camera.enableHDR, msaaSamples, TextureWrapMode.Clamp, TextureFilterMode.Bilinear);
+            this._internalColorTarget = pool.allocateRenderTarget(viewport.width, viewport.height, camera._getInternalColorTextureFormat(), depthFormat, false, false, !camera.enableHDR, msaaSamples, TextureWrapMode.Clamp, TextureFilterMode.Bilinear);
             if (this._shouldCopyBackgroundColor) {
                 var _camera_renderTarget;
                 var colorTexture = (_camera_renderTarget = camera.renderTarget) == null ? void 0 : _camera_renderTarget.getColorTexture(0);
                 var _colorTexture_format, _colorTexture_isSRGBColorSpace;
-                var copyBackgroundTexture = PipelineUtils.recreateTextureIfNeeded(engine, this._copyBackgroundTexture, viewport.width, viewport.height, (_colorTexture_format = colorTexture == null ? void 0 : colorTexture.format) != null ? _colorTexture_format : TextureFormat.R8G8B8A8, false, (_colorTexture_isSRGBColorSpace = colorTexture == null ? void 0 : colorTexture.isSRGBColorSpace) != null ? _colorTexture_isSRGBColorSpace : false, TextureWrapMode.Clamp, TextureFilterMode.Bilinear);
-                this._copyBackgroundTexture = copyBackgroundTexture;
-            }
-            this._internalColorTarget = internalColorTarget;
-        } else {
-            var internalColorTarget1 = this._internalColorTarget;
-            var copyBackgroundTexture1 = this._copyBackgroundTexture;
-            var pool = engine._renderTargetPool;
-            if (internalColorTarget1) {
-                pool.freeRenderTarget(internalColorTarget1);
-                this._internalColorTarget = null;
-            }
-            if (copyBackgroundTexture1) {
-                pool.freeTexture(copyBackgroundTexture1);
-                this._copyBackgroundTexture = null;
+                this._copyBackgroundTexture = pool.allocateTexture(viewport.width, viewport.height, (_colorTexture_format = colorTexture == null ? void 0 : colorTexture.format) != null ? _colorTexture_format : TextureFormat.R8G8B8A8, false, (_colorTexture_isSRGBColorSpace = colorTexture == null ? void 0 : colorTexture.isSRGBColorSpace) != null ? _colorTexture_isSRGBColorSpace : false, TextureWrapMode.Clamp, TextureFilterMode.Bilinear);
             }
         }
         // Scalable ambient obscurance pass
@@ -26839,6 +26839,15 @@ CascadedShadowCasterPass._tempMatrix0 = new engineMath.Matrix();
             this._saoPass.release();
         }
         this._drawRenderPass(context, camera, finalClearFlags, cubeFace, mipLevel);
+        // Return the per-frame leases so the next camera with matching shape can reuse them
+        if (this._internalColorTarget) {
+            pool.freeRenderTarget(this._internalColorTarget);
+            this._internalColorTarget = null;
+        }
+        if (this._copyBackgroundTexture) {
+            pool.freeTexture(this._copyBackgroundTexture);
+            this._copyBackgroundTexture = null;
+        }
     };
     _proto._drawRenderPass = function _drawRenderPass(context, camera, finalClearFlags, cubeFace, mipLevel) {
         var cullingResults = this._cullingResults;
@@ -27172,7 +27181,9 @@ var OverlayCamera = function OverlayCamera() {
     _inherits(Engine, EventDispatcher);
     function Engine(canvas, hardwareRenderer, configuration) {
         var _this;
-        _this = EventDispatcher.call(this) || this, /** @internal */ _this._renderingStatistics = new RenderingStatistics(), /** @internal */ _this._isDeviceLost = false, /** @internal */ _this._frameInProcess = false, /** @internal */ _this._pendingDestroyObjects = [], /** @internal */ _this._processingPendingDestroys = false, /** @internal */ _this._physicsInitialized = false, /* @internal */ _this._lastRenderState = new RenderState(), /* @internal */ _this._renderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._textRenderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._charRenderInfoPool = new ReturnableObjectPool(CharRenderInfo, 50), /* @internal */ _this._renderContext = new RenderContext(), /* @internal */ _this._renderCount = 0, /* @internal */ _this._shaderProgramMaps = [], /** @internal */ _this._fontMap = {}, /** @internal */ _this._macroCollection = new ShaderMacroCollection(), /** @internal */ _this._postProcessPassNeedRefresh = false, _this._settings = {}, _this._resourceManager = new ResourceManager(_this), _this._sceneManager = new SceneManager(_this), _this._vSyncCount = 1, _this._targetFrameRate = 60, _this._time = new Time(), _this._isPaused = true, _this._vSyncCounter = 1, _this._targetFrameInterval = 1000 / 60, _this._destroyed = false, _this._waitingDestroy = false, _this._waitingGC = false, _this._postProcessPasses = new Array(), _this._activePostProcessPasses = new Array(), _this._animate = function() {
+        _this = EventDispatcher.call(this) || this, /** @internal */ _this._renderingStatistics = new RenderingStatistics(), /** @internal */ _this._isDeviceLost = false, /** @internal */ _this._frameInProcess = false, /** @internal */ _this._pendingDestroyObjects = [], /** @internal */ _this._processingPendingDestroys = false, /** @internal */ _this._physicsInitialized = false, /* @internal */ _this._lastRenderState = new RenderState(), /* @internal */ _this._renderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._textRenderElementPool = new ClearableObjectPool(RenderElement), /* @internal */ _this._charRenderInfoPool = new ReturnableObjectPool(CharRenderInfo, 50), /* @internal */ _this._renderContext = new RenderContext(), /* @internal */ _this._renderCount = 0, /* @internal */ _this._shaderProgramMaps = [], /** @internal */ _this._fontMap = {}, /** @internal */ _this._macroCollection = new ShaderMacroCollection(), /** @internal */ _this._postProcessPassNeedRefresh = false, _this._settings = {}, _this._resourceManager = new ResourceManager(_this), _this._sceneManager = new SceneManager(_this), _this._vSyncCount = 1, _this._targetFrameRate = 60, _this._time = new Time(), _this._isPaused = true, _this._vSyncCounter = 1, _this._targetFrameInterval = 1000 / 60, _this._destroyed = false, _this._waitingDestroy = false, _this._waitingGC = false, _this._postProcessPasses = new Array(), _this._activePostProcessPasses = new Array(), _this._onCanvasResize = function() {
+            return _this._renderTargetPool.gc();
+        }, _this._animate = function() {
             if (_this._vSyncCount) {
                 var _this_xrManager;
                 var raf = ((_this_xrManager = _this.xrManager) == null ? void 0 : _this_xrManager._getRequestAnimationFrame()) || requestAnimationFrame;
@@ -27193,6 +27204,7 @@ var OverlayCamera = function OverlayCamera() {
         _this._textDefaultFont.isGCIgnored = true;
         _this._batcherManager = new BatcherManager(_this);
         _this._renderTargetPool = new RenderTargetPool(_this);
+        canvas._sizeUpdateFlagManager.addListener(_this._onCanvasResize);
         _this.inputManager = new InputManager(_this, configuration.input);
         var xrDevice = configuration.xrDevice;
         if (xrDevice) {
@@ -27396,6 +27408,7 @@ var OverlayCamera = function OverlayCamera() {
         var _this_xrManager;
         this._destroyed = true;
         this._waitingDestroy = false;
+        this._canvas._sizeUpdateFlagManager.removeListener(this._onCanvasResize);
         this._sceneManager._destroyAllScene();
         this._resourceManager._destroy();
         this.inputManager._destroy();
@@ -29730,7 +29743,7 @@ var PointerMethods = /*#__PURE__*/ function(PointerMethods) {
                 for(var _len = arguments.length, signalArgs = new Array(_len), _key = 0; _key < _len; _key++){
                     signalArgs[_key] = arguments[_key];
                 }
-                return (_target = target)[methodName].apply(_target, [].concat(args, signalArgs));
+                return (_target = target)[methodName].apply(_target, [].concat(signalArgs, args));
             } : function() {
                 for(var _len = arguments.length, signalArgs = new Array(_len), _key = 0; _key < _len; _key++){
                     signalArgs[_key] = arguments[_key];
@@ -30164,7 +30177,7 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
  */ var AnimationClipCurveBinding = /*#__PURE__*/ function() {
     function AnimationClipCurveBinding() {
         /** The index of the component that is animated. */ this.typeIndex = 0;
-        this._tempCurveOwner = {};
+        this._tempCurveOwner = new WeakMap();
     }
     var _proto = AnimationClipCurveBinding.prototype;
     /**
@@ -30190,11 +30203,12 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
     /**
    * @internal
    */ _proto._getTempCurveOwner = function _getTempCurveOwner(entity, component) {
-        var instanceId = entity.instanceId;
-        if (!this._tempCurveOwner[instanceId]) {
-            this._tempCurveOwner[instanceId] = this._createCurveOwner(entity, component);
+        var owner = this._tempCurveOwner.get(entity);
+        if (!owner) {
+            owner = this._createCurveOwner(entity, component);
+            this._tempCurveOwner.set(entity, owner);
         }
-        return this._tempCurveOwner[instanceId];
+        return owner;
     };
     return AnimationClipCurveBinding;
 }();
@@ -30276,11 +30290,10 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
         this._length = 0;
     };
     /**
-   * @internal
    * Samples an animation at a given time.
    * @param entity - The animated entity
    * @param time - The time to sample an animation
-   */ _proto._sampleAnimation = function _sampleAnimation(entity, time) {
+   */ _proto.sampleAnimation = function sampleAnimation(entity, time) {
         var _this = this, curveBindings = _this._curveBindings;
         var components = AnimationCurveOwner._components;
         for(var i = curveBindings.length - 1; i >= 0; i--){
@@ -31455,12 +31468,6 @@ var AnimatorLayerBlendingMode = /*#__PURE__*/ function(AnimatorLayerBlendingMode
     return LayerState;
 }({});
 
-/**
- * @internal
- */ var AnimationEventHandler = function AnimationEventHandler() {
-    this.handlers = [];
-};
-
 /**
  * Animation wrap mode.
  */ var WrapMode = /*#__PURE__*/ function(WrapMode) {
@@ -31469,6 +31476,12 @@ var AnimatorLayerBlendingMode = /*#__PURE__*/ function(AnimatorLayerBlendingMode
     return WrapMode;
 }({});
 
+/**
+ * @internal
+ */ var AnimationEventHandler = function AnimationEventHandler() {
+    this.handlers = [];
+};
+
 /**
  * @internal
  */ var AnimatorStatePlayData = /*#__PURE__*/ function() {
@@ -31509,19 +31522,21 @@ var AnimatorLayerBlendingMode = /*#__PURE__*/ function(AnimatorLayerBlendingMode
         this.playedTime += deltaTime;
         var instance = this.instance;
         var state = instance._state;
+        var clipLength = state.clip.length;
+        var clipStartTime = state.clipStartTime;
         var time = this.playedTime + this.offsetFrameTime;
-        var duration = state._getDuration();
+        var duration = (state.clipEndTime - clipStartTime) * clipLength;
         this.playState = AnimatorStatePlayState.Playing;
         if (instance.wrapMode === WrapMode.Loop) {
             time = duration ? time % duration : 0;
-        } else {
-            if (Math.abs(time) >= duration) {
-                time = time < 0 ? -duration : duration;
-                this.playState = AnimatorStatePlayState.Finished;
-            }
+        } else if (time >= duration || time <= -duration) {
+            time = time < 0 ? -duration : duration;
+            this.playState = AnimatorStatePlayState.Finished;
+        }
+        if (time < 0) {
+            time += duration;
         }
-        time < 0 && (time += duration);
-        this.clipTime = time + state.clipStartTime * state.clip.length;
+        this.clipTime = time + clipStartTime * clipLength;
         if (this._changedOrientation) {
             !this.isForward && this._correctTime();
             this._changedOrientation = false;
@@ -31534,6 +31549,26 @@ var AnimatorLayerBlendingMode = /*#__PURE__*/ function(AnimatorLayerBlendingMode
             this.clipTime = state.clipEndTime * state.clip.length;
         }
     };
+    _create_class(AnimatorStatePlayData, [
+        {
+            key: "state",
+            get: function get() {
+                return this.instance._state;
+            }
+        },
+        {
+            key: "speed",
+            get: function get() {
+                return this.instance.speed;
+            }
+        },
+        {
+            key: "wrapMode",
+            get: function get() {
+                return this.instance.wrapMode;
+            }
+        }
+    ]);
     return AnimatorStatePlayData;
 }();
 
@@ -31712,8 +31747,8 @@ function _type_of(obj) {
  * @internal
  */ var AnimatorLayerData = /*#__PURE__*/ function() {
     function AnimatorLayerData() {
-        this.curveOwnerPool = Object.create(null);
-        this.animatorStateDataMap = new WeakMap();
+        this.curveOwnerPool = new WeakMap();
+        this.animatorStateDataMap = new Map();
         this.instanceMap = new WeakMap();
         this.srcPlayData = null;
         this.destPlayData = null;
@@ -31732,15 +31767,6 @@ function _type_of(obj) {
         }
         return instance;
     };
-    _proto.completeCrossFade = function completeCrossFade() {
-        this.srcPlayData = this.destPlayData;
-        this.destPlayData = null;
-        this.crossFadeTransition = null;
-    };
-    _proto.clearCrossFadeSlot = function clearCrossFadeSlot() {
-        this.destPlayData = null;
-        this.crossFadeTransition = null;
-    };
     _proto.resetCurrentCheckIndex = function resetCurrentCheckIndex() {
         this.layer.stateMachine._entryTransitionCollection.needResetCurrentCheckIndex = true;
         this.layer.stateMachine._anyStateTransitionCollection.needResetCurrentCheckIndex = true;
@@ -31764,7 +31790,7 @@ function _type_of(obj) {
     _inherits(Animator, Component);
     function Animator(entity) {
         var _this;
-        _this = Component.call(this, entity) || this, /** Culling mode of this Animator. */ _this.cullingMode = AnimatorCullingMode.None, /** The playback speed of the Animator, 1.0 is normal playback speed. */ _this.speed = 1.0, /** @internal */ _this._playFrameCount = -1, /** @internal */ _this._onUpdateIndex = -1, _this._updateMark = 0, _this._animatorLayersData = new Array(), _this._curveOwnerPool = Object.create(null), _this._parametersValueMap = Object.create(null), _this._tempAnimatorStateInfo = {
+        _this = Component.call(this, entity) || this, /** Culling mode of this Animator. */ _this.cullingMode = AnimatorCullingMode.None, /** The playback speed of the Animator, 1.0 is normal playback speed. */ _this.speed = 1.0, /** Whether the Animator sends AnimationEvent callbacks. */ _this.fireEvents = true, /** @internal */ _this._playFrameCount = -1, /** @internal */ _this._onUpdateIndex = -1, _this._updateMark = 0, _this._animatorLayersData = new Array(), _this._curveOwnerPool = new WeakMap(), _this._parametersValueMap = Object.create(null), _this._tempAnimatorStateInfo = {
             layerIndex: -1,
             state: null
         }, _this._controlledRenderers = new Array();
@@ -31947,16 +31973,21 @@ function _type_of(obj) {
     /**
    * @internal
    */ _proto._reset = function _reset() {
-        var _this = this, animationCurveOwners = _this._curveOwnerPool;
-        for(var instanceId in animationCurveOwners){
-            var propertyOwners = animationCurveOwners[instanceId];
-            for(var property in propertyOwners){
-                var owner = propertyOwners[property];
-                owner.revertDefaultValue();
+        var layersData = this._animatorLayersData;
+        for(var i = 0, n = layersData.length; i < n; i++){
+            var layerData = layersData[i];
+            if (!layerData) continue;
+            for(var _iterator = _create_for_of_iterator_helper_loose(layerData.animatorStateDataMap.values()), _step; !(_step = _iterator()).done;){
+                var stateData = _step.value;
+                var layerOwners = stateData.curveLayerOwner;
+                for(var k = 0, l = layerOwners.length; k < l; k++){
+                    var _layerOwners_k_curveOwner, _layerOwners_k;
+                    (_layerOwners_k = layerOwners[k]) == null ? void 0 : (_layerOwners_k_curveOwner = _layerOwners_k.curveOwner) == null ? void 0 : _layerOwners_k_curveOwner.revertDefaultValue();
+                }
             }
         }
         this._animatorLayersData.length = 0;
-        this._curveOwnerPool = Object.create(null);
+        this._curveOwnerPool = new WeakMap();
         this._parametersValueMap = Object.create(null);
         if (this._controllerUpdateFlag) {
             this._controllerUpdateFlag.flag = false;
@@ -31979,6 +32010,7 @@ function _type_of(obj) {
     };
     _proto._onDestroy = function _onDestroy() {
         Component.prototype._onDestroy.call(this);
+        this._reset();
         var controller = this._animatorController;
         if (controller) {
             var _this__controllerUpdateFlag;
@@ -31992,7 +32024,8 @@ function _type_of(obj) {
         if (!state) {
             return;
         }
-        var manuallyTransition = this._getAnimatorLayerData(playLayerIndex).manuallyTransition;
+        var animatorLayerData = this._getAnimatorLayerData(playLayerIndex);
+        var manuallyTransition = animatorLayerData.manuallyTransition;
         manuallyTransition.duration = duration;
         manuallyTransition.offset = normalizedTimeOffset;
         manuallyTransition.isFixedDuration = isFixedDuration;
@@ -32047,20 +32080,30 @@ function _type_of(obj) {
             var relativePath = curve.relativePath;
             var targetEntity = curve.relativePath === "" ? entity : entity.findByPath(curve.relativePath);
             if (targetEntity) {
-                var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _property1;
+                var _layerPropertyOwners, _property;
                 var component = curve.typeIndex > 0 ? targetEntity.getComponents(curve.type, components)[curve.typeIndex] : targetEntity.getComponent(curve.type);
                 components.length = 0;
                 if (!component) {
                     continue;
                 }
                 var property = curve.property;
-                var instanceId = component.instanceId;
-                // Get owner
-                var propertyOwners = (_curveOwnerPool = curveOwnerPool)[_instanceId = instanceId] || (_curveOwnerPool[_instanceId] = Object.create(null));
-                var owner = (_propertyOwners = propertyOwners)[_property = property] || (_propertyOwners[_property] = curve._createCurveOwner(targetEntity, component));
-                // Get layer owner
-                var layerPropertyOwners = (_layerCurveOwnerPool = layerCurveOwnerPool)[_instanceId1 = instanceId] || (_layerCurveOwnerPool[_instanceId1] = Object.create(null));
-                var layerOwner = (_layerPropertyOwners = layerPropertyOwners)[_property1 = property] || (_layerPropertyOwners[_property1] = curve._createCurveLayerOwner(owner));
+                // Key owner lookup by Component identity instead of instanceId.
+                var propertyOwners = curveOwnerPool.get(component);
+                if (!propertyOwners) {
+                    propertyOwners = Object.create(null);
+                    curveOwnerPool.set(component, propertyOwners);
+                }
+                var owner = propertyOwners[property];
+                if (!owner) {
+                    owner = curve._createCurveOwner(targetEntity, component);
+                    propertyOwners[property] = owner;
+                }
+                var layerPropertyOwners = layerCurveOwnerPool.get(component);
+                if (!layerPropertyOwners) {
+                    layerPropertyOwners = Object.create(null);
+                    layerCurveOwnerPool.set(component, layerPropertyOwners);
+                }
+                var layerOwner = (_layerPropertyOwners = layerPropertyOwners)[_property = property] || (_layerPropertyOwners[_property] = curve._createCurveLayerOwner(owner));
                 if (mask && mask.pathMasks.length) {
                     var _mask_getPathMask;
                     var _mask_getPathMask_active;
@@ -32074,8 +32117,6 @@ function _type_of(obj) {
         }
     };
     _proto._ensureEventHandlers = function _ensureEventHandlers(state, animatorStateData) {
-        // state._updateFlagManager dispatches on both clip-swap and clip-events-mutation,
-        // so its version covers every input that affects eventHandlers binding
         var stateVersion = state._updateFlagManager.version;
         var scriptsVersion = this._entity._scriptsVersion;
         if (animatorStateData.eventsBuiltVersion === stateVersion && animatorStateData.eventsBuiltScriptsVersion === scriptsVersion) {
@@ -32199,8 +32240,8 @@ function _type_of(obj) {
     };
     _proto._updatePlayingState = function _updatePlayingState(layerData, weight, additive, deltaTime, aniUpdate) {
         var srcPlayData = layerData.srcPlayData;
-        var state = srcPlayData.instance._state;
-        var playSpeed = srcPlayData.instance.speed * this.speed;
+        var state = srcPlayData.state;
+        var playSpeed = srcPlayData.speed * this.speed;
         var playDeltaTime = playSpeed * deltaTime;
         srcPlayData.updateOrientation(playDeltaTime);
         var lastClipTime = srcPlayData.clipTime, lastPlayState = srcPlayData.playState;
@@ -32244,14 +32285,13 @@ function _type_of(obj) {
         this._evaluatePlayingState(srcPlayData, weight, additive, aniUpdate);
         this._fireAnimationEventsAndCallScripts(layerData.layerIndex, srcPlayData, state, lastClipTime, lastPlayState, playCostTime);
         if (transition) {
-            // Remove speed factor, use actual cost time. Per-instance speed=0 means the source
-            // state is paused, so it consumes no time — pass deltaTime through to the destination.
+            // Remove speed factor, use actual cost time
             var remainDeltaTime = playSpeed === 0 ? deltaTime : deltaTime - playCostTime / playSpeed;
             remainDeltaTime > 0 && this._updateState(layerData, remainDeltaTime, aniUpdate);
         }
     };
     _proto._evaluatePlayingState = function _evaluatePlayingState(playData, weight, additive, aniUpdate) {
-        var curveBindings = playData.instance.clip._curveBindings;
+        var curveBindings = playData.state.clip._curveBindings;
         var finished = playData.playState === AnimatorStatePlayState.Finished;
         if (aniUpdate || finished) {
             var curveLayerOwner = playData.stateData.curveLayerOwner;
@@ -32274,14 +32314,14 @@ function _type_of(obj) {
     _proto._updateCrossFadeState = function _updateCrossFadeState(layerData, weight, additive, deltaTime, aniUpdate) {
         var srcPlayData = layerData.srcPlayData, destPlayData = layerData.destPlayData, layerIndex = layerData.layerIndex;
         var speed = this.speed;
-        var srcState = srcPlayData.instance._state;
-        var destState = destPlayData.instance._state;
+        var srcState = srcPlayData.state;
+        var destState = destPlayData.state;
         var transitionDuration = layerData.crossFadeTransition._getFixedDuration();
         if (this._tryCrossFadeInterrupt(layerData, transitionDuration, destState, deltaTime, aniUpdate)) {
             return;
         }
-        var srcPlaySpeed = srcPlayData.instance.speed * speed;
-        var dstPlaySpeed = destPlayData.instance.speed * speed;
+        var srcPlaySpeed = srcPlayData.speed * speed;
+        var dstPlaySpeed = destPlayData.speed * speed;
         var dstPlayDeltaTime = dstPlaySpeed * deltaTime;
         srcPlayData.updateOrientation(srcPlaySpeed * deltaTime);
         destPlayData.updateOrientation(dstPlayDeltaTime);
@@ -32324,8 +32364,8 @@ function _type_of(obj) {
     };
     _proto._evaluateCrossFadeState = function _evaluateCrossFadeState(layerData, srcPlayData, destPlayData, weight, crossWeight, additive, aniUpdate) {
         var crossLayerOwnerCollection = layerData.crossLayerOwnerCollection;
-        var _srcPlayData_instance_clip = srcPlayData.instance.clip, srcCurves = _srcPlayData_instance_clip._curveBindings;
-        var destState = destPlayData.instance._state;
+        var _srcPlayData_state_clip = srcPlayData.state.clip, srcCurves = _srcPlayData_state_clip._curveBindings;
+        var destState = destPlayData.state;
         var _destState_clip = destState.clip, destCurves = _destState_clip._curveBindings;
         var finished = destPlayData.playState === AnimatorStatePlayState.Finished;
         if (aniUpdate || finished) {
@@ -32344,12 +32384,12 @@ function _type_of(obj) {
     };
     _proto._updateCrossFadeFromPoseState = function _updateCrossFadeFromPoseState(layerData, weight, additive, deltaTime, aniUpdate) {
         var destPlayData = layerData.destPlayData;
-        var state = destPlayData.instance._state;
+        var state = destPlayData.state;
         var transitionDuration = layerData.crossFadeTransition._getFixedDuration();
         if (this._tryCrossFadeInterrupt(layerData, transitionDuration, state, deltaTime, aniUpdate)) {
             return;
         }
-        var playSpeed = destPlayData.instance.speed * this.speed;
+        var playSpeed = destPlayData.speed * this.speed;
         var playDeltaTime = playSpeed * deltaTime;
         destPlayData.updateOrientation(playDeltaTime);
         var lastDestClipTime = destPlayData.clipTime, lastPlayState = destPlayData.playState;
@@ -32386,7 +32426,7 @@ function _type_of(obj) {
     };
     _proto._evaluateCrossFadeFromPoseState = function _evaluateCrossFadeFromPoseState(layerData, destPlayData, weight, crossWeight, additive, aniUpdate) {
         var crossLayerOwnerCollection = layerData.crossLayerOwnerCollection;
-        var state = destPlayData.instance._state;
+        var state = destPlayData.state;
         var _state_clip = state.clip, curveBindings = _state_clip._curveBindings;
         var destClipTime = destPlayData.clipTime, playState = destPlayData.playState;
         var finished = playState === AnimatorStatePlayState.Finished;
@@ -32398,7 +32438,7 @@ function _type_of(obj) {
                 if (!owner) continue;
                 var curveIndex = layerOwner.crossDestCurveIndex;
                 this._checkRevertOwner(owner, additive);
-                var value = layerOwner.curveOwner.crossFadeFromPoseAndApplyValue(curveIndex >= 0 ? curveBindings[curveIndex].curve : null, destClipTime, crossWeight, additive);
+                var value = owner.crossFadeFromPoseAndApplyValue(curveIndex >= 0 ? curveBindings[curveIndex].curve : null, destClipTime, crossWeight, additive);
                 aniUpdate && owner.applyValue(value, weight, additive);
                 finished && layerOwner.saveFinalValue();
             }
@@ -32406,8 +32446,8 @@ function _type_of(obj) {
     };
     _proto._updateFinishedState = function _updateFinishedState(layerData, weight, additive, deltaTime, aniUpdate) {
         var playData = layerData.srcPlayData;
-        var state = playData.instance._state;
-        var actualSpeed = playData.instance.speed * this.speed;
+        var state = playData.state;
+        var actualSpeed = playData.speed * this.speed;
         var actualDeltaTime = actualSpeed * deltaTime;
         playData.updateOrientation(actualDeltaTime);
         var clipTime = playData.clipTime, isForward = playData.isForward;
@@ -32425,7 +32465,7 @@ function _type_of(obj) {
             return;
         }
         var curveLayerOwner = playData.stateData.curveLayerOwner;
-        var _playData_instance_clip = playData.instance.clip, curveBindings = _playData_instance_clip._curveBindings;
+        var _playData_state_clip = playData.state.clip, curveBindings = _playData_state_clip._curveBindings;
         for(var i = curveBindings.length - 1; i >= 0; i--){
             var layerOwner = curveLayerOwner[i];
             var owner = layerOwner == null ? void 0 : layerOwner.curveOwner;
@@ -32441,12 +32481,14 @@ function _type_of(obj) {
         } else {
             layerData.layerState = LayerState.Playing;
         }
-        layerData.completeCrossFade();
+        layerData.srcPlayData = destPlayData;
+        layerData.destPlayData = null;
+        layerData.crossFadeTransition = null;
     };
     _proto._preparePlayOwner = function _preparePlayOwner(layerData, playState) {
         if (layerData.layerState === LayerState.Playing) {
             var srcPlayData = layerData.srcPlayData;
-            if (srcPlayData.instance._state !== playState) {
+            if (srcPlayData.state !== playState) {
                 var curveLayerOwner = srcPlayData.stateData.curveLayerOwner;
                 for(var i = curveLayerOwner.length - 1; i >= 0; i--){
                     var _curveLayerOwner_i;
@@ -32461,17 +32503,17 @@ function _type_of(obj) {
         }
     };
     _proto._applyStateTransitions = function _applyStateTransitions(layerData, isForward, playData, transitionCollection, lastClipTime, clipTime, deltaTime, aniUpdate) {
-        var state = playData.instance._state;
-        var clipDuration = state.clip.length;
+        var state = playData.state;
         var targetTransition = null;
-        var startTime = state.clipStartTime * clipDuration;
-        var endTime = state.clipEndTime * clipDuration;
         if (transitionCollection.noExitTimeCount) {
             targetTransition = this._checkNoExitTimeTransitions(layerData, transitionCollection, aniUpdate);
             if (targetTransition) {
                 return targetTransition;
             }
         }
+        var clipDuration = state.clip.length;
+        var startTime = state.clipStartTime * clipDuration;
+        var endTime = state.clipEndTime * clipDuration;
         if (isForward) {
             if (lastClipTime + deltaTime >= endTime) {
                 targetTransition = this._checkSubTransition(layerData, state, transitionCollection, lastClipTime, endTime, aniUpdate);
@@ -32578,9 +32620,8 @@ function _type_of(obj) {
         var playData = animatorLayerData.getOrCreateInstance(state)._playData;
         playData.reset(animatorStateData, state._getClipActualEndTime() * normalizedTimeOffset);
         animatorLayerData.srcPlayData = playData;
-        // Drop any dangling cross-fade slot from a previously-interrupted crossFade
-        // so a later crossFade(B) isn't wrongly no-op'd by the active-dest guard.
-        animatorLayerData.clearCrossFadeSlot();
+        animatorLayerData.destPlayData = null;
+        animatorLayerData.crossFadeTransition = null;
         animatorLayerData.resetCurrentCheckIndex();
         return true;
     };
@@ -32664,9 +32705,7 @@ function _type_of(obj) {
             return false;
         }
         var animatorLayerData = this._getAnimatorLayerData(layerIndex);
-        // Self/active-dest cross-fade is a no-op: each state has one persistent
-        // instance per layer, so a second concurrent fade has nowhere to live.
-        if (((_animatorLayerData_srcPlayData = animatorLayerData.srcPlayData) == null ? void 0 : _animatorLayerData_srcPlayData.instance._state) === crossState || ((_animatorLayerData_destPlayData = animatorLayerData.destPlayData) == null ? void 0 : _animatorLayerData_destPlayData.instance._state) === crossState) {
+        if (((_animatorLayerData_srcPlayData = animatorLayerData.srcPlayData) == null ? void 0 : _animatorLayerData_srcPlayData.state) === crossState || ((_animatorLayerData_destPlayData = animatorLayerData.destPlayData) == null ? void 0 : _animatorLayerData_destPlayData.state) === crossState) {
             return false;
         }
         var animatorStateData = this._getAnimatorStateData(crossState, animatorLayerData, layerIndex);
@@ -32698,23 +32737,27 @@ function _type_of(obj) {
         return true;
     };
     _proto._fireAnimationEvents = function _fireAnimationEvents(playData, eventHandlers, lastClipTime, deltaTime) {
-        var isForward = playData.isForward, clipTime = playData.clipTime;
-        var state = playData.instance._state;
+        var state = playData.state, isForward = playData.isForward, clipTime = playData.clipTime, wrapMode = playData.wrapMode;
         var startTime = state._getClipActualStartTime();
         var endTime = state._getClipActualEndTime();
+        var canWrap = wrapMode === WrapMode.Loop;
         if (isForward) {
             if (lastClipTime + deltaTime >= endTime) {
                 this._fireSubAnimationEvents(playData, eventHandlers, lastClipTime, endTime);
-                playData.currentEventIndex = 0;
-                this._fireSubAnimationEvents(playData, eventHandlers, startTime, clipTime);
+                if (canWrap) {
+                    playData.currentEventIndex = 0;
+                    this._fireSubAnimationEvents(playData, eventHandlers, startTime, clipTime);
+                }
             } else {
                 this._fireSubAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
             }
         } else {
             if (lastClipTime + deltaTime <= startTime) {
                 this._fireBackwardSubAnimationEvents(playData, eventHandlers, lastClipTime, startTime);
-                playData.currentEventIndex = eventHandlers.length - 1;
-                this._fireBackwardSubAnimationEvents(playData, eventHandlers, endTime, clipTime);
+                if (canWrap) {
+                    playData.currentEventIndex = eventHandlers.length - 1;
+                    this._fireBackwardSubAnimationEvents(playData, eventHandlers, endTime, clipTime);
+                }
             } else {
                 this._fireBackwardSubAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
             }
@@ -32730,8 +32773,10 @@ function _type_of(obj) {
             }
             var handlers = eventHandler.handlers;
             if (time >= lastClipTime) {
-                for(var j = handlers.length - 1; j >= 0; j--){
-                    handlers[j](parameter);
+                if (this.fireEvents) {
+                    for(var j = handlers.length - 1; j >= 0; j--){
+                        handlers[j](parameter);
+                    }
                 }
                 playState.currentEventIndex = Math.min(eventIndex + 1, n - 1);
             }
@@ -32747,8 +32792,10 @@ function _type_of(obj) {
             }
             if (time <= lastClipTime) {
                 var handlers = eventHandler.handlers;
-                for(var j = handlers.length - 1; j >= 0; j--){
-                    handlers[j](parameter);
+                if (this.fireEvents) {
+                    for(var j = handlers.length - 1; j >= 0; j--){
+                        handlers[j](parameter);
+                    }
                 }
                 playState.currentEventIndex = Math.max(eventIndex - 1, 0);
             }
@@ -32779,9 +32826,6 @@ function _type_of(obj) {
         owner.updateMark = this._updateMark;
     };
     _proto._fireAnimationEventsAndCallScripts = function _fireAnimationEventsAndCallScripts(layerIndex, playData, state, lastClipTime, lastPlayState, deltaTime) {
-        // Re-check whether the clip events/scripts changed since the last build —
-        // play()/crossFade() entry points already ensure on enter, but addEvent()
-        // or addComponent(Script) after play() must also flow through.
         this._ensureEventHandlers(state, playData.stateData);
         var eventHandlers = playData.stateData.eventHandlers;
         eventHandlers.length && this._fireAnimationEvents(playData, eventHandlers, lastClipTime, deltaTime);
@@ -32849,6 +32893,9 @@ Animator._tempScripts = [];
 __decorate([
     assignmentClone
 ], Animator.prototype, "speed", void 0);
+__decorate([
+    assignmentClone
+], Animator.prototype, "fireEvents", void 0);
 __decorate([
     assignmentClone
 ], Animator.prototype, "_animatorController", void 0);
@@ -32920,7 +32967,10 @@ function _assert_this_initialized(self) {
             /** @internal */ _this._parametersMap = {},
             /** @internal */ _this._layers = [],
             /** @internal */ _this._layersMap = {},
-            _this._updateFlagManager = new UpdateFlagManager()
+            _this._updateFlagManager = new UpdateFlagManager(),
+            _this._onStatesInvalidate = function() {
+                return _this._updateFlagManager.dispatch();
+            }
         ][0];
         return _assert_this_initialized(_this);
     }
@@ -32975,6 +33025,7 @@ function _assert_this_initialized(self) {
    */ _proto.addLayer = function addLayer(layer) {
         this._layers.push(layer);
         this._layersMap[layer.name] = layer;
+        layer._setStatesInvalidateCallback(this._onStatesInvalidate);
         layer._setEngine(this._engine);
         this._updateFlagManager.dispatch();
     };
@@ -32984,13 +33035,18 @@ function _assert_this_initialized(self) {
    */ _proto.removeLayer = function removeLayer(layerIndex) {
         var theLayer = this.layers[layerIndex];
         this._layers.splice(layerIndex, 1);
+        theLayer._setStatesInvalidateCallback(null);
         delete this._layersMap[theLayer.name];
         this._updateFlagManager.dispatch();
     };
     /**
    * Clear layers.
    */ _proto.clearLayers = function clearLayers() {
-        this._layers.length = 0;
+        var _this = this, layers = _this._layers;
+        for(var i = 0, n = layers.length; i < n; i++){
+            layers[i]._setStatesInvalidateCallback(null);
+        }
+        layers.length = 0;
         for(var name in this._layersMap){
             delete this._layersMap[name];
         }
@@ -33006,7 +33062,9 @@ function _assert_this_initialized(self) {
    */ _proto._setEngine = function _setEngine(engine) {
         var _this = this, layers = _this._layers;
         for(var i = 0, n = layers.length; i < n; i++){
-            layers[i]._setEngine(engine);
+            var layer = layers[i];
+            layer._setStatesInvalidateCallback(this._onStatesInvalidate);
+            layer._setEngine(engine);
         }
     };
     _proto._addParameter = function _addParameter(name, defaultValue, isTrigger) {
@@ -33393,6 +33451,7 @@ function _assert_this_initialized(self) {
  */ var AnimatorStateMachine = /*#__PURE__*/ function() {
     function AnimatorStateMachine() {
         /** The list of states. */ this.states = [];
+        this._onStatesInvalidate = null;
         /**
    * The state will be played automatically.
    * @remarks When the Animator's AnimatorController changed or the Animator's onEnable be triggered. Cleared to `null` if the state is removed via `removeState`.
@@ -33429,6 +33488,7 @@ function _assert_this_initialized(self) {
             if (this.defaultState === state) {
                 this.defaultState = null;
             }
+            this._onStatesInvalidate == null ? void 0 : this._onStatesInvalidate.call(this);
         }
     };
     /**
@@ -33488,6 +33548,11 @@ function _assert_this_initialized(self) {
             states[i]._setEngine(engine);
         }
     };
+    /**
+   * @internal
+   */ _proto._setStatesInvalidateCallback = function _setStatesInvalidateCallback(onStatesInvalidate) {
+        this._onStatesInvalidate = onStatesInvalidate;
+    };
     _create_class(AnimatorStateMachine, [
         {
             key: "entryTransitions",
@@ -33516,14 +33581,43 @@ function _assert_this_initialized(self) {
         this.name = name;
         this./** The blending weight that the layers has. It is not taken into account for the first layer. */ weight = 1.0;
         this./** The blending mode used by the layer. It is not taken into account for the first layer. */ blendingMode = AnimatorLayerBlendingMode.Override;
-        this.stateMachine = new AnimatorStateMachine();
+        this._onStatesInvalidate = null;
+        this._stateMachine = new AnimatorStateMachine();
     }
     var _proto = AnimatorControllerLayer.prototype;
     /**
    * @internal
    */ _proto._setEngine = function _setEngine(engine) {
-        this.stateMachine._setEngine(engine);
+        this._engine = engine;
+        this._stateMachine._setEngine(engine);
     };
+    /**
+   * @internal
+   */ _proto._setStatesInvalidateCallback = function _setStatesInvalidateCallback(onStatesInvalidate) {
+        this._onStatesInvalidate = onStatesInvalidate;
+        this._stateMachine._setStatesInvalidateCallback(onStatesInvalidate);
+    };
+    _create_class(AnimatorControllerLayer, [
+        {
+            key: "stateMachine",
+            get: /**
+   * The state machine for the layer.
+   */ function get() {
+                return this._stateMachine;
+            },
+            set: function set(value) {
+                var lastStateMachine = this._stateMachine;
+                if (lastStateMachine === value) {
+                    return;
+                }
+                lastStateMachine._setStatesInvalidateCallback(null);
+                this._stateMachine = value;
+                value._setStatesInvalidateCallback(this._onStatesInvalidate);
+                this._engine && value._setEngine(this._engine);
+                this._onStatesInvalidate == null ? void 0 : this._onStatesInvalidate.call(this);
+            }
+        }
+    ]);
     return AnimatorControllerLayer;
 }();
 
@@ -33892,8 +33986,10 @@ var ParticleStopMode = /*#__PURE__*/ function(ParticleStopMode) {
     /**
    * @internal
    */ _proto._onEnable = function _onEnable() {
-        if (this.generator.main.playOnEnabled) {
-            this.generator.play(false);
+        var generator = this.generator;
+        generator._setTransformFeedback();
+        if (generator.main.playOnEnabled) {
+            generator.play(false);
         }
     };
     /**
@@ -34488,6 +34584,14 @@ ParticleTransformFeedbackSimulator._deltaTimeProperty = ShaderProperty.getByName
     return ParticleGradientMode;
 }({});
 
+/**
+ * Particle sub emitter trigger type.
+ */ var ParticleSubEmitterType = /*#__PURE__*/ function(ParticleSubEmitterType) {
+    /** Triggered when a parent particle is born. */ ParticleSubEmitterType[ParticleSubEmitterType["Birth"] = 0] = "Birth";
+    /** Triggered when a parent particle dies (lifetime expired). */ ParticleSubEmitterType[ParticleSubEmitterType["Death"] = 1] = "Death";
+    return ParticleSubEmitterType;
+}({});
+
 /**
  * @internal
  */ var ParticleRandomSubSeeds = /*#__PURE__*/ function(ParticleRandomSubSeeds) {
@@ -34509,6 +34613,7 @@ ParticleTransformFeedbackSimulator._deltaTimeProperty = ShaderProperty.getByName
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["ForceOverLifetime"] = 3875246972] = "ForceOverLifetime";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["LimitVelocityOverLifetime"] = 3047300990] = "LimitVelocityOverLifetime";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["Noise"] = 4105357473] = "Noise";
+    ParticleRandomSubSeeds[ParticleRandomSubSeeds["SubEmitter"] = 2622110509] = "SubEmitter";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["EmissionRate"] = 2625893077] = "EmissionRate";
     return ParticleRandomSubSeeds;
 }({});
@@ -34578,6 +34683,12 @@ ParticleTransformFeedbackSimulator._deltaTimeProperty = ShaderProperty.getByName
    * @param colorKeys - The color keys
    * @param alphaKeys - The alpha keys
    */ _proto.setKeys = function setKeys(colorKeys, alphaKeys) {
+        if (colorKeys.length > 4) {
+            throw new Error("Gradient can only have 4 color keys");
+        }
+        if (alphaKeys.length > 4) {
+            throw new Error("Gradient can only have 4 alpha keys");
+        }
         var currentColorKeys = this._colorKeys;
         var currentAlphaKeys = this._alphaKeys;
         for(var i = 0, n = currentColorKeys.length; i < n; i++){
@@ -34632,6 +34743,60 @@ ParticleTransformFeedbackSimulator._deltaTimeProperty = ShaderProperty.getByName
         }
         return typeArray;
     };
+    /**
+   * @internal
+   */ _proto._evaluate = function _evaluate(time, out) {
+        var alphaKeys = this._alphaKeys;
+        var alphaCount = alphaKeys.length;
+        if (alphaCount === 0) {
+            out.a = 0;
+        } else {
+            var alphaMaxTime = alphaKeys[alphaCount - 1].time;
+            var alphaT = Math.min(time, alphaMaxTime);
+            for(var i = 0; i < alphaCount; i++){
+                var key = alphaKeys[i];
+                if (alphaT <= key.time) {
+                    if (i === 0) {
+                        out.a = key.alpha;
+                    } else {
+                        var lastKey = alphaKeys[i - 1];
+                        var age = (alphaT - lastKey.time) / (key.time - lastKey.time);
+                        out.a = lastKey.alpha + (key.alpha - lastKey.alpha) * age;
+                    }
+                    break;
+                }
+            }
+        }
+        var colorKeys = this._colorKeys;
+        var colorCount = colorKeys.length;
+        if (colorCount === 0) {
+            out.r = 0;
+            out.g = 0;
+            out.b = 0;
+        } else {
+            var colorMaxTime = colorKeys[colorCount - 1].time;
+            var colorT = Math.min(time, colorMaxTime);
+            for(var i1 = 0; i1 < colorCount; i1++){
+                var key1 = colorKeys[i1];
+                if (colorT <= key1.time) {
+                    var c = key1.color;
+                    if (i1 === 0) {
+                        out.r = c.r;
+                        out.g = c.g;
+                        out.b = c.b;
+                    } else {
+                        var lastKey1 = colorKeys[i1 - 1];
+                        var last = lastKey1.color;
+                        var age1 = (colorT - lastKey1.time) / (key1.time - lastKey1.time);
+                        out.r = last.r + (c.r - last.r) * age1;
+                        out.g = last.g + (c.g - last.g) * age1;
+                        out.b = last.b + (c.b - last.b) * age1;
+                    }
+                    break;
+                }
+            }
+        }
+    };
     _proto._addKey = function _addKey(keys, key) {
         var time = key.time;
         var count = keys.length;
@@ -34811,6 +34976,17 @@ __decorate([
             case ParticleGradientMode.TwoConstants:
                 engineMath.Color.lerp(this.constantMin, this.constantMax, lerpFactor, out);
                 break;
+            case ParticleGradientMode.Gradient:
+                this.gradientMax._evaluate(time, out);
+                break;
+            case ParticleGradientMode.TwoGradients:
+                {
+                    var tmp = ParticleCompositeGradient._tempColor;
+                    this.gradientMin._evaluate(time, tmp);
+                    this.gradientMax._evaluate(time, out);
+                    engineMath.Color.lerp(tmp, out, lerpFactor, out);
+                    break;
+                }
         }
     };
     _create_class(ParticleCompositeGradient, [
@@ -34839,6 +35015,7 @@ __decorate([
     ]);
     return ParticleCompositeGradient;
 }();
+ParticleCompositeGradient._tempColor = new engineMath.Color();
 __decorate([
     deepClone
 ], ParticleCompositeGradient.prototype, "constantMin", void 0);
@@ -35016,7 +35193,33 @@ __decorate([
     };
     /**
    * @internal
+   */ _proto._evaluateCumulative = function _evaluateCumulative(normalizedAge, lerpFactor) {
+        switch(this.mode){
+            case ParticleCurveMode.Constant:
+                return this.constantMax * normalizedAge;
+            case ParticleCurveMode.TwoConstants:
+                return (this.constantMin + (this.constantMax - this.constantMin) * lerpFactor) * normalizedAge;
+            case ParticleCurveMode.Curve:
+                var _this_curveMax;
+                var _this_curveMax__evaluateCumulative;
+                return (_this_curveMax__evaluateCumulative = (_this_curveMax = this.curveMax) == null ? void 0 : _this_curveMax._evaluateCumulative(normalizedAge)) != null ? _this_curveMax__evaluateCumulative : 0;
+            case ParticleCurveMode.TwoCurves:
+                {
+                    var _this_curveMin, _this_curveMax1;
+                    var _this_curveMin__evaluateCumulative;
+                    var min = (_this_curveMin__evaluateCumulative = (_this_curveMin = this.curveMin) == null ? void 0 : _this_curveMin._evaluateCumulative(normalizedAge)) != null ? _this_curveMin__evaluateCumulative : 0;
+                    var _this_curveMax__evaluateCumulative1;
+                    var max = (_this_curveMax__evaluateCumulative1 = (_this_curveMax1 = this.curveMax) == null ? void 0 : _this_curveMax1._evaluateCumulative(normalizedAge)) != null ? _this_curveMax__evaluateCumulative1 : 0;
+                    return min + (max - min) * lerpFactor;
+                }
+            default:
+                return 0;
+        }
+    };
+    /**
+   * @internal
    */ _proto._getMax = function _getMax() {
+        var minMaxRange = ParticleCompositeCurve._minMaxRange;
         switch(this.mode){
             case ParticleCurveMode.Constant:
                 return this.constantMax;
@@ -35024,17 +35227,18 @@ __decorate([
                 return Math.max(this.constantMin, this.constantMax);
             case ParticleCurveMode.Curve:
                 var _this_curveMax;
-                return this._getMaxKeyValue((_this_curveMax = this.curveMax) == null ? void 0 : _this_curveMax.keys);
+                this._getKeyMinMax((_this_curveMax = this.curveMax) == null ? void 0 : _this_curveMax.keys, minMaxRange);
+                return minMaxRange.y;
             case ParticleCurveMode.TwoCurves:
                 var _this_curveMin, _this_curveMax1;
-                var min = this._getMaxKeyValue((_this_curveMin = this.curveMin) == null ? void 0 : _this_curveMin.keys);
-                var max = this._getMaxKeyValue((_this_curveMax1 = this.curveMax) == null ? void 0 : _this_curveMax1.keys);
-                return min > max ? min : max;
+                this._getKeyMinMax((_this_curveMin = this.curveMin) == null ? void 0 : _this_curveMin.keys, minMaxRange);
+                var maxCurveMin = minMaxRange.y;
+                this._getKeyMinMax((_this_curveMax1 = this.curveMax) == null ? void 0 : _this_curveMax1.keys, minMaxRange);
+                return maxCurveMin > minMaxRange.y ? maxCurveMin : minMaxRange.y;
         }
     };
     /**
    * @internal
-
    */ _proto._getMinMax = function _getMinMax(out) {
         switch(this.mode){
             case ParticleCurveMode.Constant:
@@ -35044,23 +35248,40 @@ __decorate([
                 out.set(Math.min(this.constantMin, this.constantMax), Math.max(this.constantMin, this.constantMax));
                 break;
             case ParticleCurveMode.Curve:
-                var _this_curveMax, _this_curveMax1;
-                out.set(this._getMinKeyValue((_this_curveMax = this.curveMax) == null ? void 0 : _this_curveMax.keys), this._getMaxKeyValue((_this_curveMax1 = this.curveMax) == null ? void 0 : _this_curveMax1.keys));
+                var _this_curveMax;
+                this._getKeyMinMax((_this_curveMax = this.curveMax) == null ? void 0 : _this_curveMax.keys, out);
                 break;
             case ParticleCurveMode.TwoCurves:
-                var _this_curveMax2, _this_curveMin, _this_curveMax3, _this_curveMin1;
-                var minCurveMax = this._getMinKeyValue((_this_curveMax2 = this.curveMax) == null ? void 0 : _this_curveMax2.keys);
-                var minCurveMin = this._getMinKeyValue((_this_curveMin = this.curveMin) == null ? void 0 : _this_curveMin.keys);
-                var maxCurveMax = this._getMaxKeyValue((_this_curveMax3 = this.curveMax) == null ? void 0 : _this_curveMax3.keys);
-                var maxCurveMin = this._getMaxKeyValue((_this_curveMin1 = this.curveMin) == null ? void 0 : _this_curveMin1.keys);
-                var min = minCurveMax < minCurveMin ? minCurveMax : minCurveMin;
-                var max = maxCurveMax > maxCurveMin ? maxCurveMax : maxCurveMin;
-                out.set(min, max);
+                var _this_curveMin, _this_curveMax1;
+                this._getKeyMinMax((_this_curveMin = this.curveMin) == null ? void 0 : _this_curveMin.keys, out);
+                var minCurveMin = out.x;
+                var maxCurveMin = out.y;
+                this._getKeyMinMax((_this_curveMax1 = this.curveMax) == null ? void 0 : _this_curveMax1.keys, out);
+                var minCurveMax = out.x;
+                var maxCurveMax = out.y;
+                out.set(minCurveMax < minCurveMin ? minCurveMax : minCurveMin, maxCurveMax > maxCurveMin ? maxCurveMax : maxCurveMin);
                 break;
         }
     };
     /**
    * @internal
+   */ _proto._isZero = function _isZero() {
+        var minMax = ParticleCompositeCurve._minMaxRange;
+        this._getMinMax(minMax);
+        return minMax.x === 0 && minMax.y === 0;
+    };
+    /**
+   * @internal
+   */ _proto._isCurveMode = function _isCurveMode() {
+        return this._mode === ParticleCurveMode.Curve || this._mode === ParticleCurveMode.TwoCurves;
+    };
+    /**
+   * @internal
+   */ _proto._isRandomMode = function _isRandomMode() {
+        return this._mode === ParticleCurveMode.TwoConstants || this._mode === ParticleCurveMode.TwoCurves;
+    };
+    /**
+   * @internal
    */ _proto._registerOnValueChanged = function _registerOnValueChanged(listener) {
         this._updateManager.addListener(listener);
     };
@@ -35069,31 +35290,20 @@ __decorate([
    */ _proto._unRegisterOnValueChanged = function _unRegisterOnValueChanged(listener) {
         this._updateManager.removeListener(listener);
     };
-    _proto._getMaxKeyValue = function _getMaxKeyValue(keys) {
-        var max = undefined;
-        var _keys_length;
-        var count = (_keys_length = keys == null ? void 0 : keys.length) != null ? _keys_length : 0;
-        if (count > 0) {
-            max = keys[0].value;
-            for(var i = 1; i < count; i++){
-                var value = keys[i].value;
-                max = Math.max(max, value);
-            }
-        }
-        return max;
-    };
-    _proto._getMinKeyValue = function _getMinKeyValue(keys) {
+    _proto._getKeyMinMax = function _getKeyMinMax(keys, out) {
         var min = undefined;
+        var max = undefined;
         var _keys_length;
         var count = (_keys_length = keys == null ? void 0 : keys.length) != null ? _keys_length : 0;
         if (count > 0) {
-            min = keys[0].value;
+            min = max = keys[0].value;
             for(var i = 1; i < count; i++){
                 var value = keys[i].value;
                 min = Math.min(min, value);
+                max = Math.max(max, value);
             }
         }
-        return min;
+        out.set(min != null ? min : 0, max != null ? max : 0);
     };
     _proto._onCurveChange = function _onCurveChange(lastValue, value) {
         var dispatch = this._updateDispatch;
@@ -35199,6 +35409,7 @@ __decorate([
     ]);
     return ParticleCompositeCurve;
 }();
+ParticleCompositeCurve._minMaxRange = new engineMath.Vector2();
 __decorate([
     ignoreClone
 ], ParticleCompositeCurve.prototype, "_updateManager", void 0);
@@ -36860,6 +37071,34 @@ __decorate([
     };
     /**
    * @internal
+   */ _proto._evaluateCumulative = function _evaluateCumulative(normalizedAge) {
+        var keys = this.keys;
+        var length = keys.length;
+        if (length === 0) return 0;
+        // Single key is a constant curve (matches `_evaluate`); its integral is value × age.
+        if (length === 1) return keys[0].value * normalizedAge;
+        var firstKey = keys[0];
+        if (normalizedAge <= firstKey.time) return firstKey.value * normalizedAge;
+        var cumulative = firstKey.value * firstKey.time;
+        for(var i = 1; i < length; i++){
+            var key = keys[i];
+            var lastKey = keys[i - 1];
+            var segmentTime = key.time - lastKey.time;
+            if (segmentTime <= 0) continue;
+            if (key.time >= normalizedAge) {
+                var offsetTime = normalizedAge - lastKey.time;
+                var t = offsetTime / segmentTime;
+                var currentValue = lastKey.value + (key.value - lastKey.value) * t;
+                cumulative += (lastKey.value + currentValue) * 0.5 * offsetTime;
+                return cumulative;
+            }
+            cumulative += (lastKey.value + key.value) * 0.5 * segmentTime;
+        }
+        var lastKey1 = keys[length - 1];
+        return cumulative + lastKey1.value * (normalizedAge - lastKey1.time);
+    };
+    /**
+   * @internal
    */ _proto._getTypeArray = function _getTypeArray() {
         var typeArray = this._typeArray || (this._typeArray = new Float32Array(4 * 2));
         if (this._typeArrayDirty) {
@@ -37508,10 +37747,20 @@ __decorate([
     _inherits(VelocityOverLifetimeModule, ParticleGeneratorModule);
     function VelocityOverLifetimeModule(generator) {
         var _this;
-        _this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._velocityRand = new engineMath.Rand(0, ParticleRandomSubSeeds.VelocityOverLifetime), _this._velocityMinConstant = new engineMath.Vector3(), _this._velocityMaxConstant = new engineMath.Vector3(), _this._space = ParticleSimulationSpace.Local;
+        _this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._velocityRand = new engineMath.Rand(0, ParticleRandomSubSeeds.VelocityOverLifetime), _this._velocityMinConstant = new engineMath.Vector3(), _this._velocityMaxConstant = new engineMath.Vector3(), _this._orbitalMinConstant = new engineMath.Vector3(), _this._orbitalConstant = new engineMath.Vector3(), _this._offset = new engineMath.Vector3(), _this._space = ParticleSimulationSpace.Local, _this._onTransformFeedbackDirty = function() {
+            return _this._generator._setTransformFeedback();
+        };
         _this.velocityX = new ParticleCompositeCurve(0);
         _this.velocityY = new ParticleCompositeCurve(0);
         _this.velocityZ = new ParticleCompositeCurve(0);
+        _this.orbitalX = new ParticleCompositeCurve(0);
+        _this.orbitalY = new ParticleCompositeCurve(0);
+        _this.orbitalZ = new ParticleCompositeCurve(0);
+        _this.radial = new ParticleCompositeCurve(0);
+        // @ts-ignore
+        _this._offset._onValueChanged = function() {
+            return _this._generator._renderer._onGeneratorParamsChanged();
+        };
         return _this;
     }
     var _proto = VelocityOverLifetimeModule.prototype;
@@ -37520,6 +37769,10 @@ __decorate([
    */ _proto._updateShaderData = function _updateShaderData(shaderData) {
         var velocityMacro = null;
         var isRandomModeMacro = null;
+        var orbitalMacro = null;
+        var orbitalRandomModeMacro = null;
+        var radialMacro = null;
+        var radialRandomModeMacro = null;
         if (this.enabled) {
             var velocityX = this.velocityX;
             var velocityY = this.velocityY;
@@ -37549,15 +37802,111 @@ __decorate([
                 }
             }
             shaderData.setInt(VelocityOverLifetimeModule._spaceProperty, this.space);
+            var needTransformFeedback = this._needTransformFeedback();
+            var orbitalActive = needTransformFeedback && this._isOrbitalActive();
+            var radialActive = needTransformFeedback && this._isRadialActive();
+            if (orbitalActive) {
+                var orbitalX = this._orbitalX;
+                var orbitalY = this._orbitalY;
+                var orbitalZ = this._orbitalZ;
+                var isOrbitalRandomCurveMode = orbitalX.mode === ParticleCurveMode.TwoCurves && orbitalY.mode === ParticleCurveMode.TwoCurves && orbitalZ.mode === ParticleCurveMode.TwoCurves;
+                if (isOrbitalRandomCurveMode || orbitalX.mode === ParticleCurveMode.Curve && orbitalY.mode === ParticleCurveMode.Curve && orbitalZ.mode === ParticleCurveMode.Curve) {
+                    shaderData.setFloatArray(VelocityOverLifetimeModule._orbitalMaxCurveXProperty, orbitalX.curveMax._getTypeArray());
+                    shaderData.setFloatArray(VelocityOverLifetimeModule._orbitalMaxCurveYProperty, orbitalY.curveMax._getTypeArray());
+                    shaderData.setFloatArray(VelocityOverLifetimeModule._orbitalMaxCurveZProperty, orbitalZ.curveMax._getTypeArray());
+                    orbitalMacro = VelocityOverLifetimeModule._orbitalCurveModeMacro;
+                    if (isOrbitalRandomCurveMode) {
+                        shaderData.setFloatArray(VelocityOverLifetimeModule._orbitalMinCurveXProperty, orbitalX.curveMin._getTypeArray());
+                        shaderData.setFloatArray(VelocityOverLifetimeModule._orbitalMinCurveYProperty, orbitalY.curveMin._getTypeArray());
+                        shaderData.setFloatArray(VelocityOverLifetimeModule._orbitalMinCurveZProperty, orbitalZ.curveMin._getTypeArray());
+                        orbitalRandomModeMacro = VelocityOverLifetimeModule._orbitalRandomModeMacro;
+                    }
+                } else {
+                    this._orbitalConstant.set(orbitalX.constantMax, orbitalY.constantMax, orbitalZ.constantMax);
+                    shaderData.setVector3(VelocityOverLifetimeModule._orbitalMaxConstantProperty, this._orbitalConstant);
+                    orbitalMacro = VelocityOverLifetimeModule._orbitalConstantModeMacro;
+                    if (orbitalX.mode === ParticleCurveMode.TwoConstants && orbitalY.mode === ParticleCurveMode.TwoConstants && orbitalZ.mode === ParticleCurveMode.TwoConstants) {
+                        this._orbitalMinConstant.set(orbitalX.constantMin, orbitalY.constantMin, orbitalZ.constantMin);
+                        shaderData.setVector3(VelocityOverLifetimeModule._orbitalMinConstantProperty, this._orbitalMinConstant);
+                        orbitalRandomModeMacro = VelocityOverLifetimeModule._orbitalRandomModeMacro;
+                    }
+                }
+            }
+            if (radialActive) {
+                var radial = this._radial;
+                var isRadialRandomMode = radial._isRandomMode();
+                if (radial._isCurveMode()) {
+                    shaderData.setFloatArray(VelocityOverLifetimeModule._radialMaxCurveProperty, radial.curveMax._getTypeArray());
+                    radialMacro = VelocityOverLifetimeModule._radialCurveModeMacro;
+                    if (isRadialRandomMode) {
+                        shaderData.setFloatArray(VelocityOverLifetimeModule._radialMinCurveProperty, radial.curveMin._getTypeArray());
+                        radialRandomModeMacro = VelocityOverLifetimeModule._radialRandomModeMacro;
+                    }
+                } else {
+                    shaderData.setFloat(VelocityOverLifetimeModule._radialMaxConstantProperty, radial.constantMax);
+                    radialMacro = VelocityOverLifetimeModule._radialConstantModeMacro;
+                    if (isRadialRandomMode) {
+                        shaderData.setFloat(VelocityOverLifetimeModule._radialMinConstantProperty, radial.constantMin);
+                        radialRandomModeMacro = VelocityOverLifetimeModule._radialRandomModeMacro;
+                    }
+                }
+            }
+            if (orbitalActive || radialActive) {
+                shaderData.setVector3(VelocityOverLifetimeModule._offsetProperty, this._offset);
+            }
         }
         this._velocityMacro = this._enableMacro(shaderData, this._velocityMacro, velocityMacro);
         this._randomModeMacro = this._enableMacro(shaderData, this._randomModeMacro, isRandomModeMacro);
+        this._orbitalMacro = this._enableMacro(shaderData, this._orbitalMacro, orbitalMacro);
+        this._orbitalRandomModeMacro = this._enableMacro(shaderData, this._orbitalRandomModeMacro, orbitalRandomModeMacro);
+        this._radialMacro = this._enableMacro(shaderData, this._radialMacro, radialMacro);
+        this._radialRandomModeMacro = this._enableMacro(shaderData, this._radialRandomModeMacro, radialRandomModeMacro);
     };
     /**
    * @internal
    */ _proto._resetRandomSeed = function _resetRandomSeed(seed) {
         this._velocityRand.reset(seed, ParticleRandomSubSeeds.VelocityOverLifetime);
     };
+    /**
+   * @internal
+   */ _proto._needTransformFeedback = function _needTransformFeedback() {
+        if (!this._enabled || !this._generator._renderer.engine._hardwareRenderer.isWebGL2) {
+            return false;
+        }
+        return this._isOrbitalActive() || this._isRadialActive();
+    };
+    /**
+   * @internal
+   */ _proto._isOrbitalActive = function _isOrbitalActive() {
+        return !(this._orbitalX._isZero() && this._orbitalY._isZero() && this._orbitalZ._isZero());
+    };
+    /**
+   * @internal
+   */ _proto._isRadialActive = function _isRadialActive() {
+        return !this._radial._isZero();
+    };
+    /**
+   * @internal
+   */ _proto._isRandomMode = function _isRandomMode() {
+        var velocityX = this.velocityX;
+        var velocityY = this.velocityY;
+        var velocityZ = this.velocityZ;
+        var isLinearRandomMode = velocityX.mode === ParticleCurveMode.TwoConstants && velocityY.mode === ParticleCurveMode.TwoConstants && velocityZ.mode === ParticleCurveMode.TwoConstants || velocityX.mode === ParticleCurveMode.TwoCurves && velocityY.mode === ParticleCurveMode.TwoCurves && velocityZ.mode === ParticleCurveMode.TwoCurves;
+        if (!this._needTransformFeedback()) {
+            return isLinearRandomMode;
+        }
+        var orbitalX = this._orbitalX;
+        var orbitalY = this._orbitalY;
+        var orbitalZ = this._orbitalZ;
+        var isOrbitalRandomMode = orbitalX.mode === ParticleCurveMode.TwoConstants && orbitalY.mode === ParticleCurveMode.TwoConstants && orbitalZ.mode === ParticleCurveMode.TwoConstants || orbitalX.mode === ParticleCurveMode.TwoCurves && orbitalY.mode === ParticleCurveMode.TwoCurves && orbitalZ.mode === ParticleCurveMode.TwoCurves;
+        return isLinearRandomMode || isOrbitalRandomMode || this._radial._isRandomMode();
+    };
+    _proto._onOrbitalRadialChange = function _onOrbitalRadialChange(lastValue, value) {
+        this._onCompositeCurveChange(lastValue, value);
+        lastValue == null ? void 0 : lastValue._unRegisterOnValueChanged(this._onTransformFeedbackDirty);
+        value == null ? void 0 : value._registerOnValueChanged(this._onTransformFeedbackDirty);
+        this._generator._setTransformFeedback();
+    };
     _create_class(VelocityOverLifetimeModule, [
         {
             key: "velocityX",
@@ -37604,6 +37953,84 @@ __decorate([
                 }
             }
         },
+        {
+            key: "orbitalX",
+            get: /**
+   * Orbital velocity (radians/second) around the x axis of the system.
+   * @remarks Requires WebGL2.
+   */ function get() {
+                return this._orbitalX;
+            },
+            set: function set(value) {
+                var lastValue = this._orbitalX;
+                if (value !== lastValue) {
+                    this._orbitalX = value;
+                    this._onOrbitalRadialChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "orbitalY",
+            get: /**
+   * Orbital velocity (radians/second) around the y axis of the system.
+   * @remarks Requires WebGL2.
+   */ function get() {
+                return this._orbitalY;
+            },
+            set: function set(value) {
+                var lastValue = this._orbitalY;
+                if (value !== lastValue) {
+                    this._orbitalY = value;
+                    this._onOrbitalRadialChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "orbitalZ",
+            get: /**
+   * Orbital velocity (radians/second) around the z axis of the system.
+   * @remarks Requires WebGL2.
+   */ function get() {
+                return this._orbitalZ;
+            },
+            set: function set(value) {
+                var lastValue = this._orbitalZ;
+                if (value !== lastValue) {
+                    this._orbitalZ = value;
+                    this._onOrbitalRadialChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "radial",
+            get: /**
+   * Radial velocity moving particles away from (or towards) the center.
+   * @remarks Requires WebGL2.
+   */ function get() {
+                return this._radial;
+            },
+            set: function set(value) {
+                var lastValue = this._radial;
+                if (value !== lastValue) {
+                    this._radial = value;
+                    this._onOrbitalRadialChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "centerOffset",
+            get: /**
+   * The center offset of orbital/radial motion from the particle system origin.
+   */ function get() {
+                return this._offset;
+            },
+            set: function set(value) {
+                var offset = this._offset;
+                if (value !== offset) {
+                    offset.copyFrom(value);
+                }
+            }
+        },
         {
             key: "space",
             get: /**
@@ -37626,6 +38053,7 @@ __decorate([
             set: function set(value) {
                 if (value !== this._enabled) {
                     this._enabled = value;
+                    this._generator._setTransformFeedback();
                     this._generator._renderer._onGeneratorParamsChanged();
                 }
             }
@@ -37645,6 +38073,25 @@ VelocityOverLifetimeModule._maxGradientXProperty = ShaderProperty.getByName("ren
 VelocityOverLifetimeModule._maxGradientYProperty = ShaderProperty.getByName("renderer_VOLMaxGradientY");
 VelocityOverLifetimeModule._maxGradientZProperty = ShaderProperty.getByName("renderer_VOLMaxGradientZ");
 VelocityOverLifetimeModule._spaceProperty = ShaderProperty.getByName("renderer_VOLSpace");
+VelocityOverLifetimeModule._orbitalConstantModeMacro = ShaderMacro.getByName("RENDERER_VOL_ORBITAL_CONSTANT_MODE");
+VelocityOverLifetimeModule._orbitalCurveModeMacro = ShaderMacro.getByName("RENDERER_VOL_ORBITAL_CURVE_MODE");
+VelocityOverLifetimeModule._orbitalRandomModeMacro = ShaderMacro.getByName("RENDERER_VOL_ORBITAL_IS_RANDOM_TWO");
+VelocityOverLifetimeModule._radialConstantModeMacro = ShaderMacro.getByName("RENDERER_VOL_RADIAL_CONSTANT_MODE");
+VelocityOverLifetimeModule._radialCurveModeMacro = ShaderMacro.getByName("RENDERER_VOL_RADIAL_CURVE_MODE");
+VelocityOverLifetimeModule._radialRandomModeMacro = ShaderMacro.getByName("RENDERER_VOL_RADIAL_IS_RANDOM_TWO");
+VelocityOverLifetimeModule._orbitalMinConstantProperty = ShaderProperty.getByName("renderer_VOLOrbitalMinConst");
+VelocityOverLifetimeModule._orbitalMaxConstantProperty = ShaderProperty.getByName("renderer_VOLOrbitalMaxConst");
+VelocityOverLifetimeModule._orbitalMinCurveXProperty = ShaderProperty.getByName("renderer_VOLOrbitalMinCurveX");
+VelocityOverLifetimeModule._orbitalMinCurveYProperty = ShaderProperty.getByName("renderer_VOLOrbitalMinCurveY");
+VelocityOverLifetimeModule._orbitalMinCurveZProperty = ShaderProperty.getByName("renderer_VOLOrbitalMinCurveZ");
+VelocityOverLifetimeModule._orbitalMaxCurveXProperty = ShaderProperty.getByName("renderer_VOLOrbitalMaxCurveX");
+VelocityOverLifetimeModule._orbitalMaxCurveYProperty = ShaderProperty.getByName("renderer_VOLOrbitalMaxCurveY");
+VelocityOverLifetimeModule._orbitalMaxCurveZProperty = ShaderProperty.getByName("renderer_VOLOrbitalMaxCurveZ");
+VelocityOverLifetimeModule._radialMinConstantProperty = ShaderProperty.getByName("renderer_VOLRadialMinConst");
+VelocityOverLifetimeModule._radialMaxConstantProperty = ShaderProperty.getByName("renderer_VOLRadialMaxConst");
+VelocityOverLifetimeModule._radialMinCurveProperty = ShaderProperty.getByName("renderer_VOLRadialMinCurve");
+VelocityOverLifetimeModule._radialMaxCurveProperty = ShaderProperty.getByName("renderer_VOLRadialMaxCurve");
+VelocityOverLifetimeModule._offsetProperty = ShaderProperty.getByName("renderer_VOLOffset");
 __decorate([
     ignoreClone
 ], VelocityOverLifetimeModule.prototype, "_velocityRand", void 0);
@@ -37660,6 +38107,24 @@ __decorate([
 __decorate([
     ignoreClone
 ], VelocityOverLifetimeModule.prototype, "_randomModeMacro", void 0);
+__decorate([
+    ignoreClone
+], VelocityOverLifetimeModule.prototype, "_orbitalMinConstant", void 0);
+__decorate([
+    ignoreClone
+], VelocityOverLifetimeModule.prototype, "_orbitalConstant", void 0);
+__decorate([
+    ignoreClone
+], VelocityOverLifetimeModule.prototype, "_orbitalMacro", void 0);
+__decorate([
+    ignoreClone
+], VelocityOverLifetimeModule.prototype, "_orbitalRandomModeMacro", void 0);
+__decorate([
+    ignoreClone
+], VelocityOverLifetimeModule.prototype, "_radialMacro", void 0);
+__decorate([
+    ignoreClone
+], VelocityOverLifetimeModule.prototype, "_radialRandomModeMacro", void 0);
 __decorate([
     deepClone
 ], VelocityOverLifetimeModule.prototype, "_velocityX", void 0);
@@ -37669,6 +38134,239 @@ __decorate([
 __decorate([
     deepClone
 ], VelocityOverLifetimeModule.prototype, "_velocityZ", void 0);
+__decorate([
+    deepClone
+], VelocityOverLifetimeModule.prototype, "_orbitalX", void 0);
+__decorate([
+    deepClone
+], VelocityOverLifetimeModule.prototype, "_orbitalY", void 0);
+__decorate([
+    deepClone
+], VelocityOverLifetimeModule.prototype, "_orbitalZ", void 0);
+__decorate([
+    deepClone
+], VelocityOverLifetimeModule.prototype, "_radial", void 0);
+__decorate([
+    deepClone
+], VelocityOverLifetimeModule.prototype, "_offset", void 0);
+__decorate([
+    ignoreClone
+], VelocityOverLifetimeModule.prototype, "_onTransformFeedbackDirty", void 0);
+
+/**
+ * Optional parent properties a sub-emitter inherits
+ * Sub particles are always emitted at the parent particle's position; these flags only select
+ * which additional properties are inherited on top of that.
+ */ var ParticleSubEmitterInheritProperty = /*#__PURE__*/ function(ParticleSubEmitterInheritProperty) {
+    /** Inherit no additional properties; sub particles are still emitted at the parent's position. */ ParticleSubEmitterInheritProperty[ParticleSubEmitterInheritProperty["None"] = 0] = "None";
+    /** Multiply parent's current color into the sub particle's start color. */ ParticleSubEmitterInheritProperty[ParticleSubEmitterInheritProperty["Color"] = 1] = "Color";
+    /** Multiply parent's current size into the sub particle's start size. */ ParticleSubEmitterInheritProperty[ParticleSubEmitterInheritProperty["Size"] = 2] = "Size";
+    /** Add parent's current rotation onto the sub particle's start rotation. */ ParticleSubEmitterInheritProperty[ParticleSubEmitterInheritProperty["Rotation"] = 4] = "Rotation";
+    /** Emit the sub particle along the parent's velocity direction. */ ParticleSubEmitterInheritProperty[ParticleSubEmitterInheritProperty["Velocity"] = 8] = "Velocity";
+    return ParticleSubEmitterInheritProperty;
+}({});
+
+/**
+ * One slot in `SubEmittersModule.subEmitters`. Configures which sub-emitter
+ * fires, on which parent event, with what inheritance, probability, and count.
+ */ var SubEmitter = /*#__PURE__*/ function() {
+    function SubEmitter() {
+        /** Bitmask of properties inherited from the parent particle. */ this.inheritProperties = ParticleSubEmitterInheritProperty.None;
+        /** Probability (0..1) the sub-emitter fires for any given event. */ this.emitProbability = 1;
+        /** Number of sub particles emitted per parent event. */ this.emitCount = 1;
+        /** @internal */ this._module = null;
+        this._emitter = null;
+        this._type = ParticleSubEmitterType.Birth;
+    }
+    _create_class(SubEmitter, [
+        {
+            key: "emitter",
+            get: /**
+   * Target particle renderer the sub particles emit into.
+   */ function get() {
+                return this._emitter;
+            },
+            set: function set(value) {
+                var _this__module;
+                if (value === this._emitter) return;
+                (_this__module = this._module) == null ? void 0 : _this__module._validateEmitter(value);
+                this._emitter = value;
+            }
+        },
+        {
+            key: "type",
+            get: /**
+   * Which parent-particle event drives this slot.
+   */ function get() {
+                return this._type;
+            },
+            set: function set(value) {
+                var _this__module;
+                if (value === this._type) return;
+                this._type = value;
+                (_this__module = this._module) == null ? void 0 : _this__module._generator._setTransformFeedback();
+            }
+        }
+    ]);
+    return SubEmitter;
+}();
+__decorate([
+    ignoreClone
+], SubEmitter.prototype, "_module", void 0);
+
+/**
+ * Fires sub-emitters on parent particle lifecycle events (Birth / Death).
+ * @remarks Requires WebGL2; the module stays inactive on WebGL1.
+ */ var SubEmittersModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
+    _inherits(SubEmittersModule, ParticleGeneratorModule);
+    function SubEmittersModule() {
+        var _this;
+        _this = ParticleGeneratorModule.apply(this, arguments) || this, _this._subEmitters = [], _this._probabilityRand = new engineMath.Rand(0, ParticleRandomSubSeeds.SubEmitter);
+        return _this;
+    }
+    var _proto = SubEmittersModule.prototype;
+    /**
+   * Add a sub-emitter slot.
+   * @param emitter - Target particle renderer
+   * @param type - Trigger event (`Birth` / `Death`)
+   * @param inheritProperties - Bitmask of properties inherited from the parent particle
+   * @param emitProbability - Per-event fire probability [0, 1]
+   * @param emitCount - Number of sub particles emitted per parent event
+   */ _proto.addSubEmitter = function addSubEmitter(emitter, type, inheritProperties, emitProbability, emitCount) {
+        if (inheritProperties === void 0) inheritProperties = ParticleSubEmitterInheritProperty.None;
+        if (emitProbability === void 0) emitProbability = 1;
+        if (emitCount === void 0) emitCount = 1;
+        if (SubEmittersModule._wouldCreateCycle(emitter, this._generator)) {
+            throw new Error("Sub-emitter would create a cycle");
+        }
+        var sub = new SubEmitter();
+        sub.emitter = emitter;
+        sub.type = type;
+        sub.inheritProperties = inheritProperties;
+        sub.emitProbability = emitProbability;
+        sub.emitCount = emitCount;
+        sub._module = this;
+        this._subEmitters.push(sub);
+        this._generator._setTransformFeedback();
+    };
+    /**
+   * Remove the sub-emitter at the given index.
+   * @param index - Index of the sub-emitter to remove
+   */ _proto.removeSubEmitterByIndex = function removeSubEmitterByIndex(index) {
+        this._subEmitters.splice(index, 1);
+        this._generator._setTransformFeedback();
+    };
+    /**
+   * @internal
+   */ _proto._dispatchEvent = function _dispatchEvent(type, worldPosition, parentColor, parentSize, parentRotation, worldDirection) {
+        var subEmitters = this.subEmitters;
+        for(var i = 0, n = subEmitters.length; i < n; i++){
+            var sub = subEmitters[i];
+            if (sub.type !== type) continue;
+            var target = sub.emitter;
+            if (target === null || target.destroyed) continue;
+            var count = sub.emitCount;
+            if (count <= 0) continue;
+            if (sub.emitProbability < 1.0 && this._probabilityRand.random() >= sub.emitProbability) {
+                continue;
+            }
+            var inherit = sub.inheritProperties;
+            var colorOverride = (inherit & ParticleSubEmitterInheritProperty.Color) !== 0 ? parentColor : null;
+            var sizeOverride = (inherit & ParticleSubEmitterInheritProperty.Size) !== 0 ? parentSize : null;
+            var rotationOverride = (inherit & ParticleSubEmitterInheritProperty.Rotation) !== 0 ? parentRotation : null;
+            var directionOverride = (inherit & ParticleSubEmitterInheritProperty.Velocity) !== 0 ? worldDirection : null;
+            target.generator._emitFromSubEmitter(count, worldPosition, colorOverride, sizeOverride, rotationOverride, directionOverride);
+        }
+    };
+    /**
+   * @internal
+   */ _proto._resetRandomSeed = function _resetRandomSeed(seed) {
+        this._probabilityRand.reset(seed, ParticleRandomSubSeeds.SubEmitter);
+    };
+    /**
+   * @internal
+   */ _proto._hasSubEmitterOfType = function _hasSubEmitterOfType(type) {
+        if (!this.enabled) return false;
+        var subEmitters = this.subEmitters;
+        for(var i = 0, n = subEmitters.length; i < n; i++){
+            if (subEmitters[i].type === type) return true;
+        }
+        return false;
+    };
+    /**
+   * @internal
+   */ _proto._cloneTo = function _cloneTo(target) {
+        // _module is @ignoreClone, so re-link each cloned slot back to its new module
+        var subEmitters = target._subEmitters;
+        for(var i = 0, n = subEmitters.length; i < n; i++){
+            subEmitters[i]._module = target;
+        }
+    };
+    /**
+   * @internal
+   */ _proto._validateEmitter = function _validateEmitter(emitter) {
+        if (emitter && SubEmittersModule._wouldCreateCycle(emitter, this._generator)) {
+            throw new Error("Sub-emitter would create a cycle");
+        }
+    };
+    SubEmittersModule._wouldCreateCycle = function _wouldCreateCycle(target, root) {
+        var visited = SubEmittersModule._cycleVisited;
+        var stack = SubEmittersModule._cycleStack;
+        visited.clear();
+        stack.length = 0;
+        stack.push(target.generator);
+        var found = false;
+        while(stack.length > 0){
+            var cur = stack.pop();
+            if (cur === root) {
+                found = true;
+                break;
+            }
+            if (visited.has(cur)) continue;
+            visited.add(cur);
+            var slots = cur.subEmitters.subEmitters;
+            for(var i = 0, n = slots.length; i < n; i++){
+                var _slots_i_emitter;
+                var child = (_slots_i_emitter = slots[i].emitter) == null ? void 0 : _slots_i_emitter.generator;
+                if (child && !visited.has(child)) stack.push(child);
+            }
+        }
+        visited.clear();
+        stack.length = 0;
+        return found;
+    };
+    _create_class(SubEmittersModule, [
+        {
+            key: "subEmitters",
+            get: /**
+   * The configured sub-emitters.
+   */ function get() {
+                return this._subEmitters;
+            }
+        },
+        {
+            key: "enabled",
+            get: function get() {
+                return this._enabled && this._generator._renderer.engine._hardwareRenderer.isWebGL2;
+            },
+            set: function set(value) {
+                if (value !== this._enabled) {
+                    this._enabled = value;
+                    this._generator._setTransformFeedback();
+                }
+            }
+        }
+    ]);
+    return SubEmittersModule;
+}(ParticleGeneratorModule);
+SubEmittersModule._cycleVisited = new Set();
+SubEmittersModule._cycleStack = [];
+__decorate([
+    deepClone
+], SubEmittersModule.prototype, "_subEmitters", void 0);
+__decorate([
+    ignoreClone
+], SubEmittersModule.prototype, "_probabilityRand", void 0);
 
 /**
  * Particle Generator.
@@ -37689,6 +38387,7 @@ __decorate([
         /** @internal */ this._subPrimitive = new SubMesh(0, 0, MeshTopology.Triangles);
         /** @internal */ this._useTransformFeedback = false;
         /** @internal */ this._feedbackBindingIndex = -1;
+        this._feedbackReadback = null;
         this._isPlaying = false;
         this._instanceBufferResized = false;
         this._waitProcessRetiredElementCount = 0;
@@ -37697,6 +38396,13 @@ __decorate([
         this._firstActiveTransformedBoundingBox = 0;
         this._firstFreeTransformedBoundingBox = 0;
         this._playStartDelay = 0;
+        this._eventPos = new engineMath.Vector3();
+        this._eventColor = new engineMath.Color();
+        this._eventSize = new engineMath.Vector3();
+        this._eventRotation = new engineMath.Vector3();
+        this._eventDir = new engineMath.Vector3();
+        this._emitLocalPos = new engineMath.Vector3();
+        this._emitDirection = new engineMath.Vector3();
         this._renderer = renderer;
         var subPrimitive = new SubPrimitive();
         subPrimitive.start = 0;
@@ -37709,6 +38415,7 @@ __decorate([
         this.sizeOverLifetime = new SizeOverLifetimeModule(this);
         this.limitVelocityOverLifetime = new LimitVelocityOverLifetimeModule(this);
         this.noise = new NoiseModule(this);
+        this.subEmitters = new SubEmittersModule(this);
         this.customData = new CustomDataModule(this);
         this.emission.enabled = true;
     }
@@ -38040,16 +38747,15 @@ __decorate([
         this.rotationOverLifetime._resetRandomSeed(seed);
         this.colorOverLifetime._resetRandomSeed(seed);
         this.noise._resetRandomSeed(seed);
+        this.subEmitters._resetRandomSeed(seed);
     };
     /**
    * @internal
    */ _proto._setTransformFeedback = function _setTransformFeedback() {
-        var needed = this.limitVelocityOverLifetime.enabled || this.noise.enabled;
+        var _this_limitVelocityOverLifetime, _this_noise, _this_velocityOverLifetime, _this_subEmitters;
+        var needed = !!(this._renderer.engine._hardwareRenderer.isWebGL2 && (((_this_limitVelocityOverLifetime = this.limitVelocityOverLifetime) == null ? void 0 : _this_limitVelocityOverLifetime.enabled) || ((_this_noise = this.noise) == null ? void 0 : _this_noise.enabled) || ((_this_velocityOverLifetime = this.velocityOverLifetime) == null ? void 0 : _this_velocityOverLifetime._needTransformFeedback()) || ((_this_subEmitters = this.subEmitters) == null ? void 0 : _this_subEmitters._hasSubEmitterOfType(ParticleSubEmitterType.Death))));
         if (needed === this._useTransformFeedback) return;
         this._useTransformFeedback = needed;
-        // Switching TF mode invalidates all active particle state: feedback buffers and instance
-        // buffer layout are incompatible between the two paths. Clear rather than show a one-frame
-        // jump; new particles will fill in naturally from the next emit cycle.
         this._clearActiveParticles();
         if (needed) {
             if (!this._feedbackSimulator) {
@@ -38127,7 +38833,12 @@ __decorate([
             this._calculateTransformedBounds(maxLifetime, generatorBounds, transformedBounds);
             renderer._setDirtyFlagFalse(ParticleUpdateFlags.TransformVolume);
         }
-        this._addGravityToBounds(maxLifetime, transformedBounds, bounds);
+        if (this._useOrbitalBounds()) {
+            bounds.min.copyFrom(transformedBounds.min);
+            bounds.max.copyFrom(transformedBounds.max);
+        } else {
+            this._addGravityToBounds(maxLifetime, transformedBounds, bounds);
+        }
     };
     /**
    * @internal
@@ -38153,7 +38864,9 @@ __decorate([
             }
         }
         var maxLifetime = this.main.startLifetime._getMax();
-        this._addGravityToBounds(maxLifetime, bounds, bounds);
+        if (!this._useOrbitalBounds()) {
+            this._addGravityToBounds(maxLifetime, bounds, bounds);
+        }
     };
     /**
    * @internal
@@ -38205,7 +38918,7 @@ __decorate([
             this._transformedBoundsArray[previousFreeElement * ParticleBufferUtils.boundsFloatStride + boundsTimeOffset] = this._playTime;
         }
     };
-    _proto._addNewParticle = function _addNewParticle(position, direction, transform, playTime, emitWorldPositionOverride) {
+    _proto._addNewParticle = function _addNewParticle(position, direction, transform, playTime, emitWorldPositionOverride, inheritColor, inheritSize, inheritRotation) {
         var firstFreeElement = this._firstFreeElement;
         var nextFreeElement = firstFreeElement + 1;
         if (nextFreeElement >= this._currentParticleCount) {
@@ -38243,7 +38956,7 @@ __decorate([
         // Time
         instanceVertices[offset + ParticleBufferUtils.timeOffset] = playTime;
         // Color
-        var startColor = ParticleGenerator._tempColor0;
+        var startColor = ParticleGenerator._tempColor;
         main.startColor.evaluate(undefined, main._startColorRand.random(), startColor);
         startColor.copyToArray(instanceVertices, offset + 8);
         var duration = this.main.duration;
@@ -38302,7 +39015,7 @@ __decorate([
         }
         // Velocity random
         var velocityOverLifetime = this.velocityOverLifetime;
-        if (velocityOverLifetime.enabled && velocityOverLifetime.velocityX.mode === ParticleCurveMode.TwoConstants && velocityOverLifetime.velocityY.mode === ParticleCurveMode.TwoConstants && velocityOverLifetime.velocityZ.mode === ParticleCurveMode.TwoConstants) {
+        if (velocityOverLifetime.enabled && velocityOverLifetime._isRandomMode()) {
             var rand = velocityOverLifetime._velocityRand;
             instanceVertices[offset + 24] = rand.random();
             instanceVertices[offset + 25] = rand.random();
@@ -38344,11 +39057,79 @@ __decorate([
         if (limitVelocityOverLifetime.enabled && (limitVelocityOverLifetime._isSpeedRandomMode() || limitVelocityOverLifetime._isDragRandomMode())) {
             instanceVertices[offset + 41] = limitVelocityOverLifetime._speedRand.random();
         }
+        // Apply sub-emit inherit: multiply color/size, add rotation
+        if (inheritColor) {
+            instanceVertices[offset + 8] *= inheritColor.r;
+            instanceVertices[offset + 9] *= inheritColor.g;
+            instanceVertices[offset + 10] *= inheritColor.b;
+            instanceVertices[offset + 11] *= inheritColor.a;
+        }
+        if (inheritSize) {
+            instanceVertices[offset + 12] *= inheritSize.x;
+            instanceVertices[offset + 13] *= inheritSize.y;
+            instanceVertices[offset + 14] *= inheritSize.z;
+        }
+        if (inheritRotation) {
+            instanceVertices[offset + 15] += inheritRotation.x;
+            instanceVertices[offset + 16] += inheritRotation.y;
+            instanceVertices[offset + 17] += inheritRotation.z;
+        }
         // Initialize feedback buffer for this particle
         if (this._useTransformFeedback) {
             this._addFeedbackParticle(firstFreeElement, position, direction, startSpeed, transform, pos);
         }
         this._firstFreeElement = nextFreeElement;
+        if (this.subEmitters._hasSubEmitterOfType(ParticleSubEmitterType.Birth)) {
+            this._onParticleBirth(offset, position, direction, transform);
+        }
+    };
+    _proto._onParticleBirth = function _onParticleBirth(offset, position, direction, transform) {
+        var worldRotation = transform.worldRotationQuaternion;
+        var birthPos = this._eventPos;
+        engineMath.Vector3.transformByQuat(position, worldRotation, birthPos);
+        birthPos.add(transform.worldPosition);
+        // Birth emission direction is known directly; Death reads it back from the feedback buffer
+        var worldDirection = this._eventDir;
+        engineMath.Vector3.transformByQuat(direction, worldRotation, worldDirection);
+        var parentColor = this._eventColor;
+        var parentSize = this._eventSize;
+        var parentRotation = this._eventRotation;
+        this._evaluateOverLifetime(offset, 0, parentColor, parentSize, parentRotation);
+        this.subEmitters._dispatchEvent(ParticleSubEmitterType.Birth, birthPos, parentColor, parentSize, parentRotation, worldDirection);
+    };
+    /**
+   * @internal
+   */ _proto._emitFromSubEmitter = function _emitFromSubEmitter(count, worldPosition, inheritColor, inheritSize, inheritRotation, worldDirection) {
+        if (count <= 0) return;
+        var main = this.main;
+        var notRetired = this._getNotRetiredParticleCount();
+        var available = main.maxParticles - notRetired;
+        if (available <= 0) return;
+        if (count > available) count = available;
+        var transform = this._renderer.entity.transform;
+        var emitterWorldPosition = transform.worldPosition, emitterWorldRotation = transform.worldRotationQuaternion;
+        // Convert event world position into local emission space for a_ShapePos
+        var localPos = this._emitLocalPos;
+        engineMath.Vector3.subtract(worldPosition, emitterWorldPosition, localPos);
+        var invRot = ParticleGenerator._tempQuat0;
+        engineMath.Quaternion.invert(emitterWorldRotation, invRot);
+        engineMath.Vector3.transformByQuat(localPos, invRot, localPos);
+        var direction = this._emitDirection;
+        if (worldDirection) {
+            engineMath.Vector3.transformByQuat(worldDirection, invRot, direction);
+            var len = Math.sqrt(direction.x * direction.x + direction.y * direction.y + direction.z * direction.z);
+            if (len > engineMath.MathUtil.zeroTolerance) {
+                direction.set(direction.x / len, direction.y / len, direction.z / len);
+            } else {
+                direction.set(0, 0, -1);
+            }
+        } else {
+            direction.set(0, 0, -1);
+        }
+        var playTime = this._playTime;
+        for(var i = 0; i < count; i++){
+            this._addNewParticle(localPos, direction, transform, playTime, undefined, inheritColor, inheritSize, inheritRotation);
+        }
     };
     _proto._addFeedbackParticle = function _addFeedbackParticle(index, shapePosition, direction, startSpeed, transform, emitWorldPosition) {
         var position;
@@ -38372,7 +39153,10 @@ __decorate([
         var engine = this._renderer.engine;
         var frameCount = engine.time.frameCount;
         var instanceVertices = this._instanceVertices;
-        while(this._firstActiveElement !== this._firstNewElement){
+        var hasDeathSlot = this.subEmitters._hasSubEmitterOfType(ParticleSubEmitterType.Death);
+        var firstNewElement = this._firstNewElement;
+        var feedbackLoaded = false;
+        while(this._firstActiveElement !== firstNewElement){
             var activeParticleOffset = this._firstActiveElement * ParticleBufferUtils.instanceVertexFloatStride;
             var activeParticleTimeOffset = activeParticleOffset + ParticleBufferUtils.timeOffset;
             var particleAge = this._playTime - instanceVertices[activeParticleTimeOffset];
@@ -38380,6 +39164,13 @@ __decorate([
             if (Math.fround(particleAge) < instanceVertices[activeParticleOffset + ParticleBufferUtils.startLifeTimeOffset]) {
                 break;
             }
+            if (hasDeathSlot) {
+                if (this._feedbackSimulator && !feedbackLoaded) {
+                    this._readbackFeedback(this._firstActiveElement, firstNewElement);
+                    feedbackLoaded = true;
+                }
+                this._onParticleDeath(activeParticleOffset);
+            }
             // Store frame count in time offset to free retired particle
             instanceVertices[activeParticleTimeOffset] = frameCount;
             if (++this._firstActiveElement >= this._currentParticleCount) {
@@ -38389,6 +39180,110 @@ __decorate([
             this._waitProcessRetiredElementCount++;
         }
     };
+    _proto._readbackFeedback = function _readbackFeedback(firstActiveElement, firstNewElement) {
+        var stride = ParticleBufferUtils.feedbackVertexStride;
+        var floatStride = stride / 4;
+        var totalFloatCount = this._currentParticleCount * floatStride;
+        var readback = this._feedbackReadback;
+        if (!readback || readback.length < totalFloatCount) {
+            readback = this._feedbackReadback = new Float32Array(totalFloatCount);
+        }
+        var buffer = this._feedbackSimulator.readBinding.buffer;
+        var wrapped = firstActiveElement >= firstNewElement;
+        var firstSegmentEnd = wrapped ? this._currentParticleCount : firstNewElement;
+        buffer.getData(readback, firstActiveElement * stride, firstActiveElement * floatStride, (firstSegmentEnd - firstActiveElement) * floatStride);
+        if (wrapped && firstNewElement > 0) {
+            buffer.getData(readback, 0, 0, firstNewElement * floatStride);
+        }
+    };
+    _proto._onParticleDeath = function _onParticleDeath(particleOffset) {
+        var instanceVertices = this._instanceVertices;
+        var transform = this._renderer.entity.transform;
+        var simSpaceLocal = this.main.simulationSpace === ParticleSimulationSpace.Local;
+        var worldRotation = transform.worldRotationQuaternion;
+        var ringIndex = particleOffset / ParticleBufferUtils.instanceVertexFloatStride;
+        var feedbackData = this._feedbackReadback;
+        var feedbackOffset = ringIndex * ParticleBufferUtils.feedbackVertexStride / 4;
+        var local = this._eventPos;
+        local.set(feedbackData[feedbackOffset], feedbackData[feedbackOffset + 1], feedbackData[feedbackOffset + 2]);
+        if (simSpaceLocal) {
+            engineMath.Vector3.transformByQuat(local, worldRotation, local);
+            local.add(transform.worldPosition);
+        }
+        var worldDirection = this._eventDir;
+        worldDirection.set(feedbackData[feedbackOffset + 3], feedbackData[feedbackOffset + 4], feedbackData[feedbackOffset + 5]);
+        if (simSpaceLocal) {
+            engineMath.Vector3.transformByQuat(worldDirection, worldRotation, worldDirection);
+        } else {
+            var spawnRotation = ParticleGenerator._tempQuat0;
+            spawnRotation.set(instanceVertices[particleOffset + 30], instanceVertices[particleOffset + 31], instanceVertices[particleOffset + 32], instanceVertices[particleOffset + 33]);
+            engineMath.Vector3.transformByQuat(worldDirection, spawnRotation, worldDirection);
+        }
+        // Evaluate at the parent's normalizedAge so children inherit its visible appearance at death.
+        var lifetime = instanceVertices[particleOffset + 3];
+        var bornTime = instanceVertices[particleOffset + 7];
+        var parentColor = this._eventColor;
+        var parentSize = this._eventSize;
+        var parentRotation = this._eventRotation;
+        var normalizedAge = Math.min(Math.max((this._playTime - bornTime) / lifetime, 0), 1);
+        this._evaluateOverLifetime(particleOffset, normalizedAge, parentColor, parentSize, parentRotation);
+        this.subEmitters._dispatchEvent(ParticleSubEmitterType.Death, local, parentColor, parentSize, parentRotation, worldDirection);
+    };
+    _proto._evaluateOverLifetime = function _evaluateOverLifetime(particleOffset, normalizedAge, parentColor, parentSize, parentRotation) {
+        var instanceVertices = this._instanceVertices;
+        var r = instanceVertices[particleOffset + 8];
+        var g = instanceVertices[particleOffset + 9];
+        var b = instanceVertices[particleOffset + 10];
+        var a = instanceVertices[particleOffset + 11];
+        var col = this.colorOverLifetime;
+        if (col.enabled) {
+            var colorFactor = ParticleGenerator._tempColor;
+            col.color.evaluate(normalizedAge, instanceVertices[particleOffset + 20], colorFactor);
+            r *= colorFactor.r;
+            g *= colorFactor.g;
+            b *= colorFactor.b;
+            a *= colorFactor.a;
+        }
+        parentColor.set(r, g, b, a);
+        var sx = instanceVertices[particleOffset + 12];
+        var sy = instanceVertices[particleOffset + 13];
+        var sz = instanceVertices[particleOffset + 14];
+        var sol = this.sizeOverLifetime;
+        // SOL only contributes in Curve / TwoCurves modes (shader gates on RENDERER_SOL_CURVE_MODE)
+        if (sol.enabled && (sol.sizeX.mode === ParticleCurveMode.Curve || sol.sizeX.mode === ParticleCurveMode.TwoCurves)) {
+            var sizeRand = instanceVertices[particleOffset + 21];
+            if (sol.separateAxes) {
+                sx *= sol.sizeX.evaluate(normalizedAge, sizeRand);
+                sy *= sol.sizeY.evaluate(normalizedAge, sizeRand);
+                sz *= sol.sizeZ.evaluate(normalizedAge, sizeRand);
+            } else {
+                var factor = sol.sizeX.evaluate(normalizedAge, sizeRand);
+                sx *= factor;
+                sy *= factor;
+                sz *= factor;
+            }
+        }
+        parentSize.set(sx, sy, sz);
+        var rx = instanceVertices[particleOffset + 15];
+        var ry = instanceVertices[particleOffset + 16];
+        var rz = instanceVertices[particleOffset + 17];
+        var rol = this.rotationOverLifetime;
+        if (rol.enabled) {
+            var rotRand = instanceVertices[particleOffset + 22];
+            var lifetime = instanceVertices[particleOffset + 3];
+            var rolZ = rol.rotationZ._evaluateCumulative(normalizedAge, rotRand) * lifetime;
+            if (rol.separateAxes) {
+                rx += rol.rotationX._evaluateCumulative(normalizedAge, rotRand) * lifetime;
+                ry += rol.rotationY._evaluateCumulative(normalizedAge, rotRand) * lifetime;
+                rz += rolZ;
+            } else if (this.main.startRotation3D) {
+                rz += rolZ;
+            } else {
+                rx += rolZ; // 2D rotation: shader stores the Z angle in a_StartRotation0.x
+            }
+        }
+        parentRotation.set(rx, ry, rz);
+    };
     _proto._freeRetiredParticles = function _freeRetiredParticles() {
         var frameCount = this._renderer.engine.time.frameCount;
         while(this._firstRetiredElement !== this._firstActiveElement){
@@ -38532,7 +39427,7 @@ __decorate([
         max.set(Math.max(max.x, boundsArray[offset + 3]), Math.max(max.y, boundsArray[offset + 4]), Math.max(max.z, boundsArray[offset + 5]));
     };
     _proto._calculateTransformedBounds = function _calculateTransformedBounds(maxLifetime, origin, out) {
-        var velMinMaxX = ParticleGenerator._tempVector20, velMinMaxY = ParticleGenerator._tempVector21, velMinMaxZ = ParticleGenerator._tempVector22, worldOffsetMin = ParticleGenerator._tempVector30, worldOffsetMax = ParticleGenerator._tempVector31, rotateMat = ParticleGenerator._tempMat;
+        var velMinMaxX = ParticleGenerator._tempVector20, velMinMaxY = ParticleGenerator._tempVector21, velMinMaxZ = ParticleGenerator._tempVector22, worldOffsetMin = ParticleGenerator._tempVector30, worldOffsetMax = ParticleGenerator._tempVector31, noiseBoundsExtents = ParticleGenerator._tempVector32, rotateMat = ParticleGenerator._tempMat;
         worldOffsetMin.set(0, 0, 0);
         worldOffsetMax.set(0, 0, 0);
         var transform = this._renderer.entity.transform;
@@ -38575,27 +39470,89 @@ __decorate([
                 worldOffsetMax.set(worldOffsetMax.x + forceMinMaxX.y, worldOffsetMax.y + forceMinMaxY.y, worldOffsetMax.z + forceMinMaxZ.y);
             }
         }
-        out.transform(rotateMat);
-        min.add(worldOffsetMin);
-        max.add(worldOffsetMax);
-        // Noise module impact: noise output is normalized to [-1, 1],
-        // max displacement = |strength_max|
         var noise = this.noise;
-        if (noise.enabled) {
-            var noiseMaxX, noiseMaxY, noiseMaxZ;
-            if (noise.separateAxes) {
-                noiseMaxX = Math.abs(noise.strengthX._getMax());
-                noiseMaxY = Math.abs(noise.strengthY._getMax());
-                noiseMaxZ = Math.abs(noise.strengthZ._getMax());
-            } else {
-                noiseMaxX = noiseMaxY = noiseMaxZ = Math.abs(noise.strengthX._getMax());
+        this._getNoiseBoundsExtents(maxLifetime, noiseBoundsExtents);
+        var needTransformFeedback = velocityOverLifetime._needTransformFeedback();
+        var orbitalActive = needTransformFeedback && velocityOverLifetime._isOrbitalActive();
+        if (needTransformFeedback) {
+            var centerOffset = velocityOverLifetime.centerOffset;
+            var radialReach = 0;
+            if (velocityOverLifetime._isRadialActive()) {
+                this._getExtremeValueFromZero(velocityOverLifetime.radial, velMinMaxX);
+                radialReach = Math.max(Math.abs(velMinMaxX.x), Math.abs(velMinMaxX.y)) * maxLifetime;
+            }
+            if (orbitalActive) {
+                var dx = Math.max(Math.abs(min.x - centerOffset.x), Math.abs(max.x - centerOffset.x));
+                var dy = Math.max(Math.abs(min.y - centerOffset.y), Math.abs(max.y - centerOffset.y));
+                var dz = Math.max(Math.abs(min.z - centerOffset.z), Math.abs(max.z - centerOffset.z));
+                var worldReach = this._getRangeReach(worldOffsetMin, worldOffsetMax);
+                var noiseReach = this._getVectorReach(noiseBoundsExtents);
+                var gravityReach = this._getGravityBoundsReach(maxLifetime);
+                var reach = Math.sqrt(dx * dx + dy * dy + dz * dz) + worldReach + noiseReach + gravityReach + radialReach;
+                min.set(Math.min(min.x, centerOffset.x - reach), Math.min(min.y, centerOffset.y - reach), Math.min(min.z, centerOffset.z - reach));
+                max.set(Math.max(max.x, centerOffset.x + reach), Math.max(max.y, centerOffset.y + reach), Math.max(max.z, centerOffset.z + reach));
+            } else if (radialReach > 0) {
+                min.set(min.x - radialReach, min.y - radialReach, min.z - radialReach);
+                max.set(max.x + radialReach, max.y + radialReach, max.z + radialReach);
+            }
+        }
+        out.transform(rotateMat);
+        if (!orbitalActive) {
+            min.add(worldOffsetMin);
+            max.add(worldOffsetMax);
+            if (noise.enabled) {
+                min.set(min.x - noiseBoundsExtents.x, min.y - noiseBoundsExtents.y, min.z - noiseBoundsExtents.z);
+                max.set(max.x + noiseBoundsExtents.x, max.y + noiseBoundsExtents.y, max.z + noiseBoundsExtents.z);
             }
-            min.set(min.x - noiseMaxX, min.y - noiseMaxY, min.z - noiseMaxZ);
-            max.set(max.x + noiseMaxX, max.y + noiseMaxY, max.z + noiseMaxZ);
         }
         min.add(worldPosition);
         max.add(worldPosition);
     };
+    _proto._useOrbitalBounds = function _useOrbitalBounds() {
+        var velocityOverLifetime = this.velocityOverLifetime;
+        return velocityOverLifetime._needTransformFeedback() && velocityOverLifetime._isOrbitalActive();
+    };
+    _proto._getNoiseBoundsExtents = function _getNoiseBoundsExtents(maxLifetime, out) {
+        var noise = this.noise;
+        if (!noise.enabled) {
+            out.set(0, 0, 0);
+            return;
+        }
+        var noiseMaxX, noiseMaxY, noiseMaxZ;
+        if (noise.separateAxes) {
+            noiseMaxX = this._getCurveMagnitudeFromZero(noise.strengthX);
+            noiseMaxY = this._getCurveMagnitudeFromZero(noise.strengthY);
+            noiseMaxZ = this._getCurveMagnitudeFromZero(noise.strengthZ);
+        } else {
+            noiseMaxX = noiseMaxY = noiseMaxZ = this._getCurveMagnitudeFromZero(noise.strengthX);
+        }
+        out.set(noiseMaxX * maxLifetime, noiseMaxY * maxLifetime, noiseMaxZ * maxLifetime);
+    };
+    _proto._getGravityBoundsReach = function _getGravityBoundsReach(maxLifetime) {
+        var modifierMinMax = ParticleGenerator._tempVector20;
+        this._getExtremeValueFromZero(this.main.gravityModifier, modifierMinMax);
+        var coefficient = 0.5 * maxLifetime * maxLifetime;
+        var minGravityEffect = modifierMinMax.x * coefficient;
+        var maxGravityEffect = modifierMinMax.y * coefficient;
+        var _this__renderer_scene_physics_gravity = this._renderer.scene.physics.gravity, x = _this__renderer_scene_physics_gravity.x, y = _this__renderer_scene_physics_gravity.y, z = _this__renderer_scene_physics_gravity.z;
+        var gravityBoundsExtents = ParticleGenerator._tempVector33;
+        gravityBoundsExtents.set(Math.max(Math.abs(x * minGravityEffect), Math.abs(x * maxGravityEffect)), Math.max(Math.abs(y * minGravityEffect), Math.abs(y * maxGravityEffect)), Math.max(Math.abs(z * minGravityEffect), Math.abs(z * maxGravityEffect)));
+        return this._getVectorReach(gravityBoundsExtents);
+    };
+    _proto._getRangeReach = function _getRangeReach(min, max) {
+        var x = Math.max(Math.abs(min.x), Math.abs(max.x));
+        var y = Math.max(Math.abs(min.y), Math.abs(max.y));
+        var z = Math.max(Math.abs(min.z), Math.abs(max.z));
+        return Math.sqrt(x * x + y * y + z * z);
+    };
+    _proto._getVectorReach = function _getVectorReach(value) {
+        return Math.sqrt(value.x * value.x + value.y * value.y + value.z * value.z);
+    };
+    _proto._getCurveMagnitudeFromZero = function _getCurveMagnitudeFromZero(curve) {
+        var minMax = ParticleGenerator._tempVector20;
+        this._getExtremeValueFromZero(curve, minMax);
+        return Math.max(Math.abs(minMax.x), Math.abs(minMax.y));
+    };
     _proto._addGravityToBounds = function _addGravityToBounds(maxLifetime, origin, out) {
         var originMin = origin.min, originMax = origin.max;
         var modifierMinMax = ParticleGenerator._tempVector20;
@@ -38657,8 +39614,10 @@ ParticleGenerator._tempVector22 = new engineMath.Vector2();
 ParticleGenerator._tempVector30 = new engineMath.Vector3();
 ParticleGenerator._tempVector31 = new engineMath.Vector3();
 ParticleGenerator._tempVector32 = new engineMath.Vector3();
+ParticleGenerator._tempVector33 = new engineMath.Vector3();
 ParticleGenerator._tempMat = new engineMath.Matrix();
-ParticleGenerator._tempColor0 = new engineMath.Color();
+ParticleGenerator._tempColor = new engineMath.Color();
+ParticleGenerator._tempQuat0 = new engineMath.Quaternion();
 ParticleGenerator._tempParticleRenderers = new Array();
 ParticleGenerator._particleIncreaseCount = 128;
 ParticleGenerator._transformedBoundsIncreaseCount = 16;
@@ -38693,6 +39652,9 @@ __decorate([
 __decorate([
     deepClone
 ], ParticleGenerator.prototype, "noise", void 0);
+__decorate([
+    deepClone
+], ParticleGenerator.prototype, "subEmitters", void 0);
 __decorate([
     deepClone
 ], ParticleGenerator.prototype, "customData", void 0);
@@ -38732,6 +39694,9 @@ __decorate([
 __decorate([
     ignoreClone
 ], ParticleGenerator.prototype, "_feedbackBindingIndex", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_feedbackReadback", void 0);
 __decorate([
     ignoreClone
 ], ParticleGenerator.prototype, "_isPlaying", void 0);
@@ -38762,6 +39727,27 @@ __decorate([
 __decorate([
     ignoreClone
 ], ParticleGenerator.prototype, "_playStartDelay", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_eventPos", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_eventColor", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_eventSize", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_eventRotation", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_eventDir", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_emitLocalPos", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_emitDirection", void 0);
 
 /**
  * Base material for visual effects like particles and trails.
@@ -40466,7 +41452,14 @@ var cacheDir = new engineMath.Vector3();
    * Suspend the audio context.
    * @returns A promise that resolves when the audio context is suspended
    */ AudioManager.suspend = function suspend() {
-        return AudioManager.getContext().suspend();
+        // No context means nothing is playing: suspending is a no-op and must NOT flag a caller-suspend
+        // (a ghost flag would later block foreground recovery), and don't create a cold context just to suspend
+        var context = AudioManager._context;
+        if (!context) {
+            return Promise.resolve();
+        }
+        AudioManager._suspendedByCaller = true;
+        return context.suspend();
     };
     /**
    * Resume the audio context.
@@ -40474,6 +41467,7 @@ var cacheDir = new engineMath.Vector3();
    * @returns A promise that resolves when the audio context is resumed
    */ AudioManager.resume = function resume() {
         var _AudioManager;
+        AudioManager._suspendedByCaller = false;
         var __resumePromise;
         return (__resumePromise = (_AudioManager = AudioManager)._resumePromise) != null ? __resumePromise : _AudioManager._resumePromise = AudioManager.getContext().resume().then(function() {
             AudioManager._needsUserGestureResume = false;
@@ -40488,7 +41482,9 @@ var cacheDir = new engineMath.Vector3();
         if (!context) {
             AudioManager._context = context = new window.AudioContext();
             document.addEventListener("visibilitychange", AudioManager._onVisibilityChange);
-            // iOS Safari requires user gesture to resume AudioContext
+            // iOS Safari bfcache restore fires pageshow (persisted) but NOT visibilitychange, so recover here too
+            window.addEventListener("pageshow", AudioManager._onPageShow);
+            // iOS Safari requires a user gesture to resume the AudioContext
             document.addEventListener("touchstart", AudioManager._resumeAfterInterruption, {
                 passive: true
             });
@@ -40516,27 +41512,62 @@ var cacheDir = new engineMath.Vector3();
         return AudioManager.getContext().state === "running";
     };
     AudioManager._onVisibilityChange = function _onVisibilityChange() {
-        if (!document.hidden && AudioManager._playingCount > 0 && !AudioManager.isAudioContextRunning()) {
-            // 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
-            AudioManager.suspend();
-            AudioManager._needsUserGestureResume = true;
+        if (document.hidden) {
+            var // Desktop/Android don't auto-suspend a running WebAudio context when backgrounded (only iOS does),
+            // so suspend here to stop audio in the background; only if a context already exists (don't create one)
+            _AudioManager__context;
+            (_AudioManager__context = AudioManager._context) == null ? void 0 : _AudioManager__context.suspend().catch(function() {});
+        } else {
+            AudioManager._recoverPlaybackContext();
+        }
+    };
+    AudioManager._recoverPlaybackContext = function _recoverPlaybackContext() {
+        // Returning to foreground with a non-running context (and not a deliberate pause): iOS leaves it
+        // "interrupted", which cannot be resumed directly; suspend() first transitions it to "suspended",
+        // then resume() restarts the pipeline https://bugs.webkit.org/show_bug.cgi?id=263627
+        // _recovering guards re-entry: a bfcache restore fires both visibilitychange and pageshow
+        if (AudioManager._recovering || document.hidden || AudioManager._suspendedByCaller || AudioManager._playingCount <= 0 || AudioManager.isAudioContextRunning()) {
+            return;
+        }
+        AudioManager._recovering = true;
+        AudioManager._needsUserGestureResume = true; // fallback if the auto-resume below is rejected
+        var context = AudioManager.getContext();
+        context.suspend().catch(function() {});
+        // 100ms empirical delay (resume too soon after suspend is unreliable on iOS); _recovering is cleared
+        // on the timer rather than off a promise because iOS may never settle suspend/resume in interrupted
+        setTimeout(function() {
+            AudioManager._recovering = false;
+            if (document.hidden || AudioManager._suspendedByCaller) {
+                return;
+            }
+            // Go through AudioManager.resume() so _resumePromise coalesces any gesture-resume racing us during
+            // the slow iOS interrupted->running transition; a bare context.resume() here wouldn't dedupe
+            AudioManager.resume().catch(function() {});
+        }, 100);
+    };
+    AudioManager._onPageShow = function _onPageShow(event) {
+        // iOS Safari bfcache restore (persisted) needs recovery; a normal load has no suspended context
+        if (event.persisted) {
+            AudioManager._recoverPlaybackContext();
         }
     };
     AudioManager._resumeAfterInterruption = function _resumeAfterInterruption() {
-        if (AudioManager._needsUserGestureResume) {
-            AudioManager.resume().catch(function(e) {
-                console.warn("Failed to resume AudioContext:", e);
-            });
+        // iOS Safari gesture fallback for when auto-resume is blocked.
+        // _recovering: don't bypass the 100ms delay (would resume on a still-interrupted context)
+        if (AudioManager._recovering || AudioManager._suspendedByCaller || !AudioManager._needsUserGestureResume) {
+            return;
         }
+        AudioManager.resume().catch(function(e) {
+            console.warn("Failed to resume AudioContext:", e);
+        });
     };
     return AudioManager;
 }();
 /** @internal */ AudioManager._playingCount = 0;
 AudioManager._resumePromise = null;
 AudioManager._needsUserGestureResume = false;
+AudioManager._suspendedByCaller = false;
+AudioManager._recovering = false;
 
 /**
  * Audio Source Component.
@@ -40546,8 +41577,6 @@ AudioManager._needsUserGestureResume = false;
         var _this;
         _this = Component.call(this, entity) || this, /** If set to true, the audio component automatically begins to play on startup. */ _this.playOnEnabled = true, _this._isPlaying = false, _this._pendingPlay = false, _this._sourceNode = null, _this._pausedTime = -1, _this._playTime = -1, _this._volume = 1, _this._lastVolume = 1, _this._playbackRate = 1, _this._loop = false;
         _this._onPlayEnd = _this._onPlayEnd.bind(_this);
-        _this._gainNode = AudioManager.getContext().createGain();
-        _this._gainNode.connect(AudioManager.getGainNode());
         return _this;
     }
     var _proto = AudioSource.prototype;
@@ -40559,6 +41588,10 @@ AudioManager._needsUserGestureResume = false;
         if (!((_this__clip = this._clip) == null ? void 0 : _this__clip._getAudioSource()) || this._isPlaying || this._pendingPlay) {
             return;
         }
+        // Hidden page: don't start (would leak a sound) and don't pend (would replay out of sync) -> drop
+        if (document.hidden) {
+            return;
+        }
         if (AudioManager.isAudioContextRunning()) {
             this._startPlayback();
         } else {
@@ -40571,8 +41604,8 @@ AudioManager._needsUserGestureResume = false;
                     return;
                 }
                 _this._pendingPlay = false;
-                // Check if still valid to play after async resume
-                if (_this._destroyed || !_this.enabled || !_this._clip) {
+                // Check if still valid to play after async resume (page may have been hidden meanwhile)
+                if (_this._destroyed || !_this.enabled || !_this._clip || document.hidden) {
                     return;
                 }
                 _this._startPlayback();
@@ -40589,10 +41622,11 @@ AudioManager._needsUserGestureResume = false;
         if (this._isPlaying) {
             this._clearSourceNode();
             this._isPlaying = false;
-            this._pausedTime = -1;
-            this._playTime = -1;
             AudioManager._playingCount--;
         }
+        // stop() always resets to the start, including from a paused state (where _isPlaying is already false)
+        this._pausedTime = -1;
+        this._playTime = -1;
     };
     /**
    * Pauses playing the clip.
@@ -40610,7 +41644,7 @@ AudioManager._needsUserGestureResume = false;
    */ _proto._cloneTo = function _cloneTo(target) {
         var _target__clip;
         (_target__clip = target._clip) == null ? void 0 : _target__clip._addReferCount(1);
-        target._gainNode.gain.setValueAtTime(target._volume, AudioManager.getContext().currentTime);
+    // _volume is field-cloned; its gain node is applied lazily on first play
     };
     /**
    * @internal
@@ -40632,6 +41666,15 @@ AudioManager._needsUserGestureResume = false;
     _proto._onPlayEnd = function _onPlayEnd() {
         this.stop();
     };
+    _proto._ensureGainNode = function _ensureGainNode() {
+        var gainNode = this._gainNode;
+        if (!gainNode) {
+            this._gainNode = gainNode = AudioManager.getContext().createGain();
+            gainNode.connect(AudioManager.getGainNode());
+            gainNode.gain.setValueAtTime(this._volume, AudioManager.getContext().currentTime);
+        }
+        return gainNode;
+    };
     _proto._startPlayback = function _startPlayback() {
         var startTime = this._pausedTime > 0 ? this._pausedTime - this._playTime : 0;
         this._initSourceNode(startTime);
@@ -40643,13 +41686,17 @@ AudioManager._needsUserGestureResume = false;
     _proto._initSourceNode = function _initSourceNode(startTime) {
         var context = AudioManager.getContext();
         var sourceNode = context.createBufferSource();
-        sourceNode.buffer = this._clip._getAudioSource();
+        var buffer = this._clip._getAudioSource();
+        sourceNode.buffer = buffer;
         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.connect(this._ensureGainNode());
+        // startTime is total elapsed time; for a looping clip wrap it into the buffer to keep the loop phase
+        // (start()'s offset clamps past the end, it does not wrap)
+        var offset = this._loop && buffer.duration > 0 ? startTime % buffer.duration : startTime;
+        sourceNode.start(0, offset);
     };
     _proto._clearSourceNode = function _clearSourceNode() {
         this._sourceNode.stop();
@@ -40692,9 +41739,11 @@ AudioManager._needsUserGestureResume = false;
                 return this._volume;
             },
             set: function set(value) {
+                var // No node yet -> _ensureGainNode() applies _volume on first play
+                _this__gainNode;
                 value = Math.min(Math.max(0, value), 1.0);
                 this._volume = value;
-                this._gainNode.gain.setValueAtTime(value, AudioManager.getContext().currentTime);
+                (_this__gainNode = this._gainNode) == null ? void 0 : _this__gainNode.gain.setValueAtTime(value, AudioManager.getContext().currentTime);
             }
         },
         {
@@ -40806,6 +41855,7 @@ __decorate([
     Polyfill.registerPolyfill = function registerPolyfill() {
         Polyfill._registerMatchAll();
         Polyfill._registerAudioContext();
+        Polyfill._registerOfflineAudioContext();
         Polyfill._registerTextMetrics();
         Polyfill._registerPromiseFinally();
     };
@@ -40870,20 +41920,32 @@ __decorate([
         if (!window.AudioContext && window.webkitAudioContext) {
             Logger.info("Polyfill window.AudioContext");
             window.AudioContext = window.webkitAudioContext;
-            var originalDecodeAudioData = AudioContext.prototype.decodeAudioData;
-            AudioContext.prototype.decodeAudioData = function(arrayBuffer, successCallback, errorCallback) {
-                var _this = this;
-                return new Promise(function(resolve, reject) {
-                    originalDecodeAudioData.call(_this, arrayBuffer, function(buffer) {
-                        successCallback == null ? void 0 : successCallback(buffer);
-                        resolve(buffer);
-                    }, function(error) {
-                        errorCallback == null ? void 0 : errorCallback(error);
-                        reject(error);
-                    });
+            Polyfill._promisifyDecodeAudioData(AudioContext.prototype);
+        }
+    };
+    Polyfill._registerOfflineAudioContext = function _registerOfflineAudioContext() {
+        // iOS 14.0 and earlier expose only webkitOfflineAudioContext, with callback-form decodeAudioData
+        if (!window.OfflineAudioContext && window.webkitOfflineAudioContext) {
+            Logger.info("Polyfill window.OfflineAudioContext");
+            window.OfflineAudioContext = window.webkitOfflineAudioContext;
+            Polyfill._promisifyDecodeAudioData(OfflineAudioContext.prototype);
+        }
+    };
+    // Wrap the old callback-form decodeAudioData (on prefixed iOS contexts) into the modern Promise form
+    Polyfill._promisifyDecodeAudioData = function _promisifyDecodeAudioData(proto) {
+        var originalDecodeAudioData = proto.decodeAudioData;
+        proto.decodeAudioData = function(arrayBuffer, successCallback, errorCallback) {
+            var _this = this;
+            return new Promise(function(resolve, reject) {
+                originalDecodeAudioData.call(_this, arrayBuffer, function(buffer) {
+                    successCallback == null ? void 0 : successCallback(buffer);
+                    resolve(buffer);
+                }, function(error) {
+                    errorCallback == null ? void 0 : errorCallback(error);
+                    reject(error);
                 });
-            };
-        }
+            });
+        };
     };
     Polyfill._registerTextMetrics = function _registerTextMetrics() {
         // Based on the specific version of the engine implementation, when actualBoundingBoxLeft is not supported, width is used to represent the rendering width, and `textAlign` uses the default value `start` and direction is left to right.
@@ -41075,6 +42137,8 @@ exports.ParticleShapeArcMode = ParticleShapeArcMode;
 exports.ParticleShapeType = ParticleShapeType;
 exports.ParticleSimulationSpace = ParticleSimulationSpace;
 exports.ParticleStopMode = ParticleStopMode;
+exports.ParticleSubEmitterInheritProperty = ParticleSubEmitterInheritProperty;
+exports.ParticleSubEmitterType = ParticleSubEmitterType;
 exports.PhysicsMaterial = PhysicsMaterial;
 exports.PhysicsMaterialCombineMode = PhysicsMaterialCombineMode;
 exports.PhysicsScene = PhysicsScene;
@@ -41164,6 +42228,8 @@ exports.SpriteTileMode = SpriteTileMode;
 exports.StateMachineScript = StateMachineScript;
 exports.StaticCollider = StaticCollider;
 exports.StencilOperation = StencilOperation;
+exports.SubEmitter = SubEmitter;
+exports.SubEmittersModule = SubEmittersModule;
 exports.SubFont = SubFont;
 exports.SubMesh = SubMesh;
 exports.SubPrimitive = SubPrimitive;