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

package/dist/main.js

@@ -35139,30 +35139,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 = engineMath.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, [
         {
@@ -35813,9 +35831,9 @@ __decorate([
 /**
  * Control how Particle Generator apply transform scale.
  */ var ParticleScaleMode = /*#__PURE__*/ function(ParticleScaleMode) {
-    /** Scale the Particle Generator using the entire transform hierarchy. */ ParticleScaleMode[ParticleScaleMode["Hierarchy"] = 0] = "Hierarchy";
-    /** Scale the Particle Generator using only its own transform scale. (Ignores parent scale). */ ParticleScaleMode[ParticleScaleMode["Local"] = 1] = "Local";
-    /** Only apply transform scale to the shape component, which controls where particles are spawned, but does not affect their size or movement. */ ParticleScaleMode[ParticleScaleMode["World"] = 2] = "World";
+    /** Scale the Particle Generator using the world scale, including all parent transforms. */ ParticleScaleMode[ParticleScaleMode["World"] = 0] = "World";
+    /** Scale the Particle Generator using only its own transform scale, ignoring parent scale. */ ParticleScaleMode[ParticleScaleMode["Local"] = 1] = "Local";
+    /** Scale only the emitter shape positions; particle size and movement are unaffected. */ ParticleScaleMode[ParticleScaleMode["Shape"] = 2] = "Shape";
     return ParticleScaleMode;
 }({});
 
@@ -35867,8 +35885,8 @@ var MainModule = /*#__PURE__*/ function() {
    */ _proto._getPositionScale = function _getPositionScale() {
         var transform = this._generator._renderer.entity.transform;
         switch(this.scalingMode){
-            case ParticleScaleMode.Hierarchy:
             case ParticleScaleMode.World:
+            case ParticleScaleMode.Shape:
                 return transform.lossyWorldScale;
             case ParticleScaleMode.Local:
                 return transform.scale;
@@ -35892,7 +35910,7 @@ var MainModule = /*#__PURE__*/ function() {
                 throw new Error("ParticleRenderer: SimulationSpace value is invalid.");
         }
         switch(this.scalingMode){
-            case ParticleScaleMode.Hierarchy:
+            case ParticleScaleMode.World:
                 var scale = transform.lossyWorldScale;
                 shaderData.setVector3(MainModule._positionScale, scale);
                 shaderData.setVector3(MainModule._sizeScale, scale);
@@ -35902,7 +35920,7 @@ var MainModule = /*#__PURE__*/ function() {
                 shaderData.setVector3(MainModule._positionScale, scale);
                 shaderData.setVector3(MainModule._sizeScale, scale);
                 break;
-            case ParticleScaleMode.World:
+            case ParticleScaleMode.Shape:
                 shaderData.setVector3(MainModule._positionScale, transform.lossyWorldScale);
                 shaderData.setVector3(MainModule._sizeScale, MainModule._vector3One);
                 break;
@@ -38309,10 +38327,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);