@onerjs/core 8.48.9 → 8.49.2

package/Particles/gpuParticleSystem.js

@@ -286,6 +286,28 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._stopped = false;
         this._actualFrame = 0;
         this._preWarmDone = false;
+        // Reset emit gradient so it acts the same on every start
+        if (this._emitRateGradients) {
+            if (this._emitRateGradients.length > 0) {
+                this._currentEmitRateGradient = this._emitRateGradients[0];
+                this._currentEmitRate1 = this._currentEmitRateGradient.getFactor();
+                this._currentEmitRate2 = this._currentEmitRate1;
+            }
+            if (this._emitRateGradients.length > 1) {
+                this._currentEmitRate2 = this._emitRateGradients[1].getFactor();
+            }
+        }
+        // Reset start size gradient so it acts the same on every start
+        if (this._startSizeGradients) {
+            if (this._startSizeGradients.length > 0) {
+                this._currentStartSizeGradient = this._startSizeGradients[0];
+                this._currentStartSize1 = this._currentStartSizeGradient.getFactor();
+                this._currentStartSize2 = this._currentStartSize1;
+            }
+            if (this._startSizeGradients.length > 1) {
+                this._currentStartSize2 = this._startSizeGradients[1].getFactor();
+            }
+        }
         // Animations
         if (this.beginAnimationOnStart && this.animations && this.animations.length > 0 && this._scene) {
             this._scene.beginAnimation(this, this.beginAnimationFrom, this.beginAnimationTo, this.beginAnimationLoop);
@@ -584,35 +606,34 @@ export class GPUParticleSystem extends BaseParticleSystem {
         return this;
     }
     /**
-     * Not supported by GPUParticleSystem
-     * @returns the current particle system
-     */
-    addEmitRateGradient() {
-        // Do nothing as emit rate is not supported by GPUParticleSystem
-        return this;
-    }
-    /**
-     * Not supported by GPUParticleSystem
-     * @returns the current particle system
-     */
-    removeEmitRateGradient() {
-        // Do nothing as emit rate is not supported by GPUParticleSystem
-        return this;
-    }
-    /**
-     * Not supported by GPUParticleSystem
+     * Adds a new start size gradient (please note that this will only work if you set the targetStopDuration property)
+     * @param gradient defines the gradient to use (between 0 and 1)
+     * @param factor defines the start size factor to affect to the specified gradient
+     * @param factor2 defines an additional factor used to define a range ([factor, factor2]) with main value to pick the final value from
      * @returns the current particle system
      */
-    addStartSizeGradient() {
-        // Do nothing as start size is not supported by GPUParticleSystem
+    addStartSizeGradient(gradient, factor, factor2) {
+        if (!this._startSizeGradients) {
+            this._startSizeGradients = [];
+        }
+        const hadGradients = this._startSizeGradients.length > 0;
+        this._addFactorGradient(this._startSizeGradients, gradient, factor, factor2);
+        if (!hadGradients) {
+            this._resetEffect();
+        }
         return this;
     }
     /**
-     * Not supported by GPUParticleSystem
+     * Remove a specific start size gradient
+     * @param gradient defines the gradient to remove
      * @returns the current particle system
      */
-    removeStartSizeGradient() {
-        // Do nothing as start size is not supported by GPUParticleSystem
+    removeStartSizeGradient(gradient) {
+        const hadGradients = this._startSizeGradients && this._startSizeGradients.length > 0;
+        this._removeFactorGradient(this._startSizeGradients, gradient);
+        if (hadGradients && (!this._startSizeGradients || this._startSizeGradients.length === 0)) {
+            this._resetEffect();
+        }
         return this;
     }
     /**
@@ -683,19 +704,34 @@ export class GPUParticleSystem extends BaseParticleSystem {
         //Not supported by GPUParticleSystem
     }
     /**
-     * Not supported by GPUParticleSystem
+     * Adds a new life time gradient (please note that this will only work if you set the targetStopDuration property)
+     * @param gradient defines the gradient to use (between 0 and 1)
+     * @param factor defines the life time factor to affect to the specified gradient
+     * @param factor2 defines an additional factor used to define a range ([factor, factor2]) with main value to pick the final value from
      * @returns the current particle system
      */
-    addLifeTimeGradient() {
-        //Not supported by GPUParticleSystem
+    addLifeTimeGradient(gradient, factor, factor2) {
+        if (!this._lifeTimeGradients) {
+            this._lifeTimeGradients = [];
+        }
+        const hadGradients = this._lifeTimeGradients.length > 0;
+        this._addFactorGradient(this._lifeTimeGradients, gradient, factor, factor2);
+        if (!hadGradients) {
+            this._resetEffect();
+        }
         return this;
     }
     /**
-     * Not supported by GPUParticleSystem
+     * Remove a specific life time gradient
+     * @param gradient defines the gradient to remove
      * @returns the current particle system
      */
-    removeLifeTimeGradient() {
-        //Not supported by GPUParticleSystem
+    removeLifeTimeGradient(gradient) {
+        const hadGradients = this._lifeTimeGradients && this._lifeTimeGradients.length > 0;
+        this._removeFactorGradient(this._lifeTimeGradients, gradient);
+        if (hadGradients && (!this._lifeTimeGradients || this._lifeTimeGradients.length === 0)) {
+            this._resetEffect();
+        }
         return this;
     }
     /**
@@ -729,6 +765,18 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._actualFrame = 0;
         this._rawTextureWidth = 256;
         this._rebuildingAfterContextLost = false;
+        // Emit rate gradient caching (mirrors ThinParticleSystem)
+        this._currentEmitRateGradient = null;
+        this._currentEmitRate1 = 0;
+        this._currentEmitRate2 = 0;
+        // Start size gradient caching (mirrors ThinParticleSystem)
+        this._currentStartSizeGradient = null;
+        this._currentStartSize1 = 0;
+        this._currentStartSize2 = 0;
+        this._startSizeGradientFactor = 1.0;
+        // Life time gradient factor range for per-particle randomization in shader
+        this._lifeTimeGradientMin = 1.0;
+        this._lifeTimeGradientMax = 1.0;
         /**
          * Specifies if the particle system should be serialized
          */
@@ -1081,6 +1129,12 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._sourceBuffer = this._buffer0;
         this._targetBuffer = this._buffer1;
     }
+    /**
+     * Forces the update effect to be recreated on the next render.
+     */
+    _resetEffect() {
+        this._cachedUpdateDefines = "";
+    }
     /** @internal */
     _recreateUpdateEffect() {
         this._createColorGradientTexture();
@@ -1133,6 +1187,12 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (this._emitRateControl) {
             defines += "\n#define EMITRATECTRL";
         }
+        if (this._startSizeGradients && this._startSizeGradients.length > 0) {
+            defines += "\n#define STARTSIZEGRADIENTS";
+        }
+        if (this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
+            defines += "\n#define LIFETIMEGRADIENTS";
+        }
         if (this._platform.isUpdateBufferCreated() && this._cachedUpdateDefines === defines) {
             return this._platform.isUpdateBufferReady();
         }
@@ -1491,6 +1551,12 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 }
             }
         }
+        if (this._startSizeGradients && this._startSizeGradients.length > 0) {
+            this._updateBuffer.setFloat("startSizeGradientFactor", this._startSizeGradientFactor);
+        }
+        if (this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
+            this._updateBuffer.setFloat2("lifeTimeGradientRange", this._lifeTimeGradientMin, this._lifeTimeGradientMax);
+        }
         this._platform.updateParticleBuffer(this._targetIndex, this._targetBuffer, this._currentActiveCount);
         // Switch VAOs
         this._targetIndex++;
@@ -1535,6 +1601,48 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         // Get everything ready to render
         this._initialize();
+        // Compute effective emit rate, applying emit rate gradients if set
+        let effectiveEmitRate = this.emitRate;
+        if (this._emitRateGradients && this._emitRateGradients.length > 0 && this.targetStopDuration) {
+            const ratio = this._actualFrame / this.targetStopDuration;
+            GradientHelper.GetCurrentGradient(ratio, this._emitRateGradients, (currentGradient, nextGradient, scale) => {
+                if (currentGradient !== this._currentEmitRateGradient) {
+                    this._currentEmitRate1 = this._currentEmitRate2;
+                    this._currentEmitRate2 = nextGradient.getFactor();
+                    this._currentEmitRateGradient = currentGradient;
+                }
+                effectiveEmitRate = Lerp(this._currentEmitRate1, this._currentEmitRate2, scale);
+            });
+        }
+        // Compute start size and life time gradient factors for shader uniforms
+        if (this.targetStopDuration) {
+            const ratio = this._actualFrame / this.targetStopDuration;
+            if (this._startSizeGradients && this._startSizeGradients.length > 0) {
+                GradientHelper.GetCurrentGradient(ratio, this._startSizeGradients, (currentGradient, nextGradient, scale) => {
+                    if (currentGradient !== this._currentStartSizeGradient) {
+                        this._currentStartSize1 = this._currentStartSize2;
+                        this._currentStartSize2 = nextGradient.getFactor();
+                        this._currentStartSizeGradient = currentGradient;
+                    }
+                    this._startSizeGradientFactor = Lerp(this._currentStartSize1, this._currentStartSize2, scale);
+                });
+            }
+            else {
+                this._startSizeGradientFactor = 1.0;
+            }
+            if (this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
+                GradientHelper.GetCurrentGradient(ratio, this._lifeTimeGradients, (currentGradient, nextGradient, scale) => {
+                    const current = currentGradient;
+                    const next = nextGradient;
+                    this._lifeTimeGradientMin = Lerp(current.factor1, next.factor1, scale);
+                    this._lifeTimeGradientMax = Lerp(current.factor2 ?? current.factor1, next.factor2 ?? next.factor1, scale);
+                });
+            }
+            else {
+                this._lifeTimeGradientMin = 1.0;
+                this._lifeTimeGradientMax = 1.0;
+            }
+        }
         if (this._emitRateControl) {
             // Emit-rate-controlled mode: limits active particles to ~emitRate * maxLifeTime,
             // matching CPU particle behavior with circular buffer recycling.
@@ -1544,7 +1652,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 this.manualEmitCount = 0;
             }
             else if (!this._stopped) {
-                this._accumulatedCount += this.emitRate * this._timeDelta;
+                this._accumulatedCount += effectiveEmitRate * this._timeDelta;
             }
             // Convert accumulated fractional count into whole particles to emit this frame.
             // The fractional remainder carries over to the next frame.
@@ -1559,7 +1667,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
             // When emitRate is 0 but manualEmitCount is used, the rate-based steady state
             // would be 0, blocking buffer growth. Use newParticles as a floor so manual
             // emissions can always allocate slots.
-            const steadyStateCount = Math.min(Math.max(Math.ceil(this.emitRate * this.maxLifeTime), newParticles), this._maxActiveParticleCount);
+            const steadyStateCount = Math.min(Math.max(Math.ceil(effectiveEmitRate * this.maxLifeTime), newParticles), this._maxActiveParticleCount);
             // During ramp-up, grow the active buffer size by adding new slots.
             // Once _currentActiveCount reaches steadyStateCount, no new slots are added —
             // existing slots are recycled instead (handled by _emitIndex below).
@@ -1588,7 +1696,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 this.manualEmitCount = 0;
             }
             else {
-                this._accumulatedCount += this.emitRate * this._timeDelta;
+                this._accumulatedCount += effectiveEmitRate * this._timeDelta;
             }
             if (this._accumulatedCount >= 1) {
                 const intPart = this._accumulatedCount | 0;