@galacean/engine-core 2.0.0-alpha.29 → 2.0.0-alpha.30

package/dist/module.js

@@ -35135,30 +35135,48 @@ __decorate([
             }
             this._emitBySubBurst(middleTime, playTime, duration);
         } else {
-            this._emitBySubBurst(lastPlayTime, playTime, duration);
+            if (lastPlayTime < duration) {
+                this._emitBySubBurst(lastPlayTime, Math.min(playTime, duration), duration);
+            }
         }
     };
     _proto._emitBySubBurst = function _emitBySubBurst(lastPlayTime, playTime, duration) {
-        var generator = this._generator;
-        var rand = this._burstRand;
-        var bursts = this.bursts;
-        // Calculate the relative time of the burst
+        var _this = this, generator = _this._generator, rand = _this._burstRand, bursts = _this.bursts;
         var baseTime = Math.floor(lastPlayTime / duration) * duration;
         var startTime = lastPlayTime % duration;
         var endTime = startTime + (playTime - lastPlayTime);
+        var pendingIndex = -1;
         var index = this._currentBurstIndex;
         for(var n = bursts.length; index < n; index++){
             var burst = bursts[index];
             var burstTime = burst.time;
-            if (burstTime > endTime) {
-                break;
-            }
-            if (burstTime >= startTime) {
-                var count = burst.count.evaluate(undefined, rand.random());
-                generator._emit(baseTime + burstTime, count);
+            if (burstTime >= endTime) break;
+            var cycles = burst.cycles, repeatInterval = burst.repeatInterval;
+            if (cycles === 1) {
+                if (burstTime >= startTime) {
+                    generator._emit(baseTime + burstTime, burst.count.evaluate(undefined, rand.random()));
+                }
+            } else {
+                var maxCycles = cycles === Infinity ? Math.ceil((duration - burstTime) / repeatInterval) : cycles;
+                // Absorb float drift: (startTime - burstTime) / repeatInterval may land at cycle + 1e-15
+                // when it should be exactly cycle, and ceil would then skip ahead to cycle + 1.
+                var tolerance = MathUtil.zeroTolerance;
+                var lastCycle = Math.ceil((endTime - burstTime) / repeatInterval - tolerance) - 1;
+                var first = Math.max(0, Math.ceil((startTime - burstTime) / repeatInterval - tolerance));
+                var last = Math.min(maxCycles - 1, lastCycle);
+                for(var c = first; c <= last; c++){
+                    var effectiveTime = burstTime + c * repeatInterval;
+                    if (effectiveTime >= duration) break;
+                    generator._emit(baseTime + effectiveTime, burst.count.evaluate(undefined, rand.random()));
+                }
+                // `_currentBurstIndex` caches next frame's scan start, so only the earliest unfinished
+                // burst can be the entry point — skipping past it would drop its remaining cycles
+                if (pendingIndex < 0 && lastCycle < maxCycles - 1) {
+                    pendingIndex = index;
+                }
             }
         }
-        this._currentBurstIndex = index;
+        this._currentBurstIndex = pendingIndex >= 0 ? pendingIndex : index;
     };
     _create_class(EmissionModule, [
         {
@@ -38305,10 +38323,39 @@ __decorate([
 
 /**
  * A burst is a particle emission event, where a number of particles are all emitted at the same time
- */ var Burst = function Burst(time, count) {
-    this.time = time;
-    this.count = count;
-};
+ */ var Burst = /*#__PURE__*/ function() {
+    function Burst(time, count, cycles, repeatInterval) {
+        this.time = time;
+        this.count = count;
+        this._cycles = Math.max(cycles != null ? cycles : 1, 1);
+        this._repeatInterval = Math.max(repeatInterval != null ? repeatInterval : 0.01, 0.01);
+    }
+    _create_class(Burst, [
+        {
+            key: "cycles",
+            get: /**
+   * Number of times to repeat the burst.
+   */ function get() {
+                return this._cycles;
+            },
+            set: function set(value) {
+                this._cycles = Math.max(value, 1);
+            }
+        },
+        {
+            key: "repeatInterval",
+            get: /**
+   * Time interval between each repeated burst.
+   */ function get() {
+                return this._repeatInterval;
+            },
+            set: function set(value) {
+                this._repeatInterval = Math.max(value, 0.01);
+            }
+        }
+    ]);
+    return Burst;
+}();
 __decorate([
     deepClone
 ], Burst.prototype, "count", void 0);