@babylonjs/core 8.44.0 → 8.45.0

package/Particles/Node/nodeParticleSystemSet.helper.js

@@ -20,8 +20,10 @@ import { CylinderShapeBlock } from "./Blocks/Emitters/cylinderShapeBlock.js";
 import { CustomShapeBlock } from "./Blocks/Emitters/customShapeBlock.js";
 import { MeshShapeBlock } from "./Blocks/Emitters/meshShapeBlock.js";
 import { PointShapeBlock } from "./Blocks/Emitters/pointShapeBlock.js";
+import { SetupSpriteSheetBlock } from "./Blocks/Emitters/setupSpriteSheetBlock.js";
 import { SphereShapeBlock } from "./Blocks/Emitters/sphereShapeBlock.js";
 import { UpdateAngleBlock } from "./Blocks/Update/updateAngleBlock.js";
+import { BasicSpriteUpdateBlock } from "./Blocks/Update/basicSpriteUpdateBlock.js";
 import { UpdateColorBlock } from "./Blocks/Update/updateColorBlock.js";
 import { UpdateDirectionBlock } from "./Blocks/Update/updateDirectionBlock.js";
 import { UpdateNoiseBlock } from "./Blocks/Update/updateNoiseBlock.js";
@@ -48,14 +50,10 @@ export async function ConvertToNodeParticleSystemSetAsync(name, particleSystemsL
 async function _ExtractDatafromParticleSystemAsync(newSet, oldSystem, context) {
     // CreateParticle block group
     const createParticleOutput = _CreateParticleBlockGroup(oldSystem, context);
-    // Emitter Shape block
-    const shapeOutput = _EmitterShapeBlock(oldSystem);
-    createParticleOutput.particle.connectTo(shapeOutput.particle);
     // UpdateParticle block group
-    const updateParticleOutput = _UpdateParticleBlockGroup(shapeOutput.output, oldSystem, context);
+    const updateParticleOutput = _UpdateParticleBlockGroup(createParticleOutput, oldSystem, context);
     // System block
-    const newSystem = _SystemBlockGroup(oldSystem, context);
-    updateParticleOutput.connectTo(newSystem.particle);
+    const newSystem = _SystemBlockGroup(updateParticleOutput, oldSystem, context);
     // Register
     newSet.systemBlocks.push(newSystem);
 }
@@ -65,6 +63,7 @@ async function _ExtractDatafromParticleSystemAsync(newSet, oldSystem, context) {
 function _CreateParticleBlockGroup(oldSystem, context) {
     // Create particle block
     const createParticleBlock = new CreateParticleBlock("Create Particle");
+    let createdParticle = createParticleBlock.particle;
     _CreateParticleLifetimeBlockGroup(oldSystem, context).connectTo(createParticleBlock.lifeTime);
     _CreateParticleEmitPowerBlockGroup(oldSystem).connectTo(createParticleBlock.emitPower);
     _CreateParticleSizeBlockGroup(oldSystem, context).connectTo(createParticleBlock.size);
@@ -72,8 +71,14 @@ function _CreateParticleBlockGroup(oldSystem, context) {
     _CreateParticleAngleBlockGroup(oldSystem).connectTo(createParticleBlock.angle);
     _CreateParticleColorBlockGroup(oldSystem, context).connectTo(createParticleBlock.color);
     // Dead color
-    _CreateAndConnectInput("Dead Color", oldSystem.colorDead, createParticleBlock.colorDead);
-    return createParticleBlock;
+    _CreateAndConnectInput("Dead Color", oldSystem.colorDead.clone(), createParticleBlock.colorDead);
+    // Emitter shape
+    createdParticle = _EmitterShapeBlock(createdParticle, oldSystem);
+    // Sprite sheet setup
+    if (oldSystem.isAnimationSheetEnabled) {
+        createdParticle = _SpriteSheetBlock(createdParticle, oldSystem);
+    }
+    return createdParticle;
 }
 /**
  * Creates the group of blocks that represent the particle lifetime
@@ -83,7 +88,7 @@ function _CreateParticleBlockGroup(oldSystem, context) {
  */
 function _CreateParticleLifetimeBlockGroup(oldSystem, context) {
     if (oldSystem.targetStopDuration && oldSystem._lifeTimeGradients && oldSystem._lifeTimeGradients.length > 0) {
-        context.timeToStopTimeRatioBlockGroupOutput = _CreateTimeToStopTimeRatioBlockGroup(oldSystem, context);
+        context.timeToStopTimeRatioBlockGroupOutput = _CreateTimeToStopTimeRatioBlockGroup(oldSystem.targetStopDuration, context);
         const gradientBlockGroupOutput = _CreateGradientBlockGroup(context.timeToStopTimeRatioBlockGroupOutput, oldSystem._lifeTimeGradients, ParticleRandomBlockLocks.PerParticle, "Lifetime");
         return gradientBlockGroupOutput;
     }
@@ -136,7 +141,7 @@ function _CreateParticleScaleBlockGroup(oldSystem, context) {
     _CreateAndConnectInput("Max Scale", new Vector2(oldSystem.maxScaleX, oldSystem.maxScaleY), randomScaleBlock.max);
     if (oldSystem.targetStopDuration && oldSystem._startSizeGradients && oldSystem._startSizeGradients.length > 0) {
         // Create the start size gradient
-        context.timeToStopTimeRatioBlockGroupOutput = _CreateTimeToStopTimeRatioBlockGroup(oldSystem, context);
+        context.timeToStopTimeRatioBlockGroupOutput = _CreateTimeToStopTimeRatioBlockGroup(oldSystem.targetStopDuration, context);
         const gradientBlockGroupOutput = _CreateGradientBlockGroup(context.timeToStopTimeRatioBlockGroupOutput, oldSystem._startSizeGradients, ParticleRandomBlockLocks.PerParticle, "Start Size");
         // Multiply the initial random scale by the start size gradient
         const multiplyScaleBlock = new ParticleMathBlock("Multiply Scale by Start Size Gradient");
@@ -173,8 +178,8 @@ function _CreateParticleColorBlockGroup(oldSystem, context) {
     }
     else {
         const randomColorBlock = new ParticleRandomBlock("Random color");
-        _CreateAndConnectInput("Color 1", oldSystem.color1, randomColorBlock.min);
-        _CreateAndConnectInput("Color 2", oldSystem.color2, randomColorBlock.max);
+        _CreateAndConnectInput("Color 1", oldSystem.color1.clone(), randomColorBlock.min);
+        _CreateAndConnectInput("Color 2", oldSystem.color2.clone(), randomColorBlock.max);
         return randomColorBlock.output;
     }
 }
@@ -200,8 +205,7 @@ function _CreateParticleInitialValueFromGradient(gradients) {
         return sizeBlock.output;
     }
 }
-// ------------- EMITTER SHAPE FUNCTIONS -------------
-function _EmitterShapeBlock(oldSystem) {
+function _EmitterShapeBlock(particle, oldSystem) {
     const emitter = oldSystem.particleEmitterType;
     if (!emitter) {
         throw new Error("Particle system has no emitter type.");
@@ -212,10 +216,10 @@ function _EmitterShapeBlock(oldSystem) {
             const source = emitter;
             shapeBlock = new BoxShapeBlock("Box Shape");
             const target = shapeBlock;
-            _CreateAndConnectInput("Direction 1", source.direction1, target.direction1);
-            _CreateAndConnectInput("Direction 2", source.direction2, target.direction2);
-            _CreateAndConnectInput("Min Emit Box", source.minEmitBox, target.minEmitBox);
-            _CreateAndConnectInput("Max Emit Box", source.maxEmitBox, target.maxEmitBox);
+            _CreateAndConnectInput("Direction 1", source.direction1.clone(), target.direction1);
+            _CreateAndConnectInput("Direction 2", source.direction2.clone(), target.direction2);
+            _CreateAndConnectInput("Min Emit Box", source.minEmitBox.clone(), target.minEmitBox);
+            _CreateAndConnectInput("Max Emit Box", source.maxEmitBox.clone(), target.maxEmitBox);
             break;
         }
         case "ConeParticleEmitter": {
@@ -239,8 +243,8 @@ function _EmitterShapeBlock(oldSystem) {
             _CreateAndConnectInput("Angle", source.angle, target.angle);
             _CreateAndConnectInput("Radius Range", source.radiusRange, target.radiusRange);
             _CreateAndConnectInput("Height Range", source.heightRange, target.heightRange);
-            _CreateAndConnectInput("Direction 1", source.direction1, target.direction1);
-            _CreateAndConnectInput("Direction 2", source.direction2, target.direction2);
+            _CreateAndConnectInput("Direction 1", source.direction1.clone(), target.direction1);
+            _CreateAndConnectInput("Direction 2", source.direction2.clone(), target.direction2);
             break;
         }
         case "CustomParticleEmitter": {
@@ -269,8 +273,8 @@ function _EmitterShapeBlock(oldSystem) {
             _CreateAndConnectInput("Height", source.height, target.height);
             _CreateAndConnectInput("Radius", source.radius, target.radius);
             _CreateAndConnectInput("Radius Range", source.radiusRange, target.radiusRange);
-            _CreateAndConnectInput("Direction 1", source.direction1, target.direction1);
-            _CreateAndConnectInput("Direction 2", source.direction2, target.direction2);
+            _CreateAndConnectInput("Direction 1", source.direction1.clone(), target.direction1);
+            _CreateAndConnectInput("Direction 2", source.direction2.clone(), target.direction2);
             break;
         }
         case "HemisphericParticleEmitter": {
@@ -288,8 +292,8 @@ function _EmitterShapeBlock(oldSystem) {
             shapeBlock = new MeshShapeBlock("Mesh Shape");
             const target = shapeBlock;
             target.useMeshNormalsForDirection = source.useMeshNormalsForDirection;
-            _CreateAndConnectInput("Direction 1", source.direction1, target.direction1);
-            _CreateAndConnectInput("Direction 2", source.direction2, target.direction2);
+            _CreateAndConnectInput("Direction 1", source.direction1.clone(), target.direction1);
+            _CreateAndConnectInput("Direction 2", source.direction2.clone(), target.direction2);
             target.mesh = source.mesh;
             break;
         }
@@ -297,8 +301,8 @@ function _EmitterShapeBlock(oldSystem) {
             const source = emitter;
             shapeBlock = new PointShapeBlock("Point Shape");
             const target = shapeBlock;
-            _CreateAndConnectInput("Direction 1", source.direction1, target.direction1);
-            _CreateAndConnectInput("Direction 2", source.direction2, target.direction2);
+            _CreateAndConnectInput("Direction 1", source.direction1.clone(), target.direction1);
+            _CreateAndConnectInput("Direction 2", source.direction2.clone(), target.direction2);
             break;
         }
         case "SphereParticleEmitter": {
@@ -316,15 +320,27 @@ function _EmitterShapeBlock(oldSystem) {
             const target = shapeBlock;
             _CreateAndConnectInput("Radius", source.radius, target.radius);
             _CreateAndConnectInput("Radius Range", source.radiusRange, target.radiusRange);
-            _CreateAndConnectInput("Direction1", source.direction1, target.direction1);
-            _CreateAndConnectInput("Direction2", source.direction2, target.direction2);
+            _CreateAndConnectInput("Direction1", source.direction1.clone(), target.direction1);
+            _CreateAndConnectInput("Direction2", source.direction2.clone(), target.direction2);
             break;
         }
     }
     if (!shapeBlock) {
         throw new Error(`Unsupported particle emitter type: ${emitter.getClassName()}`);
     }
-    return shapeBlock;
+    particle.connectTo(shapeBlock.particle);
+    return shapeBlock.output;
+}
+function _SpriteSheetBlock(particle, oldSystem) {
+    const spriteSheetBlock = new SetupSpriteSheetBlock("Sprite Sheet Setup");
+    particle.connectTo(spriteSheetBlock.particle);
+    spriteSheetBlock.start = oldSystem.startSpriteCellID;
+    spriteSheetBlock.end = oldSystem.endSpriteCellID;
+    spriteSheetBlock.width = oldSystem.spriteCellWidth;
+    spriteSheetBlock.height = oldSystem.spriteCellHeight;
+    spriteSheetBlock.loop = oldSystem.spriteCellLoop;
+    spriteSheetBlock.randomStartCell = oldSystem.spriteRandomStartCell;
+    return spriteSheetBlock.output;
 }
 // ------------- UPDATE PARTICLE FUNCTIONS -------------
 /**
@@ -339,7 +355,7 @@ function _EmitterShapeBlock(oldSystem) {
 function _UpdateParticleBlockGroup(inputParticle, oldSystem, context) {
     let updatedParticle = inputParticle;
     updatedParticle = _UpdateParticleColorBlockGroup(updatedParticle, oldSystem._colorGradients, context);
-    updatedParticle = _UpdateParticleAngleBlockGroup(updatedParticle, oldSystem, context);
+    updatedParticle = _UpdateParticleAngleBlockGroup(updatedParticle, oldSystem._angularSpeedGradients, oldSystem.minAngularSpeed, oldSystem.maxAngularSpeed, context);
     if (oldSystem._velocityGradients && oldSystem._velocityGradients.length > 0) {
         context.scaledDirection = _UpdateParticleVelocityGradientBlockGroup(oldSystem._velocityGradients, context);
     }
@@ -351,7 +367,7 @@ function _UpdateParticleBlockGroup(inputParticle, oldSystem, context) {
         updatedParticle = _UpdateParticleVelocityLimitGradientBlockGroup(updatedParticle, oldSystem._limitVelocityGradients, oldSystem.limitVelocityDamping, context);
     }
     if (oldSystem.noiseTexture && oldSystem.noiseStrength) {
-        updatedParticle = _UpdateParticleNoiseBlockGroup(updatedParticle, oldSystem.noiseTexture, oldSystem.noiseStrength);
+        updatedParticle = _UpdateParticleNoiseBlockGroup(updatedParticle, oldSystem.noiseTexture.clone(), oldSystem.noiseStrength.clone());
     }
     if (oldSystem._sizeGradients && oldSystem._sizeGradients.length > 0) {
         updatedParticle = _UpdateParticleSizeGradientBlockGroup(updatedParticle, oldSystem._sizeGradients, context);
@@ -359,6 +375,9 @@ function _UpdateParticleBlockGroup(inputParticle, oldSystem, context) {
     if (oldSystem.gravity.equalsToFloats(0, 0, 0) === false) {
         updatedParticle = _UpdateParticleGravityBlockGroup(updatedParticle, oldSystem.gravity);
     }
+    if (oldSystem.isAnimationSheetEnabled) {
+        updatedParticle = _UpdateParticleSpriteCellBlockGroup(updatedParticle);
+    }
     return updatedParticle;
 }
 /**
@@ -391,19 +410,21 @@ function _UpdateParticleColorBlockGroup(inputParticle, colorGradients, context)
 /**
  * Creates the group of blocks that represent the particle angle update
  * @param inputParticle The input particle to update
- * @param oldSystem The old particle system to convert
+ * @param angularSpeedGradients The angular speed gradients (if any)
+ * @param minAngularSpeed The minimum angular speed
+ * @param maxAngularSpeed The maximum angular speed
  * @param context The context of the current conversion
  * @returns The output of the group of blocks that represent the particle color update
  */
-function _UpdateParticleAngleBlockGroup(inputParticle, oldSystem, context) {
+function _UpdateParticleAngleBlockGroup(inputParticle, angularSpeedGradients, minAngularSpeed, maxAngularSpeed, context) {
     // We will try to use gradients if they exist
     // If not, we will try to use min/max angular speed
     let angularSpeedCalculation = null;
-    if (oldSystem._angularSpeedGradients && oldSystem._angularSpeedGradients.length > 0) {
-        angularSpeedCalculation = _UpdateParticleAngularSpeedGradientBlockGroup(oldSystem._angularSpeedGradients, context);
+    if (angularSpeedGradients && angularSpeedGradients.length > 0) {
+        angularSpeedCalculation = _UpdateParticleAngularSpeedGradientBlockGroup(angularSpeedGradients, context);
     }
-    else if (oldSystem.minAngularSpeed !== 0 || oldSystem.maxAngularSpeed !== 0) {
-        angularSpeedCalculation = _UpdateParticleAngularSpeedBlockGroup(oldSystem.minAngularSpeed, oldSystem.maxAngularSpeed);
+    else if (minAngularSpeed !== 0 || maxAngularSpeed !== 0) {
+        angularSpeedCalculation = _UpdateParticleAngularSpeedBlockGroup(minAngularSpeed, maxAngularSpeed);
     }
     // If we have an angular speed calculation, then update the angle
     if (angularSpeedCalculation) {
@@ -595,6 +616,16 @@ function _UpdateParticleGravityBlockGroup(inputParticle, gravity) {
     addDirectionBlock.output.connectTo(updateDirection.direction);
     return updateDirection.output;
 }
+/**
+ * Creates the group of blocks that represent the particle sprite cell update
+ * @param inputParticle The input particle to update
+ * @returns The output of the group of blocks that represent the particle sprite cell update #2MI0A1#3
+ */
+function _UpdateParticleSpriteCellBlockGroup(inputParticle) {
+    const updateSpriteCell = new BasicSpriteUpdateBlock("Sprite Cell Update");
+    inputParticle.connectTo(updateSpriteCell.particle);
+    return updateSpriteCell.output;
+}
 function _UpdateParticleAngularSpeedGradientBlockGroup(angularSpeedGradients, context) {
     context.ageToLifeTimeRatioBlockGroupOutput = _CreateAgeToLifeTimeRatioBlockGroup(context);
     // Generate the gradient
@@ -632,10 +663,10 @@ function _ClampUpdateColorAlpha(colorCalculationOutput) {
     return composeColorBlock.colorOut;
 }
 // ------------- SYSTEM FUNCTIONS -------------
-function _SystemBlockGroup(oldSystem, context) {
+function _SystemBlockGroup(updateParticleOutput, oldSystem, context) {
     const newSystem = new SystemBlock(oldSystem.name);
-    newSystem.translationPivot.value = oldSystem.translationPivot;
-    newSystem.textureMask.value = oldSystem.textureMask;
+    newSystem.translationPivot.value = oldSystem.translationPivot.clone();
+    newSystem.textureMask.value = oldSystem.textureMask.clone();
     newSystem.manualEmitCount = oldSystem.manualEmitCount;
     newSystem.blendMode = oldSystem.blendMode;
     newSystem.capacity = oldSystem.getCapacity();
@@ -646,16 +677,19 @@ function _SystemBlockGroup(oldSystem, context) {
     newSystem.isBillboardBased = oldSystem.isBillboardBased;
     newSystem.isLocal = oldSystem.isLocal;
     newSystem.disposeOnStop = oldSystem.disposeOnStop;
-    _SystemEmitRateValue(oldSystem, newSystem, context);
-    _CreateTextureBlock(oldSystem.particleTexture).connectTo(newSystem.texture);
-    _SystemTargetStopDuration(oldSystem, newSystem, context);
+    _SystemEmitRateValue(oldSystem.getEmitRateGradients(), oldSystem.targetStopDuration, oldSystem.emitRate, newSystem, context);
+    const texture = oldSystem.particleTexture;
+    if (texture) {
+        _CreateTextureBlock(texture).connectTo(newSystem.texture);
+    }
+    _SystemTargetStopDuration(oldSystem.targetStopDuration, newSystem, context);
+    updateParticleOutput.connectTo(newSystem.particle);
     return newSystem;
 }
-function _SystemEmitRateValue(oldSystem, newSystem, context) {
-    const emitGradients = oldSystem.getEmitRateGradients();
-    if (emitGradients && emitGradients.length > 0 && oldSystem.targetStopDuration > 0) {
+function _SystemEmitRateValue(emitGradients, targetStopDuration, emitRate, newSystem, context) {
+    if (emitGradients && emitGradients.length > 0 && targetStopDuration > 0) {
         // Create the emit gradients
-        context.timeToStopTimeRatioBlockGroupOutput = _CreateTimeToStopTimeRatioBlockGroup(oldSystem, context);
+        context.timeToStopTimeRatioBlockGroupOutput = _CreateTimeToStopTimeRatioBlockGroup(targetStopDuration, context);
         const gradientValue = _CreateGradientBlockGroup(context.timeToStopTimeRatioBlockGroupOutput, emitGradients, ParticleRandomBlockLocks.PerSystem, "Emit Rate");
         // Round the value to an int
         const roundBlock = new ParticleFloatToIntBlock("Round to Int");
@@ -664,10 +698,10 @@ function _SystemEmitRateValue(oldSystem, newSystem, context) {
         roundBlock.output.connectTo(newSystem.emitRate);
     }
     else {
-        newSystem.emitRate.value = oldSystem.emitRate;
+        newSystem.emitRate.value = emitRate;
     }
 }
-function _SystemTargetStopDuration(oldSystem, newSystem, context) {
+function _SystemTargetStopDuration(targetStopDuration, newSystem, context) {
     // If something else uses the target stop duration (like a gradient),
     // then the block is already created and stored in the context
     if (context.targetStopDurationBlockOutput) {
@@ -675,7 +709,7 @@ function _SystemTargetStopDuration(oldSystem, newSystem, context) {
     }
     else {
         // If no one used it, do not create a block just set the value
-        newSystem.targetStopDuration.value = oldSystem.targetStopDuration;
+        newSystem.targetStopDuration.value = targetStopDuration;
     }
 }
 // ------------- UTILITY FUNCTIONS -------------
@@ -709,18 +743,18 @@ function _CreateAndConnectSystemSource(systemBlockName, systemSource, targetToCo
 /**
  * Creates the target stop duration input block, as it can be shared in multiple places
  * This block is stored in the context so the same block is shared in the graph
- * @param oldSystem The old particle system to convert
+ * @param targetStopDuration The target stop duration value
  * @param context The context of the current conversion
  * @returns
  */
-function _CreateTargetStopDurationInputBlock(oldSystem, context) {
+function _CreateTargetStopDurationInputBlock(targetStopDuration, context) {
     // If we have already created the target stop duration input block, return it
     if (context.targetStopDurationBlockOutput) {
         return context.targetStopDurationBlockOutput;
     }
     // Create the target stop duration input block if not already created
     const targetStopDurationInputBlock = new ParticleInputBlock("Target Stop Duration");
-    targetStopDurationInputBlock.value = oldSystem.targetStopDuration;
+    targetStopDurationInputBlock.value = targetStopDuration;
     // Save the output in our context to avoid regenerating it again
     context.targetStopDurationBlockOutput = targetStopDurationInputBlock.output;
     return context.targetStopDurationBlockOutput;
@@ -729,16 +763,16 @@ function _CreateTargetStopDurationInputBlock(oldSystem, context) {
  * Create a group of blocks that calculates the ratio between the actual frame and the target stop duration, clamped between 0 and 1.
  * This is used to simulate the behavior of the old particle system where several particle gradient values are affected by the target stop duration.
  * This block group is stored in the context so the same group is shared in the graph
- * @param oldSystem The old particle system to convert
+ * @param targetStopDuration The target stop duration value
  * @param context The context of the current conversion
  * @returns The ratio block output connection point
  */
-function _CreateTimeToStopTimeRatioBlockGroup(oldSystem, context) {
+function _CreateTimeToStopTimeRatioBlockGroup(targetStopDuration, context) {
     // If we have already generated this group, return it
     if (context.timeToStopTimeRatioBlockGroupOutput) {
         return context.timeToStopTimeRatioBlockGroupOutput;
     }
-    context.targetStopDurationBlockOutput = _CreateTargetStopDurationInputBlock(oldSystem, context);
+    context.targetStopDurationBlockOutput = _CreateTargetStopDurationInputBlock(targetStopDuration, context);
     // Find the ratio between the actual frame and the target stop duration
     const ratio = new ParticleMathBlock("Frame/Stop Ratio");
     ratio.operation = ParticleMathBlockOperations.Divide;
@@ -813,8 +847,8 @@ function _CreateGradientBlockGroup(gradientSelector, gradientValues, randomLockM
 function _CreateGradientValueBlockGroup(gradientStep, randomLockMode, prefix, index) {
     const gradientValueBlock = new ParticleGradientValueBlock(prefix + " Gradient Value " + index);
     gradientValueBlock.reference = gradientStep.gradient;
-    const value1 = gradientStep.factor1 ?? gradientStep.color1;
-    const value2 = gradientStep.factor2 ?? gradientStep.color2;
+    const value1 = gradientStep.factor1 ?? gradientStep.color1.clone();
+    const value2 = gradientStep.factor2 ?? gradientStep.color2?.clone();
     if (value2 !== undefined) {
         // Create a random between value1 and value2
         const randomBlock = new ParticleRandomBlock("Random Value " + index);
@@ -830,15 +864,9 @@ function _CreateGradientValueBlockGroup(gradientStep, randomLockMode, prefix, in
     return gradientValueBlock.output;
 }
 function _CreateTextureBlock(texture) {
-    // Texture
+    // Texture - always use sourceTexture to preserve all texture options
     const textureBlock = new ParticleTextureSourceBlock("Texture");
-    const url = texture.url || "";
-    if (url) {
-        textureBlock.url = url;
-    }
-    else {
-        textureBlock.sourceTexture = texture;
-    }
+    textureBlock.sourceTexture = texture;
     return textureBlock.texture;
 }
 //# sourceMappingURL=nodeParticleSystemSet.helper.js.map