@babylonjs/core 8.4.0 → 8.4.2

package/Particles/thinParticleSystem.js

@@ -1,6 +1,6 @@
 import { FactorGradient, ColorGradient, Color3Gradient, GradientHelper } from "../Misc/gradients.js";
 import { Observable } from "../Misc/observable.js";
-import { Vector3, Matrix, Vector4, TmpVectors } from "../Maths/math.vector.js";
+import { Vector3, Matrix, TmpVectors } from "../Maths/math.vector.js";
 import { VertexBuffer, Buffer } from "../Buffers/buffer.js";
 import { RawTexture } from "../Materials/Textures/rawTexture.js";
 import { EngineStore } from "../Engines/engineStore.js";
@@ -13,8 +13,10 @@ import "../Engines/Extensions/engine.alpha.js";
 import { addClipPlaneUniforms, prepareStringDefinesForClipPlanes, bindClipPlane } from "../Materials/clipPlaneMaterialHelper.js";
 import { BindFogParameters, BindLogDepth } from "../Materials/materialHelper.functions.js";
 import { BoxParticleEmitter } from "./EmitterTypes/boxParticleEmitter.js";
-import { Clamp, Lerp, RandomRange } from "../Maths/math.scalar.functions.js";
+import { Lerp } from "../Maths/math.scalar.functions.js";
 import { PrepareSamplersForImageProcessing, PrepareUniformsForImageProcessing } from "../Materials/imageProcessingConfiguration.functions.js";
+import { _CreateAngleData, _CreateAngleGradientsData, _CreateColorData, _CreateColorGradientsData, _CreateCustomDirectionData, _CreateCustomPositionData, _CreateDirectionData, _CreateDragData, _CreateEmitPowerData, _CreateIsLocalData, _CreateLifeGradientsData, _CreateLifetimeData, _CreateLimitVelocityGradients, _CreateNoiseData, _CreatePositionData, _CreateRampData, _CreateSheetData, _CreateSizeData, _CreateSizeGradientsData, _CreateStartSizeGradientsData, _CreateVelocityGradients, _ProcessAngularSpeed, _ProcessAngularSpeedGradients, _ProcessColor, _ProcessColorGradients, _ProcessDirection, _ProcessDragGradients, _ProcessGravity, _ProcessLimitVelocityGradients, _ProcessNoise, _ProcessPosition, _ProcessRemapGradients, _ProcessSizeGradients, _ProcessVelocityGradients, } from "./thinParticleSystem.function.js";
+import { _ConnectAfter, _ConnectBefore, _RemoveFromQueue } from "./Queue/executionQueue.js";
 /**
  * This represents a thin particle system in Babylon.
  * Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
@@ -23,6 +25,44 @@ import { PrepareSamplersForImageProcessing, PrepareUniformsForImageProcessing }
  * @example https://doc.babylonjs.com/features/featuresDeepDive/particles/particle_system/particle_system_intro
  */
 export class ThinParticleSystem extends BaseParticleSystem {
+    /**
+     * This function can be defined to specify initial direction for every new particle.
+     * It by default use the emitterType defined function
+     */
+    get startDirectionFunction() {
+        return this._startDirectionFunction;
+    }
+    set startDirectionFunction(value) {
+        if (this._startDirectionFunction === value) {
+            return;
+        }
+        this._startDirectionFunction = value;
+        if (value) {
+            this._directionProcessing.process = _CreateCustomDirectionData;
+        }
+        else {
+            this._directionProcessing.process = _CreateDirectionData;
+        }
+    }
+    /**
+     * This function can be defined to specify initial position for every new particle.
+     * It by default use the emitterType defined function
+     */
+    get startPositionFunction() {
+        return this._startPositionFunction;
+    }
+    set startPositionFunction(value) {
+        if (this._startPositionFunction === value) {
+            return;
+        }
+        this._startPositionFunction = value;
+        if (value) {
+            this._positionCreation.process = _CreateCustomPositionData;
+        }
+        else {
+            this._positionCreation.process = _CreatePositionData;
+        }
+    }
     /**
      * Sets a callback that will be triggered when the system is disposed
      */
@@ -44,6 +84,47 @@ export class ThinParticleSystem extends BaseParticleSystem {
         }
         this._useRampGradients = value;
         this._resetEffect();
+        if (value) {
+            this._rampCreation = {
+                process: _CreateRampData,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectAfter(this._rampCreation, this._colorCreation);
+            this._remapGradientProcessing = {
+                process: _ProcessRemapGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectAfter(this._remapGradientProcessing, this._gravityProcessing);
+        }
+        else {
+            _RemoveFromQueue(this._rampCreation);
+            _RemoveFromQueue(this._remapGradientProcessing);
+        }
+    }
+    /**
+     * Specifies if the particles are updated in emitter local space or world space
+     */
+    get isLocal() {
+        return this._isLocal;
+    }
+    set isLocal(value) {
+        if (this._isLocal === value) {
+            return;
+        }
+        this._isLocal = value;
+        if (value) {
+            this._isLocalCreation = {
+                process: _CreateIsLocalData,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectAfter(this._isLocalCreation, this._positionCreation);
+        }
+        else {
+            _RemoveFromQueue(this._isLocalCreation);
+        }
     }
     /**
      * Gets the current list of active particles
@@ -57,6 +138,27 @@ export class ThinParticleSystem extends BaseParticleSystem {
     get shaderLanguage() {
         return this._shaderLanguage;
     }
+    /** @internal */
+    get _isAnimationSheetEnabled() {
+        return this._animationSheetEnabled;
+    }
+    set _isAnimationSheetEnabled(value) {
+        if (this._animationSheetEnabled === value) {
+            return;
+        }
+        this._animationSheetEnabled = value;
+        if (value) {
+            this._sheetCreation = {
+                process: _CreateSheetData,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectAfter(this._sheetCreation, this._colorCreation);
+        }
+        else {
+            _RemoveFromQueue(this._sheetCreation);
+        }
+    }
     /**
      * Gets the number of particles active at the same time.
      * @returns The number of active particles.
@@ -128,6 +230,32 @@ export class ThinParticleSystem extends BaseParticleSystem {
     get indexBuffer() {
         return this._indexBuffer;
     }
+    get noiseTexture() {
+        return this._noiseTexture;
+    }
+    set noiseTexture(value) {
+        if (this.noiseTexture === value) {
+            return;
+        }
+        this._noiseTexture = value;
+        if (!value) {
+            _RemoveFromQueue(this._noiseCreation);
+            _RemoveFromQueue(this._noiseProcessing);
+            return;
+        }
+        this._noiseCreation = {
+            process: _CreateNoiseData,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._noiseCreation, this._colorCreation);
+        this._noiseProcessing = {
+            process: _ProcessNoise,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._noiseProcessing, this._positionProcessing);
+    }
     /**
      * Instantiates a particle system.
      * Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
@@ -140,7 +268,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     constructor(name, capacity, sceneOrEngine, customEffect = null, isAnimationSheetEnabled = false, epsilon = 0.01) {
         super(name);
+        /** @internal */
         this._emitterInverseWorldMatrix = Matrix.Identity();
+        this._startDirectionFunction = null;
+        this._startPositionFunction = null;
         /**
          * @internal
          */
@@ -153,18 +284,27 @@ export class ThinParticleSystem extends BaseParticleSystem {
          * An event triggered when the system is stopped
          */
         this.onStoppedObservable = new Observable();
+        /** @internal */
+        this._noiseTextureSize = null;
+        /** @internal */
+        this._noiseTextureData = null;
         this._particles = new Array();
         this._stockParticles = new Array();
         this._newPartsExcess = 0;
         this._vertexBuffers = {};
+        /** @internal */
         this._scaledColorStep = new Color4(0, 0, 0, 0);
+        /** @internal */
         this._colorDiff = new Color4(0, 0, 0, 0);
+        /** @internal */
         this._scaledDirection = Vector3.Zero();
+        /** @internal */
         this._scaledGravity = Vector3.Zero();
         this._currentRenderId = -1;
         this._useInstancing = false;
         this._started = false;
         this._stopped = false;
+        /** @internal */
         this._actualFrame = 0;
         /** @internal */
         this._currentEmitRate1 = 0;
@@ -178,10 +318,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
         this.updateInAnimate = true;
         this._rawTextureWidth = 256;
         this._useRampGradients = false;
-        /**
-         * Specifies if the particles are updated in emitter local space or world space
-         */
-        this.isLocal = false;
+        this._updateQueueStart = null;
+        this._startSizeCreation = null;
+        this._createQueueStart = null;
+        this._isLocal = false;
         /** Indicates that the particle system is CPU based */
         this.isGPU = false;
         /** Shader language used by the material */
@@ -247,152 +387,109 @@ export class ThinParticleSystem extends BaseParticleSystem {
         this._createVertexBuffers();
         // Default emitter type
         this.particleEmitterType = new BoxParticleEmitter();
-        let noiseTextureData = null;
+        // Creation queue
+        this._lifeTimeCreation = {
+            process: _CreateLifetimeData,
+            previousItem: null,
+            nextItem: null,
+        };
+        this._positionCreation = {
+            process: _CreatePositionData,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._positionCreation, this._lifeTimeCreation);
+        this._directionCreation = {
+            process: _CreateDirectionData,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._directionCreation, this._positionCreation);
+        this._emitPowerCreation = {
+            process: _CreateEmitPowerData,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._emitPowerCreation, this._directionCreation);
+        this._sizeCreation = {
+            process: _CreateSizeData,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._sizeCreation, this._emitPowerCreation);
+        this._angleCreation = {
+            process: _CreateAngleData,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._angleCreation, this._sizeCreation);
+        this._colorCreation = {
+            process: _CreateColorData,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._colorCreation, this._angleCreation);
+        this._createQueueStart = this._lifeTimeCreation;
+        // Processing queue
+        this._colorProcessing = {
+            process: _ProcessColor,
+            previousItem: null,
+            nextItem: null,
+        };
+        this._angularSpeedProcessing = {
+            process: _ProcessAngularSpeed,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._angularSpeedProcessing, this._colorProcessing);
+        this._directionProcessing = {
+            process: _ProcessDirection,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._directionProcessing, this._angularSpeedProcessing);
+        this._positionProcessing = {
+            process: _ProcessPosition,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._positionProcessing, this._directionProcessing);
+        this._gravityProcessing = {
+            process: _ProcessGravity,
+            previousItem: null,
+            nextItem: null,
+        };
+        _ConnectAfter(this._gravityProcessing, this._positionProcessing);
+        this._updateQueueStart = this._colorProcessing;
         // Update
         this.updateFunction = (particles) => {
-            let noiseTextureSize = null;
             if (this.noiseTexture) {
                 // We need to get texture data back to CPU
-                noiseTextureSize = this.noiseTexture.getSize();
+                this._noiseTextureSize = this.noiseTexture.getSize();
                 this.noiseTexture.getContent()?.then((data) => {
-                    noiseTextureData = data;
+                    this._noiseTextureData = data;
                 });
             }
             const sameParticleArray = particles === this._particles;
             for (let index = 0; index < particles.length; index++) {
                 const particle = particles[index];
-                let scaledUpdateSpeed = this._scaledUpdateSpeed;
+                this._tempScaledUpdateSpeed = this._scaledUpdateSpeed;
                 const previousAge = particle.age;
-                particle.age += scaledUpdateSpeed;
+                particle.age += this._tempScaledUpdateSpeed;
                 // Evaluate step to death
                 if (particle.age > particle.lifeTime) {
                     const diff = particle.age - previousAge;
                     const oldDiff = particle.lifeTime - previousAge;
-                    scaledUpdateSpeed = (oldDiff * scaledUpdateSpeed) / diff;
+                    this._tempScaledUpdateSpeed = (oldDiff * this._tempScaledUpdateSpeed) / diff;
                     particle.age = particle.lifeTime;
                 }
-                const ratio = particle.age / particle.lifeTime;
-                // Color
-                if (this._colorGradients && this._colorGradients.length > 0) {
-                    GradientHelper.GetCurrentGradient(ratio, this._colorGradients, (currentGradient, nextGradient, scale) => {
-                        if (currentGradient !== particle._currentColorGradient) {
-                            particle._currentColor1.copyFrom(particle._currentColor2);
-                            nextGradient.getColorToRef(particle._currentColor2);
-                            particle._currentColorGradient = currentGradient;
-                        }
-                        Color4.LerpToRef(particle._currentColor1, particle._currentColor2, scale, particle.color);
-                    });
-                }
-                else {
-                    particle.colorStep.scaleToRef(scaledUpdateSpeed, this._scaledColorStep);
-                    particle.color.addInPlace(this._scaledColorStep);
-                    if (particle.color.a < 0) {
-                        particle.color.a = 0;
-                    }
-                }
-                // Angular speed
-                if (this._angularSpeedGradients && this._angularSpeedGradients.length > 0) {
-                    GradientHelper.GetCurrentGradient(ratio, this._angularSpeedGradients, (currentGradient, nextGradient, scale) => {
-                        if (currentGradient !== particle._currentAngularSpeedGradient) {
-                            particle._currentAngularSpeed1 = particle._currentAngularSpeed2;
-                            particle._currentAngularSpeed2 = nextGradient.getFactor();
-                            particle._currentAngularSpeedGradient = currentGradient;
-                        }
-                        particle.angularSpeed = Lerp(particle._currentAngularSpeed1, particle._currentAngularSpeed2, scale);
-                    });
-                }
-                particle.angle += particle.angularSpeed * scaledUpdateSpeed;
-                // Direction
-                let directionScale = scaledUpdateSpeed;
-                /// Velocity
-                if (this._velocityGradients && this._velocityGradients.length > 0) {
-                    GradientHelper.GetCurrentGradient(ratio, this._velocityGradients, (currentGradient, nextGradient, scale) => {
-                        if (currentGradient !== particle._currentVelocityGradient) {
-                            particle._currentVelocity1 = particle._currentVelocity2;
-                            particle._currentVelocity2 = nextGradient.getFactor();
-                            particle._currentVelocityGradient = currentGradient;
-                        }
-                        directionScale *= Lerp(particle._currentVelocity1, particle._currentVelocity2, scale);
-                    });
-                }
-                particle.direction.scaleToRef(directionScale, this._scaledDirection);
-                /// Limit velocity
-                if (this._limitVelocityGradients && this._limitVelocityGradients.length > 0) {
-                    GradientHelper.GetCurrentGradient(ratio, this._limitVelocityGradients, (currentGradient, nextGradient, scale) => {
-                        if (currentGradient !== particle._currentLimitVelocityGradient) {
-                            particle._currentLimitVelocity1 = particle._currentLimitVelocity2;
-                            particle._currentLimitVelocity2 = nextGradient.getFactor();
-                            particle._currentLimitVelocityGradient = currentGradient;
-                        }
-                        const limitVelocity = Lerp(particle._currentLimitVelocity1, particle._currentLimitVelocity2, scale);
-                        const currentVelocity = particle.direction.length();
-                        if (currentVelocity > limitVelocity) {
-                            particle.direction.scaleInPlace(this.limitVelocityDamping);
-                        }
-                    });
-                }
-                /// Drag
-                if (this._dragGradients && this._dragGradients.length > 0) {
-                    GradientHelper.GetCurrentGradient(ratio, this._dragGradients, (currentGradient, nextGradient, scale) => {
-                        if (currentGradient !== particle._currentDragGradient) {
-                            particle._currentDrag1 = particle._currentDrag2;
-                            particle._currentDrag2 = nextGradient.getFactor();
-                            particle._currentDragGradient = currentGradient;
-                        }
-                        const drag = Lerp(particle._currentDrag1, particle._currentDrag2, scale);
-                        this._scaledDirection.scaleInPlace(1.0 - drag);
-                    });
-                }
-                if (this.isLocal && particle._localPosition) {
-                    particle._localPosition.addInPlace(this._scaledDirection);
-                    Vector3.TransformCoordinatesToRef(particle._localPosition, this._emitterWorldMatrix, particle.position);
-                }
-                else {
-                    particle.position.addInPlace(this._scaledDirection);
-                }
-                // Noise
-                if (noiseTextureData && noiseTextureSize && particle._randomNoiseCoordinates1) {
-                    const fetchedColorR = this._fetchR(particle._randomNoiseCoordinates1.x, particle._randomNoiseCoordinates1.y, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
-                    const fetchedColorG = this._fetchR(particle._randomNoiseCoordinates1.z, particle._randomNoiseCoordinates2.x, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
-                    const fetchedColorB = this._fetchR(particle._randomNoiseCoordinates2.y, particle._randomNoiseCoordinates2.z, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
-                    const force = TmpVectors.Vector3[0];
-                    const scaledForce = TmpVectors.Vector3[1];
-                    force.copyFromFloats((2 * fetchedColorR - 1) * this.noiseStrength.x, (2 * fetchedColorG - 1) * this.noiseStrength.y, (2 * fetchedColorB - 1) * this.noiseStrength.z);
-                    force.scaleToRef(scaledUpdateSpeed, scaledForce);
-                    particle.direction.addInPlace(scaledForce);
-                }
-                // Gravity
-                this.gravity.scaleToRef(scaledUpdateSpeed, this._scaledGravity);
-                particle.direction.addInPlace(this._scaledGravity);
-                // Size
-                if (this._sizeGradients && this._sizeGradients.length > 0) {
-                    GradientHelper.GetCurrentGradient(ratio, this._sizeGradients, (currentGradient, nextGradient, scale) => {
-                        if (currentGradient !== particle._currentSizeGradient) {
-                            particle._currentSize1 = particle._currentSize2;
-                            particle._currentSize2 = nextGradient.getFactor();
-                            particle._currentSizeGradient = currentGradient;
-                        }
-                        particle.size = Lerp(particle._currentSize1, particle._currentSize2, scale);
-                    });
-                }
-                // Remap data
-                if (this._useRampGradients) {
-                    if (this._colorRemapGradients && this._colorRemapGradients.length > 0) {
-                        GradientHelper.GetCurrentGradient(ratio, this._colorRemapGradients, (currentGradient, nextGradient, scale) => {
-                            const min = Lerp(currentGradient.factor1, nextGradient.factor1, scale);
-                            const max = Lerp(currentGradient.factor2, nextGradient.factor2, scale);
-                            particle.remapData.x = min;
-                            particle.remapData.y = max - min;
-                        });
-                    }
-                    if (this._alphaRemapGradients && this._alphaRemapGradients.length > 0) {
-                        GradientHelper.GetCurrentGradient(ratio, this._alphaRemapGradients, (currentGradient, nextGradient, scale) => {
-                            const min = Lerp(currentGradient.factor1, nextGradient.factor1, scale);
-                            const max = Lerp(currentGradient.factor2, nextGradient.factor2, scale);
-                            particle.remapData.z = min;
-                            particle.remapData.w = max - min;
-                        });
-                    }
+                this._ratio = particle.age / particle.lifeTime;
+                this._directionScale = this._tempScaledUpdateSpeed;
+                // Processing queue
+                let currentQueueItem = this._updateQueueStart;
+                while (currentQueueItem) {
+                    currentQueueItem.process(particle, this);
+                    currentQueueItem = currentQueueItem.nextItem;
                 }
                 if (this._isAnimationSheetEnabled) {
                     particle.updateCellIndex();
@@ -456,6 +553,41 @@ export class ThinParticleSystem extends BaseParticleSystem {
             index++;
         }
     }
+    _syncLifeTimeCreation() {
+        if (this.targetStopDuration && this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
+            this._lifeTimeCreation.process = _CreateLifeGradientsData;
+            return;
+        }
+        this._lifeTimeCreation.process = _CreateLifetimeData;
+    }
+    _syncStartSizeCreation() {
+        if (this._startSizeGradients && this._startSizeGradients[0] && this.targetStopDuration) {
+            if (!this._startSizeCreation) {
+                this._startSizeCreation = {
+                    process: _CreateStartSizeGradientsData,
+                    previousItem: null,
+                    nextItem: null,
+                };
+                _ConnectAfter(this._startSizeCreation, this._sizeCreation);
+            }
+            return;
+        }
+        if (this._startSizeCreation) {
+            _RemoveFromQueue(this._startSizeCreation);
+            this._startSizeCreation = null;
+        }
+    }
+    get targetStopDuration() {
+        return this._targetStopDuration;
+    }
+    set targetStopDuration(value) {
+        if (this.targetStopDuration === value) {
+            return;
+        }
+        this._targetStopDuration = value;
+        this._syncLifeTimeCreation();
+        this._syncStartSizeCreation();
+    }
     /**
      * Adds a new life time gradient
      * @param gradient defines the gradient to use (between 0 and 1)
@@ -468,6 +600,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
             this._lifeTimeGradients = [];
         }
         this._addFactorGradient(this._lifeTimeGradients, gradient, factor, factor2);
+        this._syncLifeTimeCreation();
         return this;
     }
     /**
@@ -477,6 +610,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     removeLifeTimeGradient(gradient) {
         this._removeFactorGradient(this._lifeTimeGradients, gradient);
+        this._syncLifeTimeCreation();
         return this;
     }
     /**
@@ -490,6 +624,15 @@ export class ThinParticleSystem extends BaseParticleSystem {
         if (!this._sizeGradients) {
             this._sizeGradients = [];
         }
+        if (this._sizeGradients.length === 0) {
+            this._sizeCreation.process = _CreateSizeGradientsData;
+            this._sizeGradientProcessing = {
+                process: _ProcessSizeGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectBefore(this._sizeGradientProcessing, this._gravityProcessing);
+        }
         this._addFactorGradient(this._sizeGradients, gradient, factor, factor2);
         return this;
     }
@@ -500,6 +643,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     removeSizeGradient(gradient) {
         this._removeFactorGradient(this._sizeGradients, gradient);
+        if (this._sizeGradients?.length === 0) {
+            _RemoveFromQueue(this._sizeGradientProcessing);
+            this._sizeCreation.process = _CreateSizeData;
+        }
         return this;
     }
     /**
@@ -559,6 +706,15 @@ export class ThinParticleSystem extends BaseParticleSystem {
         if (!this._angularSpeedGradients) {
             this._angularSpeedGradients = [];
         }
+        if (this._angularSpeedGradients.length === 0) {
+            this._angleCreation.process = _CreateAngleGradientsData;
+            this._angularSpeedGradientProcessing = {
+                process: _ProcessAngularSpeedGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectBefore(this._angularSpeedGradientProcessing, this._angularSpeedProcessing);
+        }
         this._addFactorGradient(this._angularSpeedGradients, gradient, factor, factor2);
         return this;
     }
@@ -569,6 +725,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     removeAngularSpeedGradient(gradient) {
         this._removeFactorGradient(this._angularSpeedGradients, gradient);
+        if (this._angularSpeedGradients?.length === 0) {
+            this._angleCreation.process = _CreateAngleData;
+            _RemoveFromQueue(this._angularSpeedGradientProcessing);
+        }
         return this;
     }
     /**
@@ -582,6 +742,20 @@ export class ThinParticleSystem extends BaseParticleSystem {
         if (!this._velocityGradients) {
             this._velocityGradients = [];
         }
+        if (this._velocityGradients.length === 0) {
+            this._velocityCreation = {
+                process: _CreateVelocityGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectAfter(this._velocityCreation, this._angleCreation);
+            this._velocityGradientProcessing = {
+                process: _ProcessVelocityGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectBefore(this._velocityGradientProcessing, this._directionProcessing);
+        }
         this._addFactorGradient(this._velocityGradients, gradient, factor, factor2);
         return this;
     }
@@ -592,6 +766,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     removeVelocityGradient(gradient) {
         this._removeFactorGradient(this._velocityGradients, gradient);
+        if (this._velocityGradients?.length === 0) {
+            _RemoveFromQueue(this._velocityCreation);
+            _RemoveFromQueue(this._velocityGradientProcessing);
+        }
         return this;
     }
     /**
@@ -605,6 +783,20 @@ export class ThinParticleSystem extends BaseParticleSystem {
         if (!this._limitVelocityGradients) {
             this._limitVelocityGradients = [];
         }
+        if (this._limitVelocityGradients.length === 0) {
+            this._limitVelocityCreation = {
+                process: _CreateLimitVelocityGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectAfter(this._limitVelocityCreation, this._angleCreation);
+            this._limitVelocityGradientProcessing = {
+                process: _ProcessLimitVelocityGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectAfter(this._limitVelocityGradientProcessing, this._directionProcessing);
+        }
         this._addFactorGradient(this._limitVelocityGradients, gradient, factor, factor2);
         return this;
     }
@@ -615,6 +807,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     removeLimitVelocityGradient(gradient) {
         this._removeFactorGradient(this._limitVelocityGradients, gradient);
+        if (this._limitVelocityGradients?.length === 0) {
+            _RemoveFromQueue(this._limitVelocityCreation);
+            _RemoveFromQueue(this._limitVelocityGradientProcessing);
+        }
         return this;
     }
     /**
@@ -628,6 +824,20 @@ export class ThinParticleSystem extends BaseParticleSystem {
         if (!this._dragGradients) {
             this._dragGradients = [];
         }
+        if (this._dragGradients.length === 0) {
+            this._dragCreation = {
+                process: _CreateDragData,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectBefore(this._dragCreation, this._colorCreation);
+            this._dragGradientProcessing = {
+                process: _ProcessDragGradients,
+                previousItem: null,
+                nextItem: null,
+            };
+            _ConnectBefore(this._dragGradientProcessing, this._positionProcessing);
+        }
         this._addFactorGradient(this._dragGradients, gradient, factor, factor2);
         return this;
     }
@@ -638,6 +848,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     removeDragGradient(gradient) {
         this._removeFactorGradient(this._dragGradients, gradient);
+        if (this._dragGradients?.length === 0) {
+            _RemoveFromQueue(this._dragCreation);
+            _RemoveFromQueue(this._dragGradientProcessing);
+        }
         return this;
     }
     /**
@@ -675,6 +889,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
             this._startSizeGradients = [];
         }
         this._addFactorGradient(this._startSizeGradients, gradient, factor, factor2);
+        this._syncStartSizeCreation();
         return this;
     }
     /**
@@ -684,6 +899,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
      */
     removeStartSizeGradient(gradient) {
         this._removeFactorGradient(this._startSizeGradients, gradient);
+        this._syncStartSizeCreation();
         return this;
     }
     _createRampGradientTexture() {
@@ -774,6 +990,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
         if (!this._colorGradients) {
             this._colorGradients = [];
         }
+        if (this._colorGradients.length === 0) {
+            this._colorCreation.process = _CreateColorGradientsData;
+            this._colorProcessing.process = _ProcessColorGradients;
+        }
         const colorGradient = new ColorGradient(gradient, color1, color2);
         this._colorGradients.push(colorGradient);
         this._colorGradients.sort((a, b) => {
@@ -804,6 +1024,10 @@ export class ThinParticleSystem extends BaseParticleSystem {
             }
             index++;
         }
+        if (this._colorGradients.length === 0) {
+            this._colorCreation.process = _CreateColorData;
+            this._colorProcessing.process = _ProcessColor;
+        }
         return this;
     }
     /**
@@ -819,6 +1043,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
         }
         this._drawWrappers = [];
     }
+    /** @internal */
     _fetchR(u, v, width, height, pixels) {
         u = Math.abs(u) * 0.5 + 0.5;
         v = Math.abs(v) * 0.5 + 0.5;
@@ -1122,6 +1347,25 @@ export class ThinParticleSystem extends BaseParticleSystem {
     _prepareParticle(particle) {
         //Do nothing
     }
+    _createNewOnes(newParticles) {
+        // Add new ones
+        let particle;
+        for (let index = 0; index < newParticles; index++) {
+            if (this._particles.length === this._capacity) {
+                break;
+            }
+            particle = this._createParticle();
+            this._particles.push(particle);
+            // Creation queue
+            let currentQueueItem = this._createQueueStart;
+            while (currentQueueItem) {
+                currentQueueItem.process(particle, this);
+                currentQueueItem = currentQueueItem.nextItem;
+            }
+            // Update the position of the attached sub-emitters to match their attached particle
+            particle._inheritParticleInfoToSubEmitters();
+        }
+    }
     _update(newParticles) {
         // Update current
         this._alive = this._particles.length > 0;
@@ -1135,187 +1379,7 @@ export class ThinParticleSystem extends BaseParticleSystem {
         }
         this._emitterWorldMatrix.invertToRef(this._emitterInverseWorldMatrix);
         this.updateFunction(this._particles);
-        // Add new ones
-        let particle;
-        for (let index = 0; index < newParticles; index++) {
-            if (this._particles.length === this._capacity) {
-                break;
-            }
-            particle = this._createParticle();
-            this._particles.push(particle);
-            // Life time
-            if (this.targetStopDuration && this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
-                const ratio = Clamp(this._actualFrame / this.targetStopDuration);
-                GradientHelper.GetCurrentGradient(ratio, this._lifeTimeGradients, (currentGradient, nextGradient) => {
-                    const factorGradient1 = currentGradient;
-                    const factorGradient2 = nextGradient;
-                    const lifeTime1 = factorGradient1.getFactor();
-                    const lifeTime2 = factorGradient2.getFactor();
-                    const gradient = (ratio - factorGradient1.gradient) / (factorGradient2.gradient - factorGradient1.gradient);
-                    particle.lifeTime = Lerp(lifeTime1, lifeTime2, gradient);
-                });
-            }
-            else {
-                particle.lifeTime = RandomRange(this.minLifeTime, this.maxLifeTime);
-            }
-            // Emitter
-            const emitPower = RandomRange(this.minEmitPower, this.maxEmitPower);
-            if (this.startPositionFunction) {
-                this.startPositionFunction(this._emitterWorldMatrix, particle.position, particle, this.isLocal);
-            }
-            else {
-                this.particleEmitterType.startPositionFunction(this._emitterWorldMatrix, particle.position, particle, this.isLocal);
-            }
-            if (this.isLocal) {
-                if (!particle._localPosition) {
-                    particle._localPosition = particle.position.clone();
-                }
-                else {
-                    particle._localPosition.copyFrom(particle.position);
-                }
-                Vector3.TransformCoordinatesToRef(particle._localPosition, this._emitterWorldMatrix, particle.position);
-            }
-            if (this.startDirectionFunction) {
-                this.startDirectionFunction(this._emitterWorldMatrix, particle.direction, particle, this.isLocal);
-            }
-            else {
-                this.particleEmitterType.startDirectionFunction(this._emitterWorldMatrix, particle.direction, particle, this.isLocal, this._emitterInverseWorldMatrix);
-            }
-            if (emitPower === 0) {
-                if (!particle._initialDirection) {
-                    particle._initialDirection = particle.direction.clone();
-                }
-                else {
-                    particle._initialDirection.copyFrom(particle.direction);
-                }
-            }
-            else {
-                particle._initialDirection = null;
-            }
-            particle.direction.scaleInPlace(emitPower);
-            // Size
-            if (!this._sizeGradients || this._sizeGradients.length === 0) {
-                particle.size = RandomRange(this.minSize, this.maxSize);
-            }
-            else {
-                particle._currentSizeGradient = this._sizeGradients[0];
-                particle._currentSize1 = particle._currentSizeGradient.getFactor();
-                particle.size = particle._currentSize1;
-                if (this._sizeGradients.length > 1) {
-                    particle._currentSize2 = this._sizeGradients[1].getFactor();
-                }
-                else {
-                    particle._currentSize2 = particle._currentSize1;
-                }
-            }
-            // Size and scale
-            particle.scale.copyFromFloats(RandomRange(this.minScaleX, this.maxScaleX), RandomRange(this.minScaleY, this.maxScaleY));
-            // Adjust scale by start size
-            if (this._startSizeGradients && this._startSizeGradients[0] && this.targetStopDuration) {
-                const ratio = this._actualFrame / this.targetStopDuration;
-                GradientHelper.GetCurrentGradient(ratio, this._startSizeGradients, (currentGradient, nextGradient, scale) => {
-                    if (currentGradient !== this._currentStartSizeGradient) {
-                        this._currentStartSize1 = this._currentStartSize2;
-                        this._currentStartSize2 = nextGradient.getFactor();
-                        this._currentStartSizeGradient = currentGradient;
-                    }
-                    const value = Lerp(this._currentStartSize1, this._currentStartSize2, scale);
-                    particle.scale.scaleInPlace(value);
-                });
-            }
-            // Angle
-            if (!this._angularSpeedGradients || this._angularSpeedGradients.length === 0) {
-                particle.angularSpeed = RandomRange(this.minAngularSpeed, this.maxAngularSpeed);
-            }
-            else {
-                particle._currentAngularSpeedGradient = this._angularSpeedGradients[0];
-                particle.angularSpeed = particle._currentAngularSpeedGradient.getFactor();
-                particle._currentAngularSpeed1 = particle.angularSpeed;
-                if (this._angularSpeedGradients.length > 1) {
-                    particle._currentAngularSpeed2 = this._angularSpeedGradients[1].getFactor();
-                }
-                else {
-                    particle._currentAngularSpeed2 = particle._currentAngularSpeed1;
-                }
-            }
-            particle.angle = RandomRange(this.minInitialRotation, this.maxInitialRotation);
-            // Velocity
-            if (this._velocityGradients && this._velocityGradients.length > 0) {
-                particle._currentVelocityGradient = this._velocityGradients[0];
-                particle._currentVelocity1 = particle._currentVelocityGradient.getFactor();
-                if (this._velocityGradients.length > 1) {
-                    particle._currentVelocity2 = this._velocityGradients[1].getFactor();
-                }
-                else {
-                    particle._currentVelocity2 = particle._currentVelocity1;
-                }
-            }
-            // Limit velocity
-            if (this._limitVelocityGradients && this._limitVelocityGradients.length > 0) {
-                particle._currentLimitVelocityGradient = this._limitVelocityGradients[0];
-                particle._currentLimitVelocity1 = particle._currentLimitVelocityGradient.getFactor();
-                if (this._limitVelocityGradients.length > 1) {
-                    particle._currentLimitVelocity2 = this._limitVelocityGradients[1].getFactor();
-                }
-                else {
-                    particle._currentLimitVelocity2 = particle._currentLimitVelocity1;
-                }
-            }
-            // Drag
-            if (this._dragGradients && this._dragGradients.length > 0) {
-                particle._currentDragGradient = this._dragGradients[0];
-                particle._currentDrag1 = particle._currentDragGradient.getFactor();
-                if (this._dragGradients.length > 1) {
-                    particle._currentDrag2 = this._dragGradients[1].getFactor();
-                }
-                else {
-                    particle._currentDrag2 = particle._currentDrag1;
-                }
-            }
-            // Color
-            if (!this._colorGradients || this._colorGradients.length === 0) {
-                const step = RandomRange(0, 1.0);
-                Color4.LerpToRef(this.color1, this.color2, step, particle.color);
-                this.colorDead.subtractToRef(particle.color, this._colorDiff);
-                this._colorDiff.scaleToRef(1.0 / particle.lifeTime, particle.colorStep);
-            }
-            else {
-                particle._currentColorGradient = this._colorGradients[0];
-                particle._currentColorGradient.getColorToRef(particle.color);
-                particle._currentColor1.copyFrom(particle.color);
-                if (this._colorGradients.length > 1) {
-                    this._colorGradients[1].getColorToRef(particle._currentColor2);
-                }
-                else {
-                    particle._currentColor2.copyFrom(particle.color);
-                }
-            }
-            // Sheet
-            if (this._isAnimationSheetEnabled) {
-                particle._initialStartSpriteCellID = this.startSpriteCellID;
-                particle._initialEndSpriteCellID = this.endSpriteCellID;
-                particle._initialSpriteCellLoop = this.spriteCellLoop;
-            }
-            // Inherited Velocity
-            particle.direction.addInPlace(this._inheritedVelocityOffset);
-            // Ramp
-            if (this._useRampGradients) {
-                particle.remapData = new Vector4(0, 1, 0, 1);
-            }
-            // Noise texture coordinates
-            if (this.noiseTexture) {
-                if (particle._randomNoiseCoordinates1) {
-                    particle._randomNoiseCoordinates1.copyFromFloats(Math.random(), Math.random(), Math.random());
-                    particle._randomNoiseCoordinates2.copyFromFloats(Math.random(), Math.random(), Math.random());
-                }
-                else {
-                    particle._randomNoiseCoordinates1 = new Vector3(Math.random(), Math.random(), Math.random());
-                    particle._randomNoiseCoordinates2 = new Vector3(Math.random(), Math.random(), Math.random());
-                }
-            }
-            // Update the position of the attached sub-emitters to match their attached particle
-            particle._inheritParticleInfoToSubEmitters();
-        }
+        this._createNewOnes(newParticles);
     }
     /**
      * @internal