@babylonjs/core 9.2.0 → 9.2.2

package/Particles/gpuParticleSystem.js

@@ -1,4 +1,4 @@
-import { FactorGradient, ColorGradient, GradientHelper } from "../Misc/gradients.js";
+import { ColorGradient, GradientHelper } from "../Misc/gradients.js";
 import { Observable } from "../Misc/observable.js";
 import { Vector3, Matrix, TmpVectors } from "../Maths/math.vector.js";
 import { Color4, TmpColors } from "../Maths/math.color.js";
@@ -6,6 +6,8 @@ import { Lerp } from "../Maths/math.scalar.functions.js";
 import { VertexBuffer, Buffer } from "../Buffers/buffer.js";
 import { BaseParticleSystem } from "./baseParticleSystem.js";
 import { ParticleSystem } from "./particleSystem.js";
+import { Attractor } from "./attractor.js";
+import { Logger } from "../Misc/logger.js";
 import { BoxParticleEmitter } from "../Particles/EmitterTypes/boxParticleEmitter.js";
 import { Scene } from "../scene.js";
 import { ImageProcessingConfiguration } from "../Materials/imageProcessingConfiguration.js";
@@ -28,6 +30,15 @@ import { CreateConeEmitter, CreateCylinderEmitter, CreateDirectedCylinderEmitter
  * @see https://www.babylonjs-playground.com/#PU4WYI#4
  */
 export class GPUParticleSystem extends BaseParticleSystem {
+    /**
+     * Whether the particle buffer needs to store the initial emission direction.
+     * True when particles are not billboarded (they orient by direction) or when
+     * using stretched-local billboard mode (stretches along initial direction).
+     * @internal
+     */
+    get _needsInitialDirection() {
+        return !this._isBillboardBased || this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED_LOCAL;
+    }
     /**
      * Gets a boolean indicating if the GPU particles can be rendered on current browser
      */
@@ -79,6 +90,17 @@ export class GPUParticleSystem extends BaseParticleSystem {
     set activeParticleCount(value) {
         this.maxActiveParticleCount = value;
     }
+    /**
+     * Add an attractor to the particle system. Attractors are used to change the direction of the particles in the system.
+     * @param attractor - The attractor to add to the particle system
+     */
+    addAttractor(attractor) {
+        if (this._attractors.length >= this.maxAttractors) {
+            Logger.Warn(`GPU particle system supports a maximum of ${this.maxAttractors} attractors. Ignoring additional attractor.`);
+            return;
+        }
+        super.addAttractor(attractor);
+    }
     /**
      * Creates a Point Emitter for the particle system (emits directly from the emitter position)
      * @param direction1 Particles are emitted between the direction1 and direction2 from within the box
@@ -273,6 +295,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);
@@ -430,23 +474,19 @@ export class GPUParticleSystem extends BaseParticleSystem {
             drawWrapper.drawContext?.reset();
         }
     }
-    _addFactorGradient(factorGradients, gradient, factor) {
-        const valueGradient = new FactorGradient(gradient, factor);
-        factorGradients.push(valueGradient);
-        this._releaseBuffers();
-    }
     /**
      * Adds a new size gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the 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
      */
-    addSizeGradient(gradient, factor) {
+    addSizeGradient(gradient, factor, factor2) {
         if (!this._sizeGradients) {
             this._sizeGradients = [];
         }
-        this._addFactorGradient(this._sizeGradients, gradient, factor);
-        this._refreshFactorGradient(this._sizeGradients, "_sizeGradientsTexture", true);
+        this._addFactorGradient(this._sizeGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._sizeGradients, "_sizeGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -460,21 +500,10 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._sizeGradientsTexture = null;
         return this;
     }
-    _refreshFactorGradient(factorGradients, textureName, reorder = false) {
+    _refreshFactorGradient(factorGradients, textureName) {
         if (!factorGradients) {
             return;
         }
-        if (reorder) {
-            factorGradients.sort((a, b) => {
-                if (a.gradient < b.gradient) {
-                    return -1;
-                }
-                else if (a.gradient > b.gradient) {
-                    return 1;
-                }
-                return 0;
-            });
-        }
         const that = this;
         if (that[textureName]) {
             that[textureName].dispose();
@@ -485,14 +514,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new angular speed gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the angular speed 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
      */
-    addAngularSpeedGradient(gradient, factor) {
+    addAngularSpeedGradient(gradient, factor, factor2) {
         if (!this._angularSpeedGradients) {
             this._angularSpeedGradients = [];
         }
-        this._addFactorGradient(this._angularSpeedGradients, gradient, factor);
-        this._refreshFactorGradient(this._angularSpeedGradients, "_angularSpeedGradientsTexture", true);
+        this._addFactorGradient(this._angularSpeedGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._angularSpeedGradients, "_angularSpeedGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -510,14 +540,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new velocity gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the velocity 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
      */
-    addVelocityGradient(gradient, factor) {
+    addVelocityGradient(gradient, factor, factor2) {
         if (!this._velocityGradients) {
             this._velocityGradients = [];
         }
-        this._addFactorGradient(this._velocityGradients, gradient, factor);
-        this._refreshFactorGradient(this._velocityGradients, "_velocityGradientsTexture", true);
+        this._addFactorGradient(this._velocityGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._velocityGradients, "_velocityGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -535,14 +566,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new limit velocity gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the limit velocity value 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
      */
-    addLimitVelocityGradient(gradient, factor) {
+    addLimitVelocityGradient(gradient, factor, factor2) {
         if (!this._limitVelocityGradients) {
             this._limitVelocityGradients = [];
         }
-        this._addFactorGradient(this._limitVelocityGradients, gradient, factor);
-        this._refreshFactorGradient(this._limitVelocityGradients, "_limitVelocityGradientsTexture", true);
+        this._addFactorGradient(this._limitVelocityGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._limitVelocityGradients, "_limitVelocityGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -560,14 +592,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * Adds a new drag gradient
      * @param gradient defines the gradient to use (between 0 and 1)
      * @param factor defines the drag value 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
      */
-    addDragGradient(gradient, factor) {
+    addDragGradient(gradient, factor, factor2) {
         if (!this._dragGradients) {
             this._dragGradients = [];
         }
-        this._addFactorGradient(this._dragGradients, gradient, factor);
-        this._refreshFactorGradient(this._dragGradients, "_dragGradientsTexture", true);
+        this._addFactorGradient(this._dragGradients, gradient, factor, factor2);
+        this._refreshFactorGradient(this._dragGradients, "_dragGradientsTexture");
         this._releaseBuffers();
         return this;
     }
@@ -582,35 +615,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;
     }
     /**
@@ -681,19 +713,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;
     }
     /**
@@ -727,6 +774,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
          */
@@ -817,6 +876,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._currentActiveCount = 0;
         this._isAnimationSheetEnabled = isAnimationSheetEnabled;
         this._emitRateControl = !!options.emitRateControl;
+        this.maxAttractors = options.maxAttractors ?? 8;
         this.particleEmitterType = new BoxParticleEmitter();
         // Random data
         const maxTextureSize = Math.min(this._engine.getCaps().maxTextureSize, fullOptions.randomTextureSize);
@@ -858,7 +918,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         renderVertexBuffers["life"] = renderBuffer.createVertexBuffer("life", offset, 1, this._attributesStrideSize, true);
         offset += 1;
         offset += 4; // seed
-        if (this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED) {
+        if (this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED || this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED_LOCAL) {
             renderVertexBuffers["direction"] = renderBuffer.createVertexBuffer("direction", offset, 3, this._attributesStrideSize, true);
         }
         offset += 3; // direction
@@ -875,7 +935,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
             renderVertexBuffers["color"] = renderBuffer.createVertexBuffer("color", offset, 4, this._attributesStrideSize, true);
             offset += 4;
         }
-        if (!this._isBillboardBased) {
+        if (this._needsInitialDirection) {
             renderVertexBuffers["initialDirection"] = renderBuffer.createVertexBuffer("initialDirection", offset, 3, this._attributesStrideSize, true);
             offset += 3;
             if (this._platform.alignDataInBuffer) {
@@ -931,7 +991,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 this._attributesStrideSize += 1;
             }
         }
-        if (!this.isBillboardBased) {
+        if (this._needsInitialDirection) {
             this._attributesStrideSize += 3;
             if (this._platform.alignDataInBuffer) {
                 this._attributesStrideSize += 1;
@@ -1013,7 +1073,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 data.push(0.0);
                 offset += 4;
             }
-            if (!this.isBillboardBased) {
+            if (this._needsInitialDirection) {
                 // initialDirection
                 data.push(0.0);
                 data.push(0.0);
@@ -1078,6 +1138,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();
@@ -1088,7 +1154,11 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._createDragGradientTexture();
         let defines = this.particleEmitterType ? this.particleEmitterType.getEffectDefines() : "";
         if (this._isBillboardBased) {
-            defines += "\n#define BILLBOARD";
+            // Stretched local needs initialDirection in the buffer, which requires !BILLBOARD in the update shader.
+            // The render shader still uses BILLBOARD — that's handled separately in fillDefines().
+            if (this.billboardMode !== ParticleSystem.BILLBOARDMODE_STRETCHED_LOCAL) {
+                defines += "\n#define BILLBOARD";
+            }
         }
         if (this._colorGradientsTexture) {
             defines += "\n#define COLORGRADIENTS";
@@ -1123,9 +1193,19 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (this.isLocal) {
             defines += "\n#define LOCAL";
         }
+        if (this._attractors.length > 0) {
+            defines += "\n#define ATTRACTORS";
+            defines += "\n#define MAX_ATTRACTORS " + this.maxAttractors;
+        }
         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();
         }
@@ -1165,7 +1245,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
     /**
      * @internal
      */
-    static _GetAttributeNamesOrOptions(hasColorGradients = false, isAnimationSheetEnabled = false, isBillboardBased = false, isBillboardStretched = false) {
+    static _GetAttributeNamesOrOptions(hasColorGradients = false, isAnimationSheetEnabled = false, isBillboardBased = false, isBillboardStretched = false, isBillboardStretchedLocal = false) {
         const attributeNamesOrOptions = [VertexBuffer.PositionKind, "age", "life", "size", "angle"];
         if (!hasColorGradients) {
             attributeNamesOrOptions.push(VertexBuffer.ColorKind);
@@ -1173,7 +1253,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (isAnimationSheetEnabled) {
             attributeNamesOrOptions.push("cellIndex");
         }
-        if (!isBillboardBased) {
+        if (!isBillboardBased || isBillboardStretchedLocal) {
             attributeNamesOrOptions.push("initialDirection");
         }
         if (isBillboardStretched) {
@@ -1231,6 +1311,10 @@ export class GPUParticleSystem extends BaseParticleSystem {
                 case ParticleSystem.BILLBOARDMODE_STRETCHED:
                     defines.push("#define BILLBOARDSTRETCHED");
                     break;
+                case ParticleSystem.BILLBOARDMODE_STRETCHED_LOCAL:
+                    defines.push("#define BILLBOARDSTRETCHED");
+                    defines.push("#define BILLBOARDSTRETCHED_LOCAL");
+                    break;
                 case ParticleSystem.BILLBOARDMODE_ALL:
                     defines.push("#define BILLBOARDMODE_ALL");
                     break;
@@ -1259,7 +1343,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
      * @param samplers Samplers array to fill
      */
     fillUniformsAttributesAndSamplerNames(uniforms, attributes, samplers) {
-        attributes.push(...GPUParticleSystem._GetAttributeNamesOrOptions(!!this._colorGradientsTexture, this._isAnimationSheetEnabled, this._isBillboardBased, this._isBillboardBased && this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED));
+        attributes.push(...GPUParticleSystem._GetAttributeNamesOrOptions(!!this._colorGradientsTexture, this._isAnimationSheetEnabled, this._isBillboardBased, this._isBillboardBased && (this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED || this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED_LOCAL), this.billboardMode === ParticleSystem.BILLBOARDMODE_STRETCHED_LOCAL));
         uniforms.push(...GPUParticleSystem._GetEffectCreationOptions(this._isAnimationSheetEnabled, this.useLogarithmicDepth, this.applyFog));
         samplers.push("diffuseSampler", "colorGradientSampler");
         if (this._imageProcessingConfiguration) {
@@ -1288,14 +1372,17 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (!factorGradients || !factorGradients.length || texture) {
             return;
         }
-        const data = new Float32Array(this._rawTextureWidth);
+        const data = new Float32Array(this._rawTextureWidth * 2);
         for (let x = 0; x < this._rawTextureWidth; x++) {
             const ratio = x / this._rawTextureWidth;
             GradientHelper.GetCurrentGradient(ratio, factorGradients, (currentGradient, nextGradient, scale) => {
-                data[x] = Lerp(currentGradient.factor1, nextGradient.factor1, scale);
+                const cg = currentGradient;
+                const ng = nextGradient;
+                data[x * 2] = Lerp(cg.factor1, ng.factor1, scale);
+                data[x * 2 + 1] = Lerp(cg.factor2 ?? cg.factor1, ng.factor2 ?? ng.factor1, scale);
             });
         }
-        this[textureName] = RawTexture.CreateRTexture(data, this._rawTextureWidth, 1, this._scene || this._engine, false, false, 1);
+        this[textureName] = new RawTexture(data, this._rawTextureWidth, 1, 7, this._scene || this._engine, false, false, 1, 1);
         this[textureName].name = textureName.substring(1);
     }
     _createSizeGradientTexture() {
@@ -1460,6 +1547,33 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (!this.isLocal) {
             this._updateBuffer.setMatrix("emitterWM", emitterWM);
         }
+        if (this._attractors.length > 0) {
+            this._updateBuffer.setInt("attractorCount", this._attractors.length);
+            // Compute inverse world matrix once for all attractors when in local space
+            let invWorld;
+            if (this.isLocal) {
+                invWorld = TmpVectors.Matrix[1];
+                emitterWM.invertToRef(invWorld);
+            }
+            for (let i = 0; i < this._attractors.length; i++) {
+                const attractor = this._attractors[i];
+                const name = "attractorPositionAndStrength[" + i + "]";
+                if (invWorld) {
+                    const localPos = TmpVectors.Vector3[0];
+                    Vector3.TransformCoordinatesToRef(attractor.position, invWorld, localPos);
+                    this._updateBuffer.setFloat4(name, localPos.x, localPos.y, localPos.z, attractor.strength);
+                }
+                else {
+                    this._updateBuffer.setFloat4(name, attractor.position.x, attractor.position.y, attractor.position.z, attractor.strength);
+                }
+            }
+        }
+        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++;
@@ -1504,6 +1618,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.
@@ -1513,7 +1669,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.
@@ -1528,7 +1684,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).
@@ -1557,7 +1713,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;
@@ -1749,12 +1905,20 @@ export class GPUParticleSystem extends BaseParticleSystem {
         serializationObject.activeParticleCount = this.activeParticleCount;
         serializationObject.randomTextureSize = this._randomTextureSize;
         serializationObject.emitRateControl = this._emitRateControl;
+        serializationObject.maxAttractors = this.maxAttractors;
         serializationObject.customShader = this.customShader;
         serializationObject.preventAutoStart = this.preventAutoStart;
         serializationObject.worldOffset = this.worldOffset.asArray();
         if (this.metadata) {
             serializationObject.metadata = this.metadata;
         }
+        // Attractors
+        if (this._attractors.length > 0) {
+            serializationObject.attractors = [];
+            for (const attractor of this._attractors) {
+                serializationObject.attractors.push(attractor.serialize());
+            }
+        }
         return serializationObject;
     }
     /**
@@ -1781,6 +1945,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
             capacity: capacity || parsedParticleSystem.capacity,
             randomTextureSize: parsedParticleSystem.randomTextureSize,
             emitRateControl: parsedParticleSystem.emitRateControl,
+            maxAttractors: parsedParticleSystem.maxAttractors,
         }, sceneOrEngine, null, parsedParticleSystem.isAnimationSheetEnabled);
         particleSystem._rootUrl = rootUrl;
         if (parsedParticleSystem.customShader && engine.createEffectForParticles) {
@@ -1807,6 +1972,15 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (parsedParticleSystem.metadata) {
             particleSystem.metadata = parsedParticleSystem.metadata;
         }
+        // Attractors
+        if (parsedParticleSystem.attractors) {
+            for (const attractorData of parsedParticleSystem.attractors) {
+                const attractor = new Attractor();
+                attractor.position = Vector3.FromArray(attractorData.position);
+                attractor.strength = attractorData.strength;
+                particleSystem.addAttractor(attractor);
+            }
+        }
         if (!doNotStart && !particleSystem.preventAutoStart) {
             particleSystem.start();
         }