Fix sizeGradient starters

dist/preview release/babylon.max.js

@@ -8559,6 +8559,17 @@ var BABYLON;
     var FactorGradient = /** @class */ (function () {
         function FactorGradient() {
         }
+        /**
+         * Will get a number picked randomly between factor1 and factor2.
+         * If factor2 is undefined then factor1 will be used
+         * @returns the picked number
+         */
+        FactorGradient.prototype.getFactor = function () {
+            if (this.factor2 === undefined) {
+                return this.factor1;
+            }
+            return BABYLON.Scalar.Lerp(this.factor1, this.factor2, Math.random());
+        };
         return FactorGradient;
     }());
     BABYLON.FactorGradient = FactorGradient;
@@ -55214,6 +55225,10 @@ var BABYLON;
             this._currentColor1 = new BABYLON.Color4(0, 0, 0, 0);
             /** @hidden */
             this._currentColor2 = new BABYLON.Color4(0, 0, 0, 0);
+            /** @hidden */
+            this._currentSize1 = 0;
+            /** @hidden */
+            this._currentSize2 = 0;
             if (!this.particleSystem.isAnimationSheetEnabled) {
                 return;
             }
@@ -55263,6 +55278,11 @@ var BABYLON;
                 other._currentColor1.copyFrom(this._currentColor1);
                 other._currentColor2.copyFrom(this._currentColor2);
             }
+            if (this._currentSizeGradient) {
+                other._currentSizeGradient = this._currentSizeGradient;
+                other._currentSize1 = this._currentSize1;
+                other._currentSize2 = this._currentSize2;
+            }
         };
         return Particle;
     }());
@@ -55416,6 +55436,7 @@ var BABYLON;
             this.gravity = BABYLON.Vector3.Zero();
             this._colorGradients = null;
             this._sizeGradients = null;
+            this._lifeTimeGradients = null;
             /**
              * Random color of each particle after it has been emitted, between color1 and color2 vectors
              */
@@ -55560,7 +55581,12 @@ var BABYLON;
                         // Gradient
                         if (_this._sizeGradients && _this._sizeGradients.length > 0) {
                             BABYLON.Tools.GetCurrentGradient(ratio, _this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                                if (currentGradient !== particle._currentSizeGradient) {
+                                    particle._currentSize1 = particle._currentSize2;
+                                    particle._currentSize2 = nextGradient.getFactor();
+                                    particle._currentSizeGradient = currentGradient;
+                                }
+                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(particle._currentSize1, particle._currentSize2, scale);
                             });
                         }
                         if (_this._isAnimationSheetEnabled) {
@@ -55724,14 +55750,16 @@ var BABYLON;
          * 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
          */
-        ParticleSystem.prototype.addSizeGradient = function (gradient, factor) {
+        ParticleSystem.prototype.addSizeGradient = function (gradient, factor, factor2) {
             if (!this._sizeGradients) {
                 this._sizeGradients = [];
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
+            sizeGradient.factor2 = factor2;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -56049,7 +56077,20 @@ var BABYLON;
                 }
                 particle.direction.scaleInPlace(emitPower);
                 particle.lifeTime = BABYLON.Scalar.RandomRange(this.minLifeTime, this.maxLifeTime);
-                particle.size = BABYLON.Scalar.RandomRange(this.minSize, this.maxSize);
+                if (!this._sizeGradients || this._sizeGradients.length === 0) {
+                    particle.size = BABYLON.Scalar.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;
+                    }
+                }
                 particle._initialSize = particle.size;
                 particle.scale.copyFromFloats(BABYLON.Scalar.RandomRange(this.minScaleX, this.maxScaleX), BABYLON.Scalar.RandomRange(this.minScaleY, this.maxScaleY));
                 particle.angularSpeed = BABYLON.Scalar.RandomRange(this.minAngularSpeed, this.maxAngularSpeed);
@@ -56485,10 +56526,14 @@ var BABYLON;
                 serializationObject.sizeGradients = [];
                 for (var _a = 0, sizeGradients_1 = sizeGradients; _a < sizeGradients_1.length; _a++) {
                     var sizeGradient = sizeGradients_1[_a];
-                    serializationObject.sizeGradients.push({
+                    var serializedGradient = {
                         gradient: sizeGradient.gradient,
-                        factor: sizeGradient.factor
-                    });
+                        factor1: sizeGradient.factor1
+                    };
+                    if (sizeGradient.factor2 !== undefined) {
+                        serializedGradient.factor2 = sizeGradient.factor2;
+                    }
+                    serializationObject.sizeGradients.push(serializedGradient);
                 }
             }
         };
@@ -56566,7 +56611,7 @@ var BABYLON;
             if (parsedParticleSystem.sizeGradients) {
                 for (var _b = 0, _c = parsedParticleSystem.sizeGradients; _b < _c.length; _b++) {
                     var sizeGradient = _c[_b];
-                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor);
+                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor1 !== undefined ? sizeGradient.factor1 : sizeGradient.factor, sizeGradient.factor2);
                 }
             }
             // Emitter
@@ -57656,7 +57701,7 @@ var BABYLON;
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -57926,7 +57971,7 @@ var BABYLON;
             for (var x = 0; x < textureWidth; x++) {
                 var ratio = x / textureWidth;
                 BABYLON.Tools.GetCurrentGradient(ratio, this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
                 });
             }
             this._sizeGradientsTexture = BABYLON.RawTexture.CreateRTexture(data, textureWidth, 1, this._scene, false, false, BABYLON.Texture.NEAREST_SAMPLINGMODE);

dist/preview release/babylon.no-module.max.js

@@ -8526,6 +8526,17 @@ var BABYLON;
     var FactorGradient = /** @class */ (function () {
         function FactorGradient() {
         }
+        /**
+         * Will get a number picked randomly between factor1 and factor2.
+         * If factor2 is undefined then factor1 will be used
+         * @returns the picked number
+         */
+        FactorGradient.prototype.getFactor = function () {
+            if (this.factor2 === undefined) {
+                return this.factor1;
+            }
+            return BABYLON.Scalar.Lerp(this.factor1, this.factor2, Math.random());
+        };
         return FactorGradient;
     }());
     BABYLON.FactorGradient = FactorGradient;
@@ -55181,6 +55192,10 @@ var BABYLON;
             this._currentColor1 = new BABYLON.Color4(0, 0, 0, 0);
             /** @hidden */
             this._currentColor2 = new BABYLON.Color4(0, 0, 0, 0);
+            /** @hidden */
+            this._currentSize1 = 0;
+            /** @hidden */
+            this._currentSize2 = 0;
             if (!this.particleSystem.isAnimationSheetEnabled) {
                 return;
             }
@@ -55230,6 +55245,11 @@ var BABYLON;
                 other._currentColor1.copyFrom(this._currentColor1);
                 other._currentColor2.copyFrom(this._currentColor2);
             }
+            if (this._currentSizeGradient) {
+                other._currentSizeGradient = this._currentSizeGradient;
+                other._currentSize1 = this._currentSize1;
+                other._currentSize2 = this._currentSize2;
+            }
         };
         return Particle;
     }());
@@ -55383,6 +55403,7 @@ var BABYLON;
             this.gravity = BABYLON.Vector3.Zero();
             this._colorGradients = null;
             this._sizeGradients = null;
+            this._lifeTimeGradients = null;
             /**
              * Random color of each particle after it has been emitted, between color1 and color2 vectors
              */
@@ -55527,7 +55548,12 @@ var BABYLON;
                         // Gradient
                         if (_this._sizeGradients && _this._sizeGradients.length > 0) {
                             BABYLON.Tools.GetCurrentGradient(ratio, _this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                                if (currentGradient !== particle._currentSizeGradient) {
+                                    particle._currentSize1 = particle._currentSize2;
+                                    particle._currentSize2 = nextGradient.getFactor();
+                                    particle._currentSizeGradient = currentGradient;
+                                }
+                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(particle._currentSize1, particle._currentSize2, scale);
                             });
                         }
                         if (_this._isAnimationSheetEnabled) {
@@ -55691,14 +55717,16 @@ var BABYLON;
          * 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
          */
-        ParticleSystem.prototype.addSizeGradient = function (gradient, factor) {
+        ParticleSystem.prototype.addSizeGradient = function (gradient, factor, factor2) {
             if (!this._sizeGradients) {
                 this._sizeGradients = [];
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
+            sizeGradient.factor2 = factor2;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -56016,7 +56044,20 @@ var BABYLON;
                 }
                 particle.direction.scaleInPlace(emitPower);
                 particle.lifeTime = BABYLON.Scalar.RandomRange(this.minLifeTime, this.maxLifeTime);
-                particle.size = BABYLON.Scalar.RandomRange(this.minSize, this.maxSize);
+                if (!this._sizeGradients || this._sizeGradients.length === 0) {
+                    particle.size = BABYLON.Scalar.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;
+                    }
+                }
                 particle._initialSize = particle.size;
                 particle.scale.copyFromFloats(BABYLON.Scalar.RandomRange(this.minScaleX, this.maxScaleX), BABYLON.Scalar.RandomRange(this.minScaleY, this.maxScaleY));
                 particle.angularSpeed = BABYLON.Scalar.RandomRange(this.minAngularSpeed, this.maxAngularSpeed);
@@ -56452,10 +56493,14 @@ var BABYLON;
                 serializationObject.sizeGradients = [];
                 for (var _a = 0, sizeGradients_1 = sizeGradients; _a < sizeGradients_1.length; _a++) {
                     var sizeGradient = sizeGradients_1[_a];
-                    serializationObject.sizeGradients.push({
+                    var serializedGradient = {
                         gradient: sizeGradient.gradient,
-                        factor: sizeGradient.factor
-                    });
+                        factor1: sizeGradient.factor1
+                    };
+                    if (sizeGradient.factor2 !== undefined) {
+                        serializedGradient.factor2 = sizeGradient.factor2;
+                    }
+                    serializationObject.sizeGradients.push(serializedGradient);
                 }
             }
         };
@@ -56533,7 +56578,7 @@ var BABYLON;
             if (parsedParticleSystem.sizeGradients) {
                 for (var _b = 0, _c = parsedParticleSystem.sizeGradients; _b < _c.length; _b++) {
                     var sizeGradient = _c[_b];
-                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor);
+                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor1 !== undefined ? sizeGradient.factor1 : sizeGradient.factor, sizeGradient.factor2);
                 }
             }
             // Emitter
@@ -57623,7 +57668,7 @@ var BABYLON;
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -57893,7 +57938,7 @@ var BABYLON;
             for (var x = 0; x < textureWidth; x++) {
                 var ratio = x / textureWidth;
                 BABYLON.Tools.GetCurrentGradient(ratio, this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
                 });
             }
             this._sizeGradientsTexture = BABYLON.RawTexture.CreateRTexture(data, textureWidth, 1, this._scene, false, false, BABYLON.Texture.NEAREST_SAMPLINGMODE);

dist/preview release/es6.js

@@ -8526,6 +8526,17 @@ var BABYLON;
     var FactorGradient = /** @class */ (function () {
         function FactorGradient() {
         }
+        /**
+         * Will get a number picked randomly between factor1 and factor2.
+         * If factor2 is undefined then factor1 will be used
+         * @returns the picked number
+         */
+        FactorGradient.prototype.getFactor = function () {
+            if (this.factor2 === undefined) {
+                return this.factor1;
+            }
+            return BABYLON.Scalar.Lerp(this.factor1, this.factor2, Math.random());
+        };
         return FactorGradient;
     }());
     BABYLON.FactorGradient = FactorGradient;
@@ -55181,6 +55192,10 @@ var BABYLON;
             this._currentColor1 = new BABYLON.Color4(0, 0, 0, 0);
             /** @hidden */
             this._currentColor2 = new BABYLON.Color4(0, 0, 0, 0);
+            /** @hidden */
+            this._currentSize1 = 0;
+            /** @hidden */
+            this._currentSize2 = 0;
             if (!this.particleSystem.isAnimationSheetEnabled) {
                 return;
             }
@@ -55230,6 +55245,11 @@ var BABYLON;
                 other._currentColor1.copyFrom(this._currentColor1);
                 other._currentColor2.copyFrom(this._currentColor2);
             }
+            if (this._currentSizeGradient) {
+                other._currentSizeGradient = this._currentSizeGradient;
+                other._currentSize1 = this._currentSize1;
+                other._currentSize2 = this._currentSize2;
+            }
         };
         return Particle;
     }());
@@ -55383,6 +55403,7 @@ var BABYLON;
             this.gravity = BABYLON.Vector3.Zero();
             this._colorGradients = null;
             this._sizeGradients = null;
+            this._lifeTimeGradients = null;
             /**
              * Random color of each particle after it has been emitted, between color1 and color2 vectors
              */
@@ -55527,7 +55548,12 @@ var BABYLON;
                         // Gradient
                         if (_this._sizeGradients && _this._sizeGradients.length > 0) {
                             BABYLON.Tools.GetCurrentGradient(ratio, _this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                                if (currentGradient !== particle._currentSizeGradient) {
+                                    particle._currentSize1 = particle._currentSize2;
+                                    particle._currentSize2 = nextGradient.getFactor();
+                                    particle._currentSizeGradient = currentGradient;
+                                }
+                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(particle._currentSize1, particle._currentSize2, scale);
                             });
                         }
                         if (_this._isAnimationSheetEnabled) {
@@ -55691,14 +55717,16 @@ var BABYLON;
          * 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
          */
-        ParticleSystem.prototype.addSizeGradient = function (gradient, factor) {
+        ParticleSystem.prototype.addSizeGradient = function (gradient, factor, factor2) {
             if (!this._sizeGradients) {
                 this._sizeGradients = [];
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
+            sizeGradient.factor2 = factor2;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -56016,7 +56044,20 @@ var BABYLON;
                 }
                 particle.direction.scaleInPlace(emitPower);
                 particle.lifeTime = BABYLON.Scalar.RandomRange(this.minLifeTime, this.maxLifeTime);
-                particle.size = BABYLON.Scalar.RandomRange(this.minSize, this.maxSize);
+                if (!this._sizeGradients || this._sizeGradients.length === 0) {
+                    particle.size = BABYLON.Scalar.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;
+                    }
+                }
                 particle._initialSize = particle.size;
                 particle.scale.copyFromFloats(BABYLON.Scalar.RandomRange(this.minScaleX, this.maxScaleX), BABYLON.Scalar.RandomRange(this.minScaleY, this.maxScaleY));
                 particle.angularSpeed = BABYLON.Scalar.RandomRange(this.minAngularSpeed, this.maxAngularSpeed);
@@ -56452,10 +56493,14 @@ var BABYLON;
                 serializationObject.sizeGradients = [];
                 for (var _a = 0, sizeGradients_1 = sizeGradients; _a < sizeGradients_1.length; _a++) {
                     var sizeGradient = sizeGradients_1[_a];
-                    serializationObject.sizeGradients.push({
+                    var serializedGradient = {
                         gradient: sizeGradient.gradient,
-                        factor: sizeGradient.factor
-                    });
+                        factor1: sizeGradient.factor1
+                    };
+                    if (sizeGradient.factor2 !== undefined) {
+                        serializedGradient.factor2 = sizeGradient.factor2;
+                    }
+                    serializationObject.sizeGradients.push(serializedGradient);
                 }
             }
         };
@@ -56533,7 +56578,7 @@ var BABYLON;
             if (parsedParticleSystem.sizeGradients) {
                 for (var _b = 0, _c = parsedParticleSystem.sizeGradients; _b < _c.length; _b++) {
                     var sizeGradient = _c[_b];
-                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor);
+                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor1 !== undefined ? sizeGradient.factor1 : sizeGradient.factor, sizeGradient.factor2);
                 }
             }
             // Emitter
@@ -57623,7 +57668,7 @@ var BABYLON;
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -57893,7 +57938,7 @@ var BABYLON;
             for (var x = 0; x < textureWidth; x++) {
                 var ratio = x / textureWidth;
                 BABYLON.Tools.GetCurrentGradient(ratio, this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
                 });
             }
             this._sizeGradientsTexture = BABYLON.RawTexture.CreateRTexture(data, textureWidth, 1, this._scene, false, false, BABYLON.Texture.NEAREST_SAMPLINGMODE);

dist/preview release/viewer/babylon.viewer.max.js

@@ -8647,6 +8647,17 @@ var BABYLON;
     var FactorGradient = /** @class */ (function () {
         function FactorGradient() {
         }
+        /**
+         * Will get a number picked randomly between factor1 and factor2.
+         * If factor2 is undefined then factor1 will be used
+         * @returns the picked number
+         */
+        FactorGradient.prototype.getFactor = function () {
+            if (this.factor2 === undefined) {
+                return this.factor1;
+            }
+            return BABYLON.Scalar.Lerp(this.factor1, this.factor2, Math.random());
+        };
         return FactorGradient;
     }());
     BABYLON.FactorGradient = FactorGradient;
@@ -55302,6 +55313,10 @@ var BABYLON;
             this._currentColor1 = new BABYLON.Color4(0, 0, 0, 0);
             /** @hidden */
             this._currentColor2 = new BABYLON.Color4(0, 0, 0, 0);
+            /** @hidden */
+            this._currentSize1 = 0;
+            /** @hidden */
+            this._currentSize2 = 0;
             if (!this.particleSystem.isAnimationSheetEnabled) {
                 return;
             }
@@ -55351,6 +55366,11 @@ var BABYLON;
                 other._currentColor1.copyFrom(this._currentColor1);
                 other._currentColor2.copyFrom(this._currentColor2);
             }
+            if (this._currentSizeGradient) {
+                other._currentSizeGradient = this._currentSizeGradient;
+                other._currentSize1 = this._currentSize1;
+                other._currentSize2 = this._currentSize2;
+            }
         };
         return Particle;
     }());
@@ -55504,6 +55524,7 @@ var BABYLON;
             this.gravity = BABYLON.Vector3.Zero();
             this._colorGradients = null;
             this._sizeGradients = null;
+            this._lifeTimeGradients = null;
             /**
              * Random color of each particle after it has been emitted, between color1 and color2 vectors
              */
@@ -55648,7 +55669,12 @@ var BABYLON;
                         // Gradient
                         if (_this._sizeGradients && _this._sizeGradients.length > 0) {
                             BABYLON.Tools.GetCurrentGradient(ratio, _this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                                if (currentGradient !== particle._currentSizeGradient) {
+                                    particle._currentSize1 = particle._currentSize2;
+                                    particle._currentSize2 = nextGradient.getFactor();
+                                    particle._currentSizeGradient = currentGradient;
+                                }
+                                particle.size = particle._initialSize * BABYLON.Scalar.Lerp(particle._currentSize1, particle._currentSize2, scale);
                             });
                         }
                         if (_this._isAnimationSheetEnabled) {
@@ -55812,14 +55838,16 @@ var BABYLON;
          * 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
          */
-        ParticleSystem.prototype.addSizeGradient = function (gradient, factor) {
+        ParticleSystem.prototype.addSizeGradient = function (gradient, factor, factor2) {
             if (!this._sizeGradients) {
                 this._sizeGradients = [];
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
+            sizeGradient.factor2 = factor2;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -56137,7 +56165,20 @@ var BABYLON;
                 }
                 particle.direction.scaleInPlace(emitPower);
                 particle.lifeTime = BABYLON.Scalar.RandomRange(this.minLifeTime, this.maxLifeTime);
-                particle.size = BABYLON.Scalar.RandomRange(this.minSize, this.maxSize);
+                if (!this._sizeGradients || this._sizeGradients.length === 0) {
+                    particle.size = BABYLON.Scalar.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;
+                    }
+                }
                 particle._initialSize = particle.size;
                 particle.scale.copyFromFloats(BABYLON.Scalar.RandomRange(this.minScaleX, this.maxScaleX), BABYLON.Scalar.RandomRange(this.minScaleY, this.maxScaleY));
                 particle.angularSpeed = BABYLON.Scalar.RandomRange(this.minAngularSpeed, this.maxAngularSpeed);
@@ -56573,10 +56614,14 @@ var BABYLON;
                 serializationObject.sizeGradients = [];
                 for (var _a = 0, sizeGradients_1 = sizeGradients; _a < sizeGradients_1.length; _a++) {
                     var sizeGradient = sizeGradients_1[_a];
-                    serializationObject.sizeGradients.push({
+                    var serializedGradient = {
                         gradient: sizeGradient.gradient,
-                        factor: sizeGradient.factor
-                    });
+                        factor1: sizeGradient.factor1
+                    };
+                    if (sizeGradient.factor2 !== undefined) {
+                        serializedGradient.factor2 = sizeGradient.factor2;
+                    }
+                    serializationObject.sizeGradients.push(serializedGradient);
                 }
             }
         };
@@ -56654,7 +56699,7 @@ var BABYLON;
             if (parsedParticleSystem.sizeGradients) {
                 for (var _b = 0, _c = parsedParticleSystem.sizeGradients; _b < _c.length; _b++) {
                     var sizeGradient = _c[_b];
-                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor);
+                    particleSystem.addSizeGradient(sizeGradient.gradient, sizeGradient.factor1 !== undefined ? sizeGradient.factor1 : sizeGradient.factor, sizeGradient.factor2);
                 }
             }
             // Emitter
@@ -57744,7 +57789,7 @@ var BABYLON;
             }
             var sizeGradient = new BABYLON.FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
             this._sizeGradients.push(sizeGradient);
             this._sizeGradients.sort(function (a, b) {
                 if (a.gradient < b.gradient) {
@@ -58014,7 +58059,7 @@ var BABYLON;
             for (var x = 0; x < textureWidth; x++) {
                 var ratio = x / textureWidth;
                 BABYLON.Tools.GetCurrentGradient(ratio, this._sizeGradients, function (currentGradient, nextGradient, scale) {
-                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor, nextGradient.factor, scale);
+                    data[x] = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
                 });
             }
             this._sizeGradientsTexture = BABYLON.RawTexture.CreateRTexture(data, textureWidth, 1, this._scene, false, false, BABYLON.Texture.NEAREST_SAMPLINGMODE);

src/Particles/babylon.gpuParticleSystem.ts

@@ -513,7 +513,7 @@
 
             let sizeGradient = new FactorGradient();
             sizeGradient.gradient = gradient;
-            sizeGradient.factor = factor;
+            sizeGradient.factor1 = factor;
             this._sizeGradients.push(sizeGradient);
 
             this._sizeGradients.sort((a, b) => {
@@ -941,7 +941,7 @@
                 var ratio = x / textureWidth;
 
                 Tools.GetCurrentGradient(ratio, this._sizeGradients, (currentGradient, nextGradient, scale) => {
-                    data[x] = Scalar.Lerp((<FactorGradient>currentGradient).factor, (<FactorGradient>nextGradient).factor, scale);
+                    data[x] = Scalar.Lerp((<FactorGradient>currentGradient).factor1, (<FactorGradient>nextGradient).factor1, scale);
                 });
             }
 

src/Particles/babylon.particleSystem.ts

@@ -959,7 +959,20 @@
 
                 particle.lifeTime = Scalar.RandomRange(this.minLifeTime, this.maxLifeTime);
 
-                particle.size = Scalar.RandomRange(this.minSize, this.maxSize);
+
+                if (!this._sizeGradients || this._sizeGradients.length === 0) {
+                    particle.size = Scalar.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;
+                    }
+                }
                 particle._initialSize = particle.size;
                 particle.scale.copyFromFloats(Scalar.RandomRange(this.minScaleX, this.maxScaleX), Scalar.RandomRange(this.minScaleY, this.maxScaleY));
                 particle.angularSpeed = Scalar.RandomRange(this.minAngularSpeed, this.maxAngularSpeed);