@babylonjs/core 8.4.1 → 8.4.2

package/Particles/thinParticleSystem.d.ts

@@ -12,9 +12,12 @@ import type { IAnimatable } from "../Animations/animatable.interface.js";
 import { DrawWrapper } from "../Materials/drawWrapper.js";
 import type { DataBuffer } from "../Buffers/dataBuffer.js";
 import { Color4, Color3 } from "../Maths/math.color.js";
+import type { ISize } from "../Maths/math.size.js";
 import type { AbstractEngine } from "../Engines/abstractEngine.js";
 import "../Engines/Extensions/engine.alpha.js";
+import type { ProceduralTexture } from "../Materials/Textures/Procedurals/proceduralTexture.js";
 import { ShaderLanguage } from "../Materials/shaderLanguage.js";
+import type { _IExecutionQueueItem } 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.
@@ -34,18 +37,24 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
      * Do not forget that this function will be called on every frame so try to keep it simple and fast :)
      */
     updateFunction: (particles: Particle[]) => void;
-    private _emitterWorldMatrix;
-    private _emitterInverseWorldMatrix;
+    /** @internal */
+    _emitterWorldMatrix: Matrix;
+    /** @internal */
+    _emitterInverseWorldMatrix: Matrix;
+    private _startDirectionFunction;
     /**
      * This function can be defined to specify initial direction for every new particle.
      * It by default use the emitterType defined function
      */
-    startDirectionFunction: (worldMatrix: Matrix, directionToUpdate: Vector3, particle: Particle, isLocal: boolean) => void;
+    get startDirectionFunction(): Nullable<(worldMatrix: Matrix, directionToUpdate: Vector3, particle: Particle, isLocal: boolean) => void>;
+    set startDirectionFunction(value: Nullable<(worldMatrix: Matrix, directionToUpdate: Vector3, particle: Particle, isLocal: boolean) => void>);
+    private _startPositionFunction;
     /**
      * This function can be defined to specify initial position for every new particle.
      * It by default use the emitterType defined function
      */
-    startPositionFunction: (worldMatrix: Matrix, positionToUpdate: Vector3, particle: Particle, isLocal: boolean) => void;
+    get startPositionFunction(): Nullable<(worldMatrix: Matrix, positionToUpdate: Vector3, particle: Particle, isLocal: boolean) => void>;
+    set startPositionFunction(value: Nullable<(worldMatrix: Matrix, positionToUpdate: Vector3, particle: Particle, isLocal: boolean) => void>);
     /**
      * @internal
      */
@@ -63,6 +72,10 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
      * Sets a callback that will be triggered when the system is disposed
      */
     set onDispose(callback: () => void);
+    /** @internal */
+    _noiseTextureSize: Nullable<ISize>;
+    /** @internal */
+    _noiseTextureData: Nullable<Uint8Array>;
     private _particles;
     private _epsilon;
     private _capacity;
@@ -80,18 +93,24 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
     _customWrappers: {
         [blendMode: number]: Nullable<DrawWrapper>;
     };
-    private _scaledColorStep;
-    private _colorDiff;
-    private _scaledDirection;
-    private _scaledGravity;
+    /** @internal */
+    _scaledColorStep: Color4;
+    /** @internal */
+    _colorDiff: Color4;
+    /** @internal */
+    _scaledDirection: Vector3;
+    /** @internal */
+    _scaledGravity: Vector3;
     private _currentRenderId;
     private _alive;
     private _useInstancing;
     private _vertexArrayObject;
     private _started;
     private _stopped;
-    private _actualFrame;
-    private _scaledUpdateSpeed;
+    /** @internal */
+    _actualFrame: number;
+    /** @internal */
+    _scaledUpdateSpeed: number;
     private _vertexBufferSize;
     /** @internal */
     _currentEmitRateGradient: Nullable<FactorGradient>;
@@ -110,6 +129,43 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
     private readonly _rawTextureWidth;
     private _rampGradientsTexture;
     private _useRampGradients;
+    protected _updateQueueStart: Nullable<_IExecutionQueueItem>;
+    protected _colorProcessing: _IExecutionQueueItem;
+    protected _angularSpeedGradientProcessing: _IExecutionQueueItem;
+    protected _angularSpeedProcessing: _IExecutionQueueItem;
+    protected _velocityGradientProcessing: _IExecutionQueueItem;
+    protected _directionProcessing: _IExecutionQueueItem;
+    protected _limitVelocityGradientProcessing: _IExecutionQueueItem;
+    protected _positionProcessing: _IExecutionQueueItem;
+    protected _dragGradientProcessing: _IExecutionQueueItem;
+    protected _noiseProcessing: _IExecutionQueueItem;
+    protected _gravityProcessing: _IExecutionQueueItem;
+    protected _sizeGradientProcessing: _IExecutionQueueItem;
+    protected _remapGradientProcessing: _IExecutionQueueItem;
+    private _lifeTimeCreation;
+    private _positionCreation;
+    private _isLocalCreation;
+    private _directionCreation;
+    private _emitPowerCreation;
+    private _sizeCreation;
+    private _startSizeCreation;
+    private _angleCreation;
+    private _velocityCreation;
+    private _limitVelocityCreation;
+    private _dragCreation;
+    private _colorCreation;
+    private _sheetCreation;
+    private _rampCreation;
+    private _noiseCreation;
+    private _createQueueStart;
+    /** @internal */
+    _directionScale: number;
+    /** @internal */
+    _tempScaledUpdateSpeed: number;
+    /** @internal */
+    _ratio: number;
+    /** @internal */
+    _emitPower: number;
     /** Gets or sets a matrix to use to compute projection */
     defaultProjectionMatrix: Matrix;
     /** Gets or sets a matrix to use to compute view */
@@ -119,10 +175,12 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
      */
     get useRampGradients(): boolean;
     set useRampGradients(value: boolean);
+    private _isLocal;
     /**
      * Specifies if the particles are updated in emitter local space or world space
      */
-    isLocal: boolean;
+    get isLocal(): boolean;
+    set isLocal(value: boolean);
     /** Indicates that the particle system is CPU based */
     readonly isGPU = false;
     /**
@@ -135,6 +193,9 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
      * Gets the shader language used in this material.
      */
     get shaderLanguage(): ShaderLanguage;
+    /** @internal */
+    get _isAnimationSheetEnabled(): boolean;
+    set _isAnimationSheetEnabled(value: boolean);
     /**
      * Gets the number of particles active at the same time.
      * @returns The number of active particles.
@@ -183,6 +244,8 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
      * Gets the index buffer used by the particle system (or null if no index buffer is used (if _useInstancing=true))
      */
     get indexBuffer(): Nullable<DataBuffer>;
+    get noiseTexture(): Nullable<ProceduralTexture>;
+    set noiseTexture(value: Nullable<ProceduralTexture>);
     /**
      * 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.
@@ -206,6 +269,10 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
     clone(name: string, newEmitter: any, cloneTexture?: boolean): ThinParticleSystem;
     private _addFactorGradient;
     private _removeFactorGradient;
+    private _syncLifeTimeCreation;
+    private _syncStartSizeCreation;
+    get targetStopDuration(): number;
+    set targetStopDuration(value: number);
     /**
      * Adds a new life time gradient
      * @param gradient defines the gradient to use (between 0 and 1)
@@ -387,7 +454,8 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
      * Resets the draw wrappers cache
      */
     resetDrawCache(): void;
-    private _fetchR;
+    /** @internal */
+    _fetchR(u: number, v: number, width: number, height: number, pixels: Uint8Array): number;
     protected _reset(): void;
     private _resetEffect;
     private _createVertexBuffers;
@@ -438,6 +506,7 @@ export declare class ThinParticleSystem extends BaseParticleSystem implements ID
     private _createParticle;
     /** @internal */
     _prepareParticle(particle: Particle): void;
+    private _createNewOnes;
     private _update;
     /**
      * @internal

package/Particles/thinParticleSystem.function.d.ts

@@ -0,0 +1,84 @@
+import type { Particle } from "./particle.js";
+import type { ThinParticleSystem } from "./thinParticleSystem.js";
+/** Color */
+/** @internal */
+export declare function _CreateColorData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateColorGradientsData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessColorGradients(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessColor(particle: Particle, system: ThinParticleSystem): void;
+/** Angular speed */
+/** @internal */
+export declare function _ProcessAngularSpeedGradients(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessAngularSpeed(particle: Particle, system: ThinParticleSystem): void;
+/** Velocity & direction */
+/** @internal */
+export declare function _CreateDirectionData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateCustomDirectionData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateVelocityGradients(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateLimitVelocityGradients(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessVelocityGradients(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessLimitVelocityGradients(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessDirection(particle: Particle, system: ThinParticleSystem): void;
+/** Position */
+/** @internal */
+export declare function _CreatePositionData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateCustomPositionData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateIsLocalData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessPosition(particle: Particle, system: ThinParticleSystem): void;
+/** Drag */
+/** @internal */
+export declare function _CreateDragData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessDragGradients(particle: Particle, system: ThinParticleSystem): void;
+/** Noise */
+/** @internal */
+export declare function _CreateNoiseData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessNoise(particle: Particle, system: ThinParticleSystem): void;
+/** Gravity */
+/** @internal */
+export declare function _ProcessGravity(particle: Particle, system: ThinParticleSystem): void;
+/** Size */
+/** @internal */
+export declare function _CreateSizeData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateSizeGradientsData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateStartSizeGradientsData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _ProcessSizeGradients(particle: Particle, system: ThinParticleSystem): void;
+/** Ramp */
+/** @internal */
+export declare function _CreateRampData(particle: Particle, system: ThinParticleSystem): void;
+/** Remap */
+/** @internal */
+export declare function _ProcessRemapGradients(particle: Particle, system: ThinParticleSystem): void;
+/** Life */
+/** @internal */
+export declare function _CreateLifeGradientsData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateLifetimeData(particle: Particle, system: ThinParticleSystem): void;
+/** Emit power */
+/** @internal */
+export declare function _CreateEmitPowerData(particle: Particle, system: ThinParticleSystem): void;
+/** Angle */
+/** @internal */
+export declare function _CreateAngleData(particle: Particle, system: ThinParticleSystem): void;
+/** @internal */
+export declare function _CreateAngleGradientsData(particle: Particle, system: ThinParticleSystem): void;
+/** Sheet */
+/** @internal */
+export declare function _CreateSheetData(particle: Particle, system: ThinParticleSystem): void;

package/Particles/thinParticleSystem.function.js

@@ -0,0 +1,340 @@
+import { Color4 } from "../Maths/math.color.js";
+import { GradientHelper } from "../Misc/gradients.js";
+import { Clamp, Lerp, RandomRange } from "../Maths/math.scalar.functions.js";
+import { TmpVectors, Vector3, Vector4 } from "../Maths/math.vector.js";
+/** Color */
+/** @internal */
+export function _CreateColorData(particle, system) {
+    const step = RandomRange(0, 1.0);
+    Color4.LerpToRef(system.color1, system.color2, step, particle.color);
+    system.colorDead.subtractToRef(particle.color, system._colorDiff);
+    system._colorDiff.scaleToRef(1.0 / particle.lifeTime, particle.colorStep);
+}
+/** @internal */
+export function _CreateColorGradientsData(particle, system) {
+    particle._currentColorGradient = system._colorGradients[0];
+    particle._currentColorGradient.getColorToRef(particle.color);
+    particle._currentColor1.copyFrom(particle.color);
+    if (system._colorGradients.length > 1) {
+        system._colorGradients[1].getColorToRef(particle._currentColor2);
+    }
+    else {
+        particle._currentColor2.copyFrom(particle.color);
+    }
+}
+/** @internal */
+export function _ProcessColorGradients(particle, system) {
+    const colorGradients = system._colorGradients;
+    GradientHelper.GetCurrentGradient(system._ratio, 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);
+    });
+}
+/** @internal */
+export function _ProcessColor(particle, system) {
+    particle.colorStep.scaleToRef(system._scaledUpdateSpeed, system._scaledColorStep);
+    particle.color.addInPlace(system._scaledColorStep);
+    if (particle.color.a < 0) {
+        particle.color.a = 0;
+    }
+}
+/** Angular speed */
+/** @internal */
+export function _ProcessAngularSpeedGradients(particle, system) {
+    GradientHelper.GetCurrentGradient(system._ratio, system._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);
+    });
+}
+/** @internal */
+export function _ProcessAngularSpeed(particle, system) {
+    particle.angle += particle.angularSpeed * system._scaledUpdateSpeed;
+}
+/** Velocity & direction */
+/** @internal */
+export function _CreateDirectionData(particle, system) {
+    system.particleEmitterType.startDirectionFunction(system._emitterWorldMatrix, particle.direction, particle, system.isLocal, system._emitterInverseWorldMatrix);
+}
+/** @internal */
+export function _CreateCustomDirectionData(particle, system) {
+    system.startDirectionFunction(system._emitterWorldMatrix, particle.direction, particle, system.isLocal);
+}
+/** @internal */
+export function _CreateVelocityGradients(particle, system) {
+    particle._currentVelocityGradient = system._velocityGradients[0];
+    particle._currentVelocity1 = particle._currentVelocityGradient.getFactor();
+    if (system._velocityGradients.length > 1) {
+        particle._currentVelocity2 = system._velocityGradients[1].getFactor();
+    }
+    else {
+        particle._currentVelocity2 = particle._currentVelocity1;
+    }
+}
+/** @internal */
+export function _CreateLimitVelocityGradients(particle, system) {
+    particle._currentLimitVelocityGradient = system._limitVelocityGradients[0];
+    particle._currentLimitVelocity1 = particle._currentLimitVelocityGradient.getFactor();
+    if (system._limitVelocityGradients.length > 1) {
+        particle._currentLimitVelocity2 = system._limitVelocityGradients[1].getFactor();
+    }
+    else {
+        particle._currentLimitVelocity2 = particle._currentLimitVelocity1;
+    }
+}
+/** @internal */
+export function _ProcessVelocityGradients(particle, system) {
+    GradientHelper.GetCurrentGradient(system._ratio, system._velocityGradients, (currentGradient, nextGradient, scale) => {
+        if (currentGradient !== particle._currentVelocityGradient) {
+            particle._currentVelocity1 = particle._currentVelocity2;
+            particle._currentVelocity2 = nextGradient.getFactor();
+            particle._currentVelocityGradient = currentGradient;
+        }
+        system._directionScale *= Lerp(particle._currentVelocity1, particle._currentVelocity2, scale);
+    });
+}
+/** @internal */
+export function _ProcessLimitVelocityGradients(particle, system) {
+    GradientHelper.GetCurrentGradient(system._ratio, system._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(system.limitVelocityDamping);
+        }
+    });
+}
+/** @internal */
+export function _ProcessDirection(particle, system) {
+    particle.direction.scaleToRef(system._directionScale, system._scaledDirection);
+}
+/** Position */
+/** @internal */
+export function _CreatePositionData(particle, system) {
+    system.particleEmitterType.startPositionFunction(system._emitterWorldMatrix, particle.position, particle, system.isLocal);
+}
+/** @internal */
+export function _CreateCustomPositionData(particle, system) {
+    system.startPositionFunction(system._emitterWorldMatrix, particle.position, particle, system.isLocal);
+}
+/** @internal */
+export function _CreateIsLocalData(particle, system) {
+    if (!particle._localPosition) {
+        particle._localPosition = particle.position.clone();
+    }
+    else {
+        particle._localPosition.copyFrom(particle.position);
+    }
+    Vector3.TransformCoordinatesToRef(particle._localPosition, system._emitterWorldMatrix, particle.position);
+}
+/** @internal */
+export function _ProcessPosition(particle, system) {
+    if (system.isLocal && particle._localPosition) {
+        particle._localPosition.addInPlace(system._scaledDirection);
+        Vector3.TransformCoordinatesToRef(particle._localPosition, system._emitterWorldMatrix, particle.position);
+    }
+    else {
+        particle.position.addInPlace(system._scaledDirection);
+    }
+}
+/** Drag */
+/** @internal */
+export function _CreateDragData(particle, system) {
+    particle._currentDragGradient = system._dragGradients[0];
+    particle._currentDrag1 = particle._currentDragGradient.getFactor();
+    if (system._dragGradients.length > 1) {
+        particle._currentDrag2 = system._dragGradients[1].getFactor();
+    }
+    else {
+        particle._currentDrag2 = particle._currentDrag1;
+    }
+}
+/** @internal */
+export function _ProcessDragGradients(particle, system) {
+    GradientHelper.GetCurrentGradient(system._ratio, system._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);
+        system._scaledDirection.scaleInPlace(1.0 - drag);
+    });
+}
+/** Noise */
+/** @internal */
+export function _CreateNoiseData(particle, system) {
+    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());
+    }
+}
+/** @internal */
+export function _ProcessNoise(particle, system) {
+    const noiseTextureData = system._noiseTextureData;
+    const noiseTextureSize = system._noiseTextureSize;
+    if (noiseTextureData && noiseTextureSize && particle._randomNoiseCoordinates1) {
+        const fetchedColorR = system._fetchR(particle._randomNoiseCoordinates1.x, particle._randomNoiseCoordinates1.y, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
+        const fetchedColorG = system._fetchR(particle._randomNoiseCoordinates1.z, particle._randomNoiseCoordinates2.x, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
+        const fetchedColorB = system._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) * system.noiseStrength.x, (2 * fetchedColorG - 1) * system.noiseStrength.y, (2 * fetchedColorB - 1) * system.noiseStrength.z);
+        force.scaleToRef(system._tempScaledUpdateSpeed, scaledForce);
+        particle.direction.addInPlace(scaledForce);
+    }
+}
+/** Gravity */
+/** @internal */
+export function _ProcessGravity(particle, system) {
+    system.gravity.scaleToRef(system._tempScaledUpdateSpeed, system._scaledGravity);
+    particle.direction.addInPlace(system._scaledGravity);
+}
+/** Size */
+/** @internal */
+export function _CreateSizeData(particle, system) {
+    particle.size = RandomRange(system.minSize, system.maxSize);
+    particle.scale.copyFromFloats(RandomRange(system.minScaleX, system.maxScaleX), RandomRange(system.minScaleY, system.maxScaleY));
+}
+/** @internal */
+export function _CreateSizeGradientsData(particle, system) {
+    particle._currentSizeGradient = system._sizeGradients[0];
+    particle._currentSize1 = particle._currentSizeGradient.getFactor();
+    particle.size = particle._currentSize1;
+    if (system._sizeGradients.length > 1) {
+        particle._currentSize2 = system._sizeGradients[1].getFactor();
+    }
+    else {
+        particle._currentSize2 = particle._currentSize1;
+    }
+    particle.scale.copyFromFloats(RandomRange(system.minScaleX, system.maxScaleX), RandomRange(system.minScaleY, system.maxScaleY));
+}
+/** @internal */
+export function _CreateStartSizeGradientsData(particle, system) {
+    const ratio = system._actualFrame / system.targetStopDuration;
+    GradientHelper.GetCurrentGradient(ratio, system._startSizeGradients, (currentGradient, nextGradient, scale) => {
+        if (currentGradient !== system._currentStartSizeGradient) {
+            system._currentStartSize1 = system._currentStartSize2;
+            system._currentStartSize2 = nextGradient.getFactor();
+            system._currentStartSizeGradient = currentGradient;
+        }
+        const value = Lerp(system._currentStartSize1, system._currentStartSize2, scale);
+        particle.scale.scaleInPlace(value);
+    });
+}
+/** @internal */
+export function _ProcessSizeGradients(particle, system) {
+    GradientHelper.GetCurrentGradient(system._ratio, system._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);
+    });
+}
+/** Ramp */
+/** @internal */
+export function _CreateRampData(particle, system) {
+    particle.remapData = new Vector4(0, 1, 0, 1);
+}
+/** Remap */
+/** @internal */
+export function _ProcessRemapGradients(particle, system) {
+    if (system._colorRemapGradients && system._colorRemapGradients.length > 0) {
+        GradientHelper.GetCurrentGradient(system._ratio, system._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 (system._alphaRemapGradients && system._alphaRemapGradients.length > 0) {
+        GradientHelper.GetCurrentGradient(system._ratio, system._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;
+        });
+    }
+}
+/** Life */
+/** @internal */
+export function _CreateLifeGradientsData(particle, system) {
+    const ratio = Clamp(system._actualFrame / system.targetStopDuration);
+    GradientHelper.GetCurrentGradient(ratio, system._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);
+    });
+    system._emitPower = RandomRange(system.minEmitPower, system.maxEmitPower);
+}
+/** @internal */
+export function _CreateLifetimeData(particle, system) {
+    particle.lifeTime = RandomRange(system.minLifeTime, system.maxLifeTime);
+    system._emitPower = RandomRange(system.minEmitPower, system.maxEmitPower);
+}
+/** Emit power */
+/** @internal */
+export function _CreateEmitPowerData(particle, system) {
+    if (system._emitPower === 0) {
+        if (!particle._initialDirection) {
+            particle._initialDirection = particle.direction.clone();
+        }
+        else {
+            particle._initialDirection.copyFrom(particle.direction);
+        }
+        particle.direction.set(0, 0, 0);
+    }
+    else {
+        particle._initialDirection = null;
+        particle.direction.scaleInPlace(system._emitPower);
+    }
+    // Inherited Velocity
+    particle.direction.addInPlace(system._inheritedVelocityOffset);
+}
+/** Angle */
+/** @internal */
+export function _CreateAngleData(particle, system) {
+    particle.angularSpeed = RandomRange(system.minAngularSpeed, system.maxAngularSpeed);
+    particle.angle = RandomRange(system.minInitialRotation, system.maxInitialRotation);
+}
+/** @internal */
+export function _CreateAngleGradientsData(particle, system) {
+    particle._currentAngularSpeedGradient = system._angularSpeedGradients[0];
+    particle.angularSpeed = particle._currentAngularSpeedGradient.getFactor();
+    particle._currentAngularSpeed1 = particle.angularSpeed;
+    if (system._angularSpeedGradients.length > 1) {
+        particle._currentAngularSpeed2 = system._angularSpeedGradients[1].getFactor();
+    }
+    else {
+        particle._currentAngularSpeed2 = particle._currentAngularSpeed1;
+    }
+    particle.angle = RandomRange(system.minInitialRotation, system.maxInitialRotation);
+}
+/** Sheet */
+/** @internal */
+export function _CreateSheetData(particle, system) {
+    particle._initialStartSpriteCellID = system.startSpriteCellID;
+    particle._initialEndSpriteCellID = system.endSpriteCellID;
+    particle._initialSpriteCellLoop = system.spriteCellLoop;
+}
+//# sourceMappingURL=thinParticleSystem.function.js.map