@tsparticles/engine 4.0.5 → 4.1.1

package/esm/Core/ParticlesManager.js

@@ -8,44 +8,44 @@ import { loadParticlesOptions } from "../Utils/OptionsUtils.js";
 export class ParticlesManager {
     checkParticlePositionPlugins;
     grid;
-    _array;
-    _container;
-    _groupLimits;
-    _limit;
-    _nextId;
-    _particleBuckets;
-    _particleResetPlugins;
-    _particleUpdatePlugins;
-    _pluginManager;
-    _pool;
-    _postParticleUpdatePlugins;
-    _postUpdatePlugins;
-    _resizeFactor;
-    _updatePlugins;
-    _zBuckets;
+    #array;
+    #container;
+    #groupLimits;
+    #limit;
+    #nextId;
+    #particleBuckets;
+    #particleResetPlugins;
+    #particleUpdatePlugins;
+    #pluginManager;
+    #pool;
+    #postParticleUpdatePlugins;
+    #postUpdatePlugins;
+    #resizeFactor;
+    #updatePlugins;
+    #zBuckets;
     constructor(pluginManager, container) {
-        this._pluginManager = pluginManager;
-        this._container = container;
-        this._nextId = 0;
-        this._array = [];
-        this._pool = [];
-        this._limit = 0;
-        this._groupLimits = new Map();
-        this._particleBuckets = new Map();
-        this._zBuckets = this._createBuckets(this._container.zLayers);
+        this.#pluginManager = pluginManager;
+        this.#container = container;
+        this.#nextId = 0;
+        this.#array = [];
+        this.#pool = [];
+        this.#limit = 0;
+        this.#groupLimits = new Map();
+        this.#particleBuckets = new Map();
+        this.#zBuckets = this.#createBuckets(this.#container.zLayers);
         this.grid = new SpatialHashGrid(spatialHashGridCellSize);
         this.checkParticlePositionPlugins = [];
-        this._particleResetPlugins = [];
-        this._particleUpdatePlugins = [];
-        this._postUpdatePlugins = [];
-        this._postParticleUpdatePlugins = [];
-        this._updatePlugins = [];
+        this.#particleResetPlugins = [];
+        this.#particleUpdatePlugins = [];
+        this.#postUpdatePlugins = [];
+        this.#postParticleUpdatePlugins = [];
+        this.#updatePlugins = [];
     }
     get count() {
-        return this._array.length;
+        return this.#array.length;
     }
     addParticle(position, overrideOptions, group, initializer) {
-        const limitMode = this._container.actualOptions.particles.number.limit.mode, limit = group === undefined ? this._limit : (this._groupLimits.get(group) ?? this._limit), currentCount = this.count;
+        const limitMode = this.#container.actualOptions.particles.number.limit.mode, limit = group === undefined ? this.#limit : (this.#groupLimits.get(group) ?? this.#limit), currentCount = this.count;
         if (limit > minLimit) {
             switch (limitMode) {
                 case LimitMode.delete: {
@@ -65,20 +65,20 @@ export class ParticlesManager {
             }
         }
         try {
-            const particle = this._pool.pop() ?? new Particle(this._pluginManager, this._container);
-            particle.init(this._nextId, position, overrideOptions, group);
+            const particle = this.#pool.pop() ?? new Particle(this.#pluginManager, this.#container);
+            particle.init(this.#nextId, position, overrideOptions, group);
             let canAdd = true;
             if (initializer) {
                 canAdd = initializer(particle);
             }
             if (!canAdd) {
-                this._pool.push(particle);
+                this.#pool.push(particle);
                 return;
             }
-            this._array.push(particle);
-            this._insertParticleIntoBucket(particle);
-            this._nextId++;
-            this._container.dispatchEvent(EventType.particleAdded, {
+            this.#array.push(particle);
+            this.#insertParticleIntoBucket(particle);
+            this.#nextId++;
+            this.#container.dispatchEvent(EventType.particleAdded, {
                 particle,
             });
             return particle;
@@ -89,25 +89,25 @@ export class ParticlesManager {
         return undefined;
     }
     clear() {
-        this._array = [];
-        this._particleBuckets.clear();
-        this._resetBuckets(this._container.zLayers);
+        this.#array = [];
+        this.#particleBuckets.clear();
+        this.#resetBuckets(this.#container.zLayers);
     }
     destroy() {
-        this._array = [];
-        this._pool.length = 0;
-        this._particleBuckets.clear();
-        this._zBuckets = [];
+        this.#array = [];
+        this.#pool.length = 0;
+        this.#particleBuckets.clear();
+        this.#zBuckets = [];
         this.checkParticlePositionPlugins = [];
-        this._particleResetPlugins = [];
-        this._particleUpdatePlugins = [];
-        this._postUpdatePlugins = [];
-        this._postParticleUpdatePlugins = [];
-        this._updatePlugins = [];
+        this.#particleResetPlugins = [];
+        this.#particleUpdatePlugins = [];
+        this.#postUpdatePlugins = [];
+        this.#postParticleUpdatePlugins = [];
+        this.#updatePlugins = [];
     }
     drawParticles(delta) {
-        for (let i = this._zBuckets.length - one; i >= minIndex; i--) {
-            const bucket = this._zBuckets[i];
+        for (let i = this.#zBuckets.length - one; i >= minIndex; i--) {
+            const bucket = this.#zBuckets[i];
             if (!bucket) {
                 continue;
             }
@@ -117,24 +117,24 @@ export class ParticlesManager {
         }
     }
     filter(condition) {
-        return this._array.filter(condition);
+        return this.#array.filter(condition);
     }
     find(condition) {
-        return this._array.find(condition);
+        return this.#array.find(condition);
     }
     get(index) {
-        return this._array[index];
+        return this.#array[index];
     }
     async init() {
-        const container = this._container, options = container.actualOptions;
+        const container = this.#container, options = container.actualOptions;
         this.checkParticlePositionPlugins = [];
-        this._updatePlugins = [];
-        this._particleUpdatePlugins = [];
-        this._postUpdatePlugins = [];
-        this._particleResetPlugins = [];
-        this._postParticleUpdatePlugins = [];
-        this._particleBuckets.clear();
-        this._resetBuckets(container.zLayers);
+        this.#updatePlugins = [];
+        this.#particleUpdatePlugins = [];
+        this.#postUpdatePlugins = [];
+        this.#particleResetPlugins = [];
+        this.#postParticleUpdatePlugins = [];
+        this.#particleBuckets.clear();
+        this.#resetBuckets(container.zLayers);
         this.grid = new SpatialHashGrid(spatialHashGridCellSize * container.retina.pixelRatio);
         for (const plugin of container.plugins) {
             if (plugin.redrawInit) {
@@ -144,26 +144,26 @@ export class ParticlesManager {
                 this.checkParticlePositionPlugins.push(plugin);
             }
             if (plugin.update) {
-                this._updatePlugins.push(plugin);
+                this.#updatePlugins.push(plugin);
             }
             if (plugin.particleUpdate) {
-                this._particleUpdatePlugins.push(plugin);
+                this.#particleUpdatePlugins.push(plugin);
             }
             if (plugin.postUpdate) {
-                this._postUpdatePlugins.push(plugin);
+                this.#postUpdatePlugins.push(plugin);
             }
             if (plugin.particleReset) {
-                this._particleResetPlugins.push(plugin);
+                this.#particleResetPlugins.push(plugin);
             }
             if (plugin.postParticleUpdate) {
-                this._postParticleUpdatePlugins.push(plugin);
+                this.#postParticleUpdatePlugins.push(plugin);
             }
         }
-        await this._container.initDrawersAndUpdaters();
-        for (const drawer of this._container.effectDrawers.values()) {
+        await this.#container.initDrawersAndUpdaters();
+        for (const drawer of this.#container.effectDrawers.values()) {
             await drawer.init?.(container);
         }
-        for (const drawer of this._container.shapeDrawers.values()) {
+        for (const drawer of this.#container.shapeDrawers.values()) {
             await drawer.init?.(container);
         }
         let handled = false;
@@ -197,10 +197,10 @@ export class ParticlesManager {
     async redraw() {
         this.clear();
         await this.init();
-        this._container.canvas.render.drawParticles({ value: 0, factor: 0 });
+        this.#container.canvas.render.drawParticles({ value: 0, factor: 0 });
     }
     remove(particle, group, override) {
-        this.removeAt(this._array.indexOf(particle), undefined, group, override);
+        this.removeAt(this.#array.indexOf(particle), undefined, group, override);
     }
     removeAt(index, quantity = defaultRemoveQuantity, group, override) {
         if (index < minIndex || index > this.count) {
@@ -208,7 +208,7 @@ export class ParticlesManager {
         }
         let deleted = 0;
         for (let i = index; deleted < quantity && i < this.count; i++) {
-            if (this._removeParticle(i, group, override)) {
+            if (this.#removeParticle(i, group, override)) {
                 i--;
                 deleted++;
             }
@@ -218,9 +218,9 @@ export class ParticlesManager {
         this.removeAt(minIndex, quantity, group);
     }
     setDensity() {
-        const options = this._container.actualOptions, groups = options.particles.groups;
+        const options = this.#container.actualOptions, groups = options.particles.groups;
         let pluginsCount = 0;
-        for (const plugin of this._container.plugins) {
+        for (const plugin of this.#container.plugins) {
             if (plugin.particlesDensityCount) {
                 pluginsCount += plugin.particlesDensityCount();
             }
@@ -230,51 +230,51 @@ export class ParticlesManager {
             if (!groupData) {
                 continue;
             }
-            const groupDataOptions = loadParticlesOptions(this._pluginManager, this._container, groupData);
-            this._applyDensity(groupDataOptions, pluginsCount, group);
+            const groupDataOptions = loadParticlesOptions(this.#pluginManager, this.#container, groupData);
+            this.#applyDensity(groupDataOptions, pluginsCount, group);
         }
-        this._applyDensity(options.particles, pluginsCount);
+        this.#applyDensity(options.particles, pluginsCount);
     }
     setResizeFactor(factor) {
-        this._resizeFactor = factor;
+        this.#resizeFactor = factor;
     }
     update(delta) {
         this.grid.clear();
-        for (const plugin of this._updatePlugins) {
+        for (const plugin of this.#updatePlugins) {
             plugin.update?.(delta);
         }
-        const particlesToDelete = this._updateParticlesPhase1(delta);
-        for (const plugin of this._postUpdatePlugins) {
+        const particlesToDelete = this.#updateParticlesPhase1(delta);
+        for (const plugin of this.#postUpdatePlugins) {
             plugin.postUpdate?.(delta);
         }
-        this._updateParticlesPhase2(delta, particlesToDelete);
+        this.#updateParticlesPhase2(delta, particlesToDelete);
         if (particlesToDelete.size) {
             for (const particle of particlesToDelete) {
                 this.remove(particle);
             }
         }
-        delete this._resizeFactor;
+        this.#resizeFactor = undefined;
     }
-    _addToPool = (...particles) => {
-        this._pool.push(...particles);
+    #addToPool = (...particles) => {
+        this.#pool.push(...particles);
     };
-    _applyDensity = (options, pluginsCount, group, groupOptions) => {
+    #applyDensity = (options, pluginsCount, group, groupOptions) => {
         const numberOptions = options.number;
         if (!numberOptions.density.enable) {
             if (group === undefined) {
-                this._limit = numberOptions.limit.value;
+                this.#limit = numberOptions.limit.value;
             }
             else if (groupOptions?.number.limit.value ?? numberOptions.limit.value) {
-                this._groupLimits.set(group, groupOptions?.number.limit.value ?? numberOptions.limit.value);
+                this.#groupLimits.set(group, groupOptions?.number.limit.value ?? numberOptions.limit.value);
             }
             return;
         }
-        const densityFactor = this._initDensityFactor(numberOptions.density), optParticlesNumber = numberOptions.value, optParticlesLimit = numberOptions.limit.value > minLimit ? numberOptions.limit.value : optParticlesNumber, particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + pluginsCount, particlesCount = Math.min(this.count, this.filter(t => t.group === group).length);
+        const densityFactor = this.#initDensityFactor(numberOptions.density), optParticlesNumber = numberOptions.value, optParticlesLimit = numberOptions.limit.value > minLimit ? numberOptions.limit.value : optParticlesNumber, particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + pluginsCount, particlesCount = Math.min(this.count, this.filter(t => t.group === group).length);
         if (group === undefined) {
-            this._limit = numberOptions.limit.value * densityFactor;
+            this.#limit = numberOptions.limit.value * densityFactor;
         }
         else {
-            this._groupLimits.set(group, numberOptions.limit.value * densityFactor);
+            this.#groupLimits.set(group, numberOptions.limit.value * densityFactor);
         }
         if (particlesCount < particlesNumber) {
             this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
@@ -283,18 +283,18 @@ export class ParticlesManager {
             this.removeQuantity(particlesCount - particlesNumber, group);
         }
     };
-    _createBuckets = (zLayers) => {
+    #createBuckets = (zLayers) => {
         const bucketCount = Math.max(Math.floor(zLayers), one);
         return Array.from({ length: bucketCount }, () => []);
     };
-    _getBucketIndex = (zIndex) => {
-        const maxBucketIndex = this._zBuckets.length - one;
+    #getBucketIndex = (zIndex) => {
+        const maxBucketIndex = this.#zBuckets.length - one;
         if (maxBucketIndex <= minIndex) {
             return minIndex;
         }
         return Math.min(Math.max(Math.floor(zIndex), minIndex), maxBucketIndex);
     };
-    _getParticleInsertIndex = (bucket, particleId) => {
+    #getParticleInsertIndex = (bucket, particleId) => {
         let start = minIndex, end = bucket.length;
         while (start < end) {
             const middle = Math.floor((start + end) / double), middleParticle = bucket[middle];
@@ -311,8 +311,8 @@ export class ParticlesManager {
         }
         return start;
     };
-    _initDensityFactor = densityOptions => {
-        const container = this._container;
+    #initDensityFactor = densityOptions => {
+        const container = this.#container;
         if (!densityOptions.enable) {
             return defaultDensityFactor;
         }
@@ -322,82 +322,82 @@ export class ParticlesManager {
         }
         return ((canvasSize.width * canvasSize.height) / (densityOptions.height * densityOptions.width * pxRatio ** squareExp));
     };
-    _insertParticleIntoBucket = (particle) => {
-        const bucketIndex = this._getBucketIndex(particle.position.z), bucket = this._zBuckets[bucketIndex];
+    #insertParticleIntoBucket = (particle) => {
+        const bucketIndex = this.#getBucketIndex(particle.position.z), bucket = this.#zBuckets[bucketIndex];
         if (!bucket) {
             return;
         }
-        bucket.splice(this._getParticleInsertIndex(bucket, particle.id), empty, particle);
-        this._particleBuckets.set(particle.id, bucketIndex);
+        bucket.splice(this.#getParticleInsertIndex(bucket, particle.id), empty, particle);
+        this.#particleBuckets.set(particle.id, bucketIndex);
     };
-    _removeParticle = (index, group, override) => {
-        const particle = this._array[index];
+    #removeParticle = (index, group, override) => {
+        const particle = this.#array[index];
         if (!particle) {
             return false;
         }
         if (particle.group !== group) {
             return false;
         }
-        this._array.splice(index, deleteCount);
-        this._removeParticleFromBucket(particle);
+        this.#array.splice(index, deleteCount);
+        this.#removeParticleFromBucket(particle);
         particle.destroy(override);
-        this._container.dispatchEvent(EventType.particleRemoved, {
+        this.#container.dispatchEvent(EventType.particleRemoved, {
             particle,
         });
-        this._addToPool(particle);
+        this.#addToPool(particle);
         return true;
     };
-    _removeParticleFromBucket = (particle) => {
-        const bucketIndex = this._particleBuckets.get(particle.id) ?? this._getBucketIndex(particle.position.z), bucket = this._zBuckets[bucketIndex];
+    #removeParticleFromBucket = (particle) => {
+        const bucketIndex = this.#particleBuckets.get(particle.id) ?? this.#getBucketIndex(particle.position.z), bucket = this.#zBuckets[bucketIndex];
         if (!bucket) {
-            this._particleBuckets.delete(particle.id);
+            this.#particleBuckets.delete(particle.id);
             return;
         }
-        const particleIndex = this._getParticleInsertIndex(bucket, particle.id);
+        const particleIndex = this.#getParticleInsertIndex(bucket, particle.id);
         if (bucket[particleIndex]?.id !== particle.id) {
-            this._particleBuckets.delete(particle.id);
+            this.#particleBuckets.delete(particle.id);
             return;
         }
         bucket.splice(particleIndex, deleteCount);
-        this._particleBuckets.delete(particle.id);
+        this.#particleBuckets.delete(particle.id);
     };
-    _resetBuckets = (zLayers) => {
+    #resetBuckets = (zLayers) => {
         const bucketCount = Math.max(Math.floor(zLayers), one);
-        if (this._zBuckets.length !== bucketCount) {
-            this._zBuckets = this._createBuckets(bucketCount);
+        if (this.#zBuckets.length !== bucketCount) {
+            this.#zBuckets = this.#createBuckets(bucketCount);
             return;
         }
-        for (const bucket of this._zBuckets) {
+        for (const bucket of this.#zBuckets) {
             bucket.length = minIndex;
         }
     };
-    _updateParticleBucket = (particle) => {
-        const newBucketIndex = this._getBucketIndex(particle.position.z), currentBucketIndex = this._particleBuckets.get(particle.id);
+    #updateParticleBucket = (particle) => {
+        const newBucketIndex = this.#getBucketIndex(particle.position.z), currentBucketIndex = this.#particleBuckets.get(particle.id);
         if (currentBucketIndex === undefined) {
-            this._insertParticleIntoBucket(particle);
+            this.#insertParticleIntoBucket(particle);
             return;
         }
         if (currentBucketIndex === newBucketIndex) {
             return;
         }
-        const currentBucket = this._zBuckets[currentBucketIndex];
+        const currentBucket = this.#zBuckets[currentBucketIndex];
         if (currentBucket) {
-            const particleIndex = this._getParticleInsertIndex(currentBucket, particle.id);
+            const particleIndex = this.#getParticleInsertIndex(currentBucket, particle.id);
             if (currentBucket[particleIndex]?.id === particle.id) {
                 currentBucket.splice(particleIndex, deleteCount);
             }
         }
-        const newBucket = this._zBuckets[newBucketIndex];
+        const newBucket = this.#zBuckets[newBucketIndex];
         if (!newBucket) {
-            this._particleBuckets.set(particle.id, newBucketIndex);
+            this.#particleBuckets.set(particle.id, newBucketIndex);
             return;
         }
-        newBucket.splice(this._getParticleInsertIndex(newBucket, particle.id), empty, particle);
-        this._particleBuckets.set(particle.id, newBucketIndex);
+        newBucket.splice(this.#getParticleInsertIndex(newBucket, particle.id), empty, particle);
+        this.#particleBuckets.set(particle.id, newBucketIndex);
     };
-    _updateParticlesPhase1 = (delta) => {
-        const particlesToDelete = new Set(), resizeFactor = this._resizeFactor;
-        for (const particle of this._array) {
+    #updateParticlesPhase1 = (delta) => {
+        const particlesToDelete = new Set(), resizeFactor = this.#resizeFactor;
+        for (const particle of this.#array) {
             if (resizeFactor && !particle.ignoresResizeRatio) {
                 particle.position.x *= resizeFactor.width;
                 particle.position.y *= resizeFactor.height;
@@ -405,10 +405,10 @@ export class ParticlesManager {
                 particle.initialPosition.y *= resizeFactor.height;
             }
             particle.ignoresResizeRatio = false;
-            for (const plugin of this._particleResetPlugins) {
+            for (const plugin of this.#particleResetPlugins) {
                 plugin.particleReset?.(particle);
             }
-            for (const plugin of this._particleUpdatePlugins) {
+            for (const plugin of this.#particleUpdatePlugins) {
                 if (particle.destroyed) {
                     break;
                 }
@@ -422,21 +422,21 @@ export class ParticlesManager {
         }
         return particlesToDelete;
     };
-    _updateParticlesPhase2 = (delta, particlesToDelete) => {
-        for (const particle of this._array) {
+    #updateParticlesPhase2 = (delta, particlesToDelete) => {
+        for (const particle of this.#array) {
             if (particle.destroyed) {
                 particlesToDelete.add(particle);
                 continue;
             }
-            for (const updater of this._container.particleUpdaters) {
+            for (const updater of this.#container.particleUpdaters) {
                 updater.update(particle, delta);
             }
             if (!particle.spawning) {
-                for (const plugin of this._postParticleUpdatePlugins) {
+                for (const plugin of this.#postParticleUpdatePlugins) {
                     plugin.postParticleUpdate?.(particle, delta);
                 }
             }
-            this._updateParticleBucket(particle);
+            this.#updateParticleBucket(particle);
         }
     };
 }