@newkrok/three-particles 2.3.0 → 2.6.0

package/dist/js/effects/three-particles/three-particles.js

@@ -10,6 +10,18 @@ import { calculateRandomPositionAndVelocityOnBox, calculateRandomPositionAndVelo
 export * from './types.js';
 let _particleSystemId = 0;
 let createdParticleSystems = [];
+// Pre-allocated objects for updateParticleSystemInstance to avoid GC pressure
+const _lastWorldPositionSnapshot = new THREE.Vector3();
+const _distanceStep = { x: 0, y: 0, z: 0 };
+const _tempPosition = { x: 0, y: 0, z: 0 };
+const _modifierParams = {
+    delta: 0,
+    generalData: null,
+    normalizedConfig: null,
+    attributes: null,
+    particleLifetimePercentage: 0,
+    particleIndex: 0,
+};
 /**
  * Mapping of blending mode string identifiers to Three.js blending constants.
  *
@@ -78,6 +90,7 @@ const DEFAULT_PARTICLE_SYSTEM_CONFIG = {
     emission: {
         rateOverTime: 10.0,
         rateOverDistance: 0.0,
+        bursts: [],
     },
     shape: {
         shape: "SPHERE" /* Shape.SPHERE */,
@@ -201,7 +214,16 @@ const DEFAULT_PARTICLE_SYSTEM_CONFIG = {
     },
 };
 const createFloat32Attributes = ({ geometry, propertyName, maxParticles, factory, }) => {
-    geometry.setAttribute(propertyName, new THREE.BufferAttribute(new Float32Array(Array.from({ length: maxParticles }, typeof factory === 'function' ? factory : () => factory)), 1));
+    const array = new Float32Array(maxParticles);
+    if (typeof factory === 'function') {
+        for (let i = 0; i < maxParticles; i++) {
+            array[i] = factory(undefined, i);
+        }
+    }
+    else {
+        array.fill(factory);
+    }
+    geometry.setAttribute(propertyName, new THREE.BufferAttribute(array, 1));
 };
 const calculatePositionAndVelocity = (generalData, { shape, sphere, cone, circle, rectangle, box }, startSpeed, position, velocity) => {
     const calculatedStartSpeed = calculateValue(generalData.particleSystemId, startSpeed, generalData.normalizedLifetimePercentage);
@@ -320,6 +342,7 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
         noise: {
             isActive: false,
             strength: 0,
+            noisePower: 0,
             positionAmount: 0,
             rotationAmount: 0,
             sizeAmount: 0,
@@ -334,6 +357,8 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
     const startPositions = Array.from({ length: maxParticles }, () => new THREE.Vector3());
     const velocities = Array.from({ length: maxParticles }, () => new THREE.Vector3());
     generalData.creationTimes = Array.from({ length: maxParticles }, () => 0);
+    // Free list for O(1) inactive particle lookup (stack, top = end of array)
+    const freeList = Array.from({ length: maxParticles }, (_, i) => maxParticles - 1 - i);
     if (velocityOverLifetime.isActive) {
         generalData.linearVelocityData = Array.from({ length: maxParticles }, () => ({
             speed: new THREE.Vector3(velocityOverLifetime.linear.x
@@ -398,6 +423,7 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
     generalData.noise = {
         isActive: noise.isActive,
         strength: noise.strength,
+        noisePower: 0.15 * noise.strength,
         positionAmount: noise.positionAmount,
         rotationAmount: noise.rotationAmount,
         sizeAmount: noise.sizeAmount,
@@ -412,6 +438,14 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
             ? Array.from({ length: maxParticles }, () => Math.random() * 100)
             : undefined,
     };
+    // Initialize burst states if bursts are configured
+    if (emission.bursts && emission.bursts.length > 0) {
+        generalData.burstStates = emission.bursts.map(() => ({
+            cyclesExecuted: 0,
+            lastCycleTime: 0,
+            probabilityPassed: false,
+        }));
+    }
     const material = new THREE.ShaderMaterial({
         uniforms: {
             elapsed: {
@@ -449,37 +483,96 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
     const geometry = new THREE.BufferGeometry();
     for (let i = 0; i < maxParticles; i++)
         calculatePositionAndVelocity(generalData, shape, startSpeed, startPositions[i], velocities[i]);
-    geometry.setFromPoints(Array.from({ length: maxParticles }, (_, index) => startPositions[index].clone()));
-    const createFloat32AttributesRequest = (propertyName, factory) => {
-        createFloat32Attributes({
-            geometry,
-            propertyName,
-            maxParticles,
-            factory,
-        });
-    };
-    createFloat32AttributesRequest('isActive', 0);
-    createFloat32AttributesRequest('lifetime', 0);
-    createFloat32AttributesRequest('startLifetime', () => calculateValue(generalData.particleSystemId, startLifetime, 0) * 1000);
-    createFloat32AttributesRequest('startFrame', () => textureSheetAnimation.startFrame
-        ? calculateValue(generalData.particleSystemId, textureSheetAnimation.startFrame, 0)
-        : 0);
-    createFloat32AttributesRequest('opacity', () => calculateValue(generalData.particleSystemId, startOpacity, 0));
-    createFloat32AttributesRequest('rotation', () => calculateValue(generalData.particleSystemId, startRotation, 0));
-    createFloat32AttributesRequest('size', (_, index) => generalData.startValues.startSize[index]);
-    createFloat32AttributesRequest('rotation', 0);
+    const positionArray = new Float32Array(maxParticles * 3);
+    for (let i = 0; i < maxParticles; i++) {
+        positionArray[i * 3] = startPositions[i].x;
+        positionArray[i * 3 + 1] = startPositions[i].y;
+        positionArray[i * 3 + 2] = startPositions[i].z;
+    }
+    geometry.setAttribute('position', new THREE.BufferAttribute(positionArray, 3));
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'isActive',
+        maxParticles,
+        factory: 0,
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'lifetime',
+        maxParticles,
+        factory: 0,
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'startLifetime',
+        maxParticles,
+        factory: () => calculateValue(generalData.particleSystemId, startLifetime, 0) * 1000,
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'startFrame',
+        maxParticles,
+        factory: () => textureSheetAnimation.startFrame
+            ? calculateValue(generalData.particleSystemId, textureSheetAnimation.startFrame, 0)
+            : 0,
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'opacity',
+        maxParticles,
+        factory: () => calculateValue(generalData.particleSystemId, startOpacity, 0),
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'rotation',
+        maxParticles,
+        factory: () => calculateValue(generalData.particleSystemId, startRotation, 0),
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'size',
+        maxParticles,
+        factory: (_, index) => generalData.startValues.startSize[index],
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'rotation',
+        maxParticles,
+        factory: 0,
+    });
     const colorRandomRatio = Math.random();
-    createFloat32AttributesRequest('colorR', () => startColor.min.r +
-        colorRandomRatio * (startColor.max.r - startColor.min.r));
-    createFloat32AttributesRequest('colorG', () => startColor.min.g +
-        colorRandomRatio * (startColor.max.g - startColor.min.g));
-    createFloat32AttributesRequest('colorB', () => startColor.min.b +
-        colorRandomRatio * (startColor.max.b - startColor.min.b));
-    createFloat32AttributesRequest('colorA', 0);
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'colorR',
+        maxParticles,
+        factory: () => startColor.min.r +
+            colorRandomRatio * (startColor.max.r - startColor.min.r),
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'colorG',
+        maxParticles,
+        factory: () => startColor.min.g +
+            colorRandomRatio * (startColor.max.g - startColor.min.g),
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'colorB',
+        maxParticles,
+        factory: () => startColor.min.b +
+            colorRandomRatio * (startColor.max.b - startColor.min.b),
+    });
+    createFloat32Attributes({
+        geometry,
+        propertyName: 'colorA',
+        maxParticles,
+        factory: 0,
+    });
     const deactivateParticle = (particleIndex) => {
         geometry.attributes.isActive.array[particleIndex] = 0;
         geometry.attributes.colorA.array[particleIndex] = 0;
         geometry.attributes.colorA.needsUpdate = true;
+        freeList.push(particleIndex);
     };
     const activateParticle = ({ particleIndex, activationTime, position, }) => {
         geometry.attributes.isActive.array[particleIndex] = 1;
@@ -577,9 +670,10 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
         wrapper = new Gyroscope();
         wrapper.add(particleSystem);
     }
-    createdParticleSystems.push({
+    const instanceData = {
         particleSystem,
         wrapper,
+        elapsedUniform: material.uniforms.elapsed,
         generalData,
         onUpdate,
         onComplete,
@@ -593,17 +687,21 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
         normalizedConfig,
         iterationCount: 0,
         velocities,
+        freeList,
         deactivateParticle,
         activateParticle,
-    });
+    };
+    createdParticleSystems.push(instanceData);
     const resumeEmitter = () => (generalData.isEnabled = true);
     const pauseEmitter = () => (generalData.isEnabled = false);
     const dispose = () => destroyParticleSystem(particleSystem);
+    const update = (cycleData) => updateParticleSystemInstance(instanceData, cycleData);
     return {
         instance: wrapper || particleSystem,
         resumeEmitter,
         pauseEmitter,
         dispose,
+        update,
     };
 };
 /**
@@ -678,160 +776,197 @@ export const createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, ex
  * @see {@link createParticleSystem} - Creates particle systems to be updated
  * @see {@link CycleData} - Timing data structure
  */
-export const updateParticleSystems = ({ now, delta, elapsed }) => {
-    createdParticleSystems.forEach((props) => {
-        const { onUpdate, generalData, onComplete, particleSystem, wrapper, creationTime, lastEmissionTime, duration, looping, emission, normalizedConfig, iterationCount, velocities, deactivateParticle, activateParticle, simulationSpace, gravity, } = props;
-        const lifetime = now - creationTime;
-        const normalizedLifetime = lifetime % (duration * 1000);
-        generalData.normalizedLifetimePercentage = Math.max(Math.min(normalizedLifetime / (duration * 1000), 1), 0);
-        const { lastWorldPosition, currentWorldPosition, worldPositionChange, lastWorldQuaternion, worldQuaternion, worldEuler, gravityVelocity, isEnabled, } = generalData;
-        if (wrapper?.parent)
-            generalData.wrapperQuaternion.copy(wrapper.parent.quaternion);
-        const lastWorldPositionSnapshot = { ...lastWorldPosition };
-        if (Array.isArray(particleSystem.material))
-            particleSystem.material.forEach((material) => {
-                if (material instanceof THREE.ShaderMaterial)
-                    material.uniforms.elapsed.value = elapsed;
-            });
-        else {
-            if (particleSystem.material instanceof THREE.ShaderMaterial)
-                particleSystem.material.uniforms.elapsed.value = elapsed;
-        }
-        particleSystem.getWorldPosition(currentWorldPosition);
-        if (lastWorldPosition.x !== -99999) {
-            worldPositionChange.set(currentWorldPosition.x - lastWorldPosition.x, currentWorldPosition.y - lastWorldPosition.y, currentWorldPosition.z - lastWorldPosition.z);
-        }
+const updateParticleSystemInstance = (props, { now, delta, elapsed }) => {
+    const { onUpdate, generalData, onComplete, particleSystem, wrapper, elapsedUniform, creationTime, lastEmissionTime, duration, looping, emission, normalizedConfig, iterationCount, velocities, freeList, deactivateParticle, activateParticle, simulationSpace, gravity, } = props;
+    const lifetime = now - creationTime;
+    const normalizedLifetime = lifetime % (duration * 1000);
+    generalData.normalizedLifetimePercentage = Math.max(Math.min(normalizedLifetime / (duration * 1000), 1), 0);
+    const { lastWorldPosition, currentWorldPosition, worldPositionChange, lastWorldQuaternion, worldQuaternion, worldEuler, gravityVelocity, isEnabled, } = generalData;
+    if (wrapper?.parent)
+        generalData.wrapperQuaternion.copy(wrapper.parent.quaternion);
+    _lastWorldPositionSnapshot.copy(lastWorldPosition);
+    elapsedUniform.value = elapsed;
+    particleSystem.getWorldPosition(currentWorldPosition);
+    if (lastWorldPosition.x !== -99999) {
+        worldPositionChange.set(currentWorldPosition.x - lastWorldPosition.x, currentWorldPosition.y - lastWorldPosition.y, currentWorldPosition.z - lastWorldPosition.z);
+    }
+    if (isEnabled) {
         generalData.distanceFromLastEmitByDistance += worldPositionChange.length();
-        particleSystem.getWorldPosition(lastWorldPosition);
-        particleSystem.getWorldQuaternion(worldQuaternion);
-        if (lastWorldQuaternion.x === -99999 ||
-            lastWorldQuaternion.x !== worldQuaternion.x ||
-            lastWorldQuaternion.y !== worldQuaternion.y ||
-            lastWorldQuaternion.z !== worldQuaternion.z) {
-            worldEuler.setFromQuaternion(worldQuaternion);
-            lastWorldQuaternion.copy(worldQuaternion);
-            gravityVelocity.set(lastWorldPosition.x, lastWorldPosition.y + gravity, lastWorldPosition.z);
-            particleSystem.worldToLocal(gravityVelocity);
-        }
-        generalData.creationTimes.forEach((entry, index) => {
-            if (particleSystem.geometry.attributes.isActive.array[index]) {
-                const particleLifetime = now - entry;
-                if (particleLifetime >
-                    particleSystem.geometry.attributes.startLifetime.array[index])
-                    deactivateParticle(index);
-                else {
-                    const velocity = velocities[index];
-                    velocity.x -= gravityVelocity.x * delta;
-                    velocity.y -= gravityVelocity.y * delta;
-                    velocity.z -= gravityVelocity.z * delta;
-                    if (gravity !== 0 ||
-                        velocity.x !== 0 ||
-                        velocity.y !== 0 ||
-                        velocity.z !== 0 ||
-                        worldPositionChange.x !== 0 ||
-                        worldPositionChange.y !== 0 ||
-                        worldPositionChange.z !== 0) {
-                        const positionIndex = index * 3;
-                        const positionArr = particleSystem.geometry.attributes.position.array;
-                        if (simulationSpace === "WORLD" /* SimulationSpace.WORLD */) {
-                            positionArr[positionIndex] -= worldPositionChange.x;
-                            positionArr[positionIndex + 1] -= worldPositionChange.y;
-                            positionArr[positionIndex + 2] -= worldPositionChange.z;
-                        }
-                        positionArr[positionIndex] += velocity.x * delta;
-                        positionArr[positionIndex + 1] += velocity.y * delta;
-                        positionArr[positionIndex + 2] += velocity.z * delta;
-                        particleSystem.geometry.attributes.position.needsUpdate = true;
+    }
+    particleSystem.getWorldPosition(lastWorldPosition);
+    particleSystem.getWorldQuaternion(worldQuaternion);
+    if (lastWorldQuaternion.x === -99999 ||
+        lastWorldQuaternion.x !== worldQuaternion.x ||
+        lastWorldQuaternion.y !== worldQuaternion.y ||
+        lastWorldQuaternion.z !== worldQuaternion.z) {
+        worldEuler.setFromQuaternion(worldQuaternion);
+        lastWorldQuaternion.copy(worldQuaternion);
+        gravityVelocity.set(lastWorldPosition.x, lastWorldPosition.y + gravity, lastWorldPosition.z);
+        particleSystem.worldToLocal(gravityVelocity);
+    }
+    const creationTimes = generalData.creationTimes;
+    const attributes = particleSystem.geometry.attributes;
+    const isActiveArr = attributes.isActive.array;
+    const startLifetimeArr = attributes.startLifetime.array;
+    const positionArr = attributes.position.array;
+    const lifetimeArr = attributes.lifetime.array;
+    const creationTimesLength = creationTimes.length;
+    let positionNeedsUpdate = false;
+    let lifetimeNeedsUpdate = false;
+    _modifierParams.delta = delta;
+    _modifierParams.generalData = generalData;
+    _modifierParams.normalizedConfig = normalizedConfig;
+    _modifierParams.attributes = attributes;
+    for (let index = 0; index < creationTimesLength; index++) {
+        if (isActiveArr[index]) {
+            const particleLifetime = now - creationTimes[index];
+            if (particleLifetime > startLifetimeArr[index]) {
+                deactivateParticle(index);
+            }
+            else {
+                const velocity = velocities[index];
+                velocity.x -= gravityVelocity.x * delta;
+                velocity.y -= gravityVelocity.y * delta;
+                velocity.z -= gravityVelocity.z * delta;
+                if (gravity !== 0 ||
+                    velocity.x !== 0 ||
+                    velocity.y !== 0 ||
+                    velocity.z !== 0 ||
+                    worldPositionChange.x !== 0 ||
+                    worldPositionChange.y !== 0 ||
+                    worldPositionChange.z !== 0) {
+                    const positionIndex = index * 3;
+                    if (simulationSpace === "WORLD" /* SimulationSpace.WORLD */) {
+                        positionArr[positionIndex] -= worldPositionChange.x;
+                        positionArr[positionIndex + 1] -= worldPositionChange.y;
+                        positionArr[positionIndex + 2] -= worldPositionChange.z;
                     }
-                    particleSystem.geometry.attributes.lifetime.array[index] =
-                        particleLifetime;
-                    particleSystem.geometry.attributes.lifetime.needsUpdate = true;
-                    const particleLifetimePercentage = particleLifetime /
-                        particleSystem.geometry.attributes.startLifetime.array[index];
-                    applyModifiers({
-                        delta,
-                        generalData,
-                        normalizedConfig,
-                        attributes: particleSystem.geometry.attributes,
-                        particleLifetimePercentage,
-                        particleIndex: index,
-                    });
+                    positionArr[positionIndex] += velocity.x * delta;
+                    positionArr[positionIndex + 1] += velocity.y * delta;
+                    positionArr[positionIndex + 2] += velocity.z * delta;
+                    positionNeedsUpdate = true;
                 }
+                lifetimeArr[index] = particleLifetime;
+                lifetimeNeedsUpdate = true;
+                _modifierParams.particleLifetimePercentage =
+                    particleLifetime / startLifetimeArr[index];
+                _modifierParams.particleIndex = index;
+                applyModifiers(_modifierParams);
             }
-        });
-        if (isEnabled && (looping || lifetime < duration * 1000)) {
-            const emissionDelta = now - lastEmissionTime;
-            const neededParticlesByTime = emission.rateOverTime
-                ? Math.floor(calculateValue(generalData.particleSystemId, emission.rateOverTime, generalData.normalizedLifetimePercentage) *
-                    (emissionDelta / 1000))
-                : 0;
-            const rateOverDistance = emission.rateOverDistance
-                ? calculateValue(generalData.particleSystemId, emission.rateOverDistance, generalData.normalizedLifetimePercentage)
-                : 0;
-            const neededParticlesByDistance = rateOverDistance > 0 && generalData.distanceFromLastEmitByDistance > 0
-                ? Math.floor(generalData.distanceFromLastEmitByDistance /
-                    (1 / rateOverDistance))
-                : 0;
-            const distanceStep = neededParticlesByDistance > 0
-                ? {
-                    x: (currentWorldPosition.x - lastWorldPositionSnapshot.x) /
-                        neededParticlesByDistance,
-                    y: (currentWorldPosition.y - lastWorldPositionSnapshot.y) /
-                        neededParticlesByDistance,
-                    z: (currentWorldPosition.z - lastWorldPositionSnapshot.z) /
-                        neededParticlesByDistance,
+        }
+    }
+    if (positionNeedsUpdate)
+        attributes.position.needsUpdate = true;
+    if (lifetimeNeedsUpdate)
+        attributes.lifetime.needsUpdate = true;
+    if (isEnabled && (looping || lifetime < duration * 1000)) {
+        const emissionDelta = now - lastEmissionTime;
+        const neededParticlesByTime = emission.rateOverTime
+            ? Math.floor(calculateValue(generalData.particleSystemId, emission.rateOverTime, generalData.normalizedLifetimePercentage) *
+                (emissionDelta / 1000))
+            : 0;
+        const rateOverDistance = emission.rateOverDistance
+            ? calculateValue(generalData.particleSystemId, emission.rateOverDistance, generalData.normalizedLifetimePercentage)
+            : 0;
+        const neededParticlesByDistance = rateOverDistance > 0 && generalData.distanceFromLastEmitByDistance > 0
+            ? Math.floor(generalData.distanceFromLastEmitByDistance / (1 / rateOverDistance))
+            : 0;
+        const useDistanceStep = neededParticlesByDistance > 0;
+        if (useDistanceStep) {
+            _distanceStep.x =
+                (currentWorldPosition.x - _lastWorldPositionSnapshot.x) /
+                    neededParticlesByDistance;
+            _distanceStep.y =
+                (currentWorldPosition.y - _lastWorldPositionSnapshot.y) /
+                    neededParticlesByDistance;
+            _distanceStep.z =
+                (currentWorldPosition.z - _lastWorldPositionSnapshot.z) /
+                    neededParticlesByDistance;
+        }
+        let neededParticles = neededParticlesByTime + neededParticlesByDistance;
+        if (rateOverDistance > 0 && neededParticlesByDistance >= 1) {
+            generalData.distanceFromLastEmitByDistance = 0;
+        }
+        // Process burst emissions
+        if (emission.bursts && generalData.burstStates) {
+            const bursts = emission.bursts;
+            const burstStates = generalData.burstStates;
+            const currentIterationTime = normalizedLifetime;
+            for (let i = 0; i < bursts.length; i++) {
+                const burst = bursts[i];
+                const state = burstStates[i];
+                const burstTimeMs = burst.time * 1000;
+                const cycles = burst.cycles ?? 1;
+                const intervalMs = (burst.interval ?? 0) * 1000;
+                const probability = burst.probability ?? 1;
+                // Check if we've looped and need to reset burst states
+                if (looping &&
+                    currentIterationTime < burstTimeMs &&
+                    state.cyclesExecuted > 0) {
+                    state.cyclesExecuted = 0;
+                    state.lastCycleTime = 0;
+                    state.probabilityPassed = false;
                 }
-                : null;
-            const neededParticles = neededParticlesByTime + neededParticlesByDistance;
-            if (rateOverDistance > 0 && neededParticlesByDistance >= 1) {
-                generalData.distanceFromLastEmitByDistance = 0;
-            }
-            if (neededParticles > 0) {
-                let generatedParticlesByDistanceNeeds = 0;
-                for (let i = 0; i < neededParticles; i++) {
-                    let particleIndex = -1;
-                    particleSystem.geometry.attributes.isActive.array.find((isActive, index) => {
-                        if (!isActive) {
-                            particleIndex = index;
-                            return true;
-                        }
-                        return false;
-                    });
-                    if (particleIndex !== -1 &&
-                        particleIndex <
-                            particleSystem.geometry.attributes.isActive.array.length) {
-                        let position = { x: 0, y: 0, z: 0 };
-                        if (distanceStep &&
-                            generatedParticlesByDistanceNeeds < neededParticlesByDistance) {
-                            position = {
-                                x: distanceStep.x * generatedParticlesByDistanceNeeds,
-                                y: distanceStep.y * generatedParticlesByDistanceNeeds,
-                                z: distanceStep.z * generatedParticlesByDistanceNeeds,
-                            };
-                            generatedParticlesByDistanceNeeds++;
-                        }
-                        activateParticle({
-                            particleIndex,
-                            activationTime: now,
-                            position,
-                        });
-                        props.lastEmissionTime = now;
+                // Check if all cycles for this burst have been executed
+                if (state.cyclesExecuted >= cycles)
+                    continue;
+                // Calculate the time for the next cycle
+                const nextCycleTime = burstTimeMs + state.cyclesExecuted * intervalMs;
+                // Check if it's time for the next cycle
+                if (currentIterationTime >= nextCycleTime) {
+                    // On first cycle, determine if probability check passes
+                    if (state.cyclesExecuted === 0) {
+                        state.probabilityPassed = Math.random() < probability;
+                    }
+                    // Only emit if probability check passed
+                    if (state.probabilityPassed) {
+                        const burstCount = Math.floor(calculateValue(generalData.particleSystemId, burst.count, generalData.normalizedLifetimePercentage));
+                        neededParticles += burstCount;
                     }
+                    state.cyclesExecuted++;
+                    state.lastCycleTime = currentIterationTime;
                 }
             }
-            if (onUpdate)
-                onUpdate({
-                    particleSystem,
-                    delta,
-                    elapsed,
-                    lifetime,
-                    normalizedLifetime,
-                    iterationCount: iterationCount + 1,
+        }
+        if (neededParticles > 0) {
+            let generatedParticlesByDistanceNeeds = 0;
+            for (let i = 0; i < neededParticles; i++) {
+                if (freeList.length === 0)
+                    break;
+                const particleIndex = freeList.pop();
+                _tempPosition.x = 0;
+                _tempPosition.y = 0;
+                _tempPosition.z = 0;
+                if (useDistanceStep &&
+                    generatedParticlesByDistanceNeeds < neededParticlesByDistance) {
+                    _tempPosition.x = _distanceStep.x * generatedParticlesByDistanceNeeds;
+                    _tempPosition.y = _distanceStep.y * generatedParticlesByDistanceNeeds;
+                    _tempPosition.z = _distanceStep.z * generatedParticlesByDistanceNeeds;
+                    generatedParticlesByDistanceNeeds++;
+                }
+                activateParticle({
+                    particleIndex,
+                    activationTime: now,
+                    position: _tempPosition,
                 });
+                props.lastEmissionTime = now;
+            }
         }
-        else if (onComplete)
-            onComplete({
+        if (onUpdate)
+            onUpdate({
                 particleSystem,
+                delta,
+                elapsed,
+                lifetime,
+                normalizedLifetime,
+                iterationCount: iterationCount + 1,
             });
-    });
+    }
+    else if (onComplete)
+        onComplete({
+            particleSystem,
+        });
+};
+export const updateParticleSystems = (cycleData) => {
+    createdParticleSystems.forEach((props) => updateParticleSystemInstance(props, cycleData));
 };