@tsparticles/plugin-poisson-disc 4.0.0-alpha.5 → 4.0.0-beta.0

package/dist_browser_PoissonDisc_js.js

@@ -0,0 +1,30 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v4.0.0-beta.0
+ */
+"use strict";
+/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+(this["webpackChunk_tsparticles_plugin_poisson_disc"] = this["webpackChunk_tsparticles_plugin_poisson_disc"] || []).push([["dist_browser_PoissonDisc_js"],{
+
+/***/ "./dist/browser/PoissonDisc.js"
+/*!*************************************!*\
+  !*** ./dist/browser/PoissonDisc.js ***!
+  \*************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   PoissonDisc: () => (/* binding */ PoissonDisc)\n/* harmony export */ });\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n\nclass PoissonDisc {\n    active;\n    cellSize;\n    cols;\n    dimensions;\n    firstPoint;\n    grid;\n    points;\n    radius;\n    retries;\n    rows;\n    size;\n    constructor(size, radius, retries, dimensions, firstPoint){\n        this.size = {\n            ...size\n        };\n        this.radius = radius;\n        this.retries = retries;\n        this.dimensions = dimensions;\n        this.cellSize = Math.floor(this.radius / Math.sqrt(this.dimensions));\n        this.cols = Math.floor(this.size.width / this.cellSize);\n        this.rows = Math.floor(this.size.height / this.cellSize);\n        this.points = [];\n        this.active = [];\n        this.grid = [];\n        this.firstPoint = firstPoint ? {\n            ...firstPoint\n        } : undefined;\n        this.reset();\n    }\n    addPoint(inputPoint) {\n        const point = {\n            position: {\n                ...inputPoint\n            },\n            gridPosition: {\n                x: Math.floor(inputPoint.x / this.cellSize),\n                y: Math.floor(inputPoint.y / this.cellSize)\n            }\n        }, pointIndex = this.points.length, row = this.grid[point.gridPosition.y];\n        if (!row) {\n            return;\n        }\n        this.points.push(point);\n        row[point.gridPosition.x] = pointIndex;\n        this.active.push(pointIndex);\n    }\n    getRandom(min, max) {\n        return Math.floor((0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getRandom)() * (max - min)) + min;\n    }\n    initialiseGrid() {\n        for(let y = 0; y <= this.rows; y++){\n            this.grid[y] = [];\n            const row = this.grid[y];\n            if (!row) {\n                continue;\n            }\n            for(let x = 0; x <= this.cols; x++){\n                row[x] = -1;\n            }\n        }\n    }\n    reset() {\n        this.points = [];\n        this.active = [];\n        this.grid = [];\n        this.initialiseGrid();\n        if (this.firstPoint) {\n            this.addPoint(this.firstPoint);\n        } else {\n            const minCoordinate = 0;\n            this.addPoint({\n                x: this.getRandom(minCoordinate, this.size.width),\n                y: this.getRandom(minCoordinate, this.size.height)\n            });\n        }\n    }\n    async run() {\n        this.reset();\n        const minCount = 0, step = 1, yieldEvery = 100, yieldStepModule = 0;\n        let iterations = 0;\n        while(this.active.length > minCount){\n            this.steps(step);\n            if (++iterations % yieldEvery === yieldStepModule) {\n                await new Promise((resolve)=>setTimeout(resolve));\n            }\n        }\n    }\n    steps(steps) {\n        const minCount = 0;\n        for(let i = 0; i < steps; i++){\n            if (this.active.length <= minCount) {\n                continue;\n            }\n            this._step();\n        }\n    }\n    _getNewPoint(currentPoint, tries) {\n        const minCoordinate = 0, gridMinValue = 0, maxNeighbourIndex = 1, newAngle = tries * (_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.doublePI / this.retries), newDist = this.getRandom(this.radius, this.radius * _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.double), offset = {\n            x: Math.cos(newAngle) * newDist,\n            y: Math.sin(newAngle) * newDist\n        }, newPoint = {\n            x: Math.floor(currentPoint.position.x + offset.x),\n            y: Math.floor(currentPoint.position.y + offset.y)\n        }, newGridCoords = {\n            x: Math.floor(newPoint.x / this.cellSize),\n            y: Math.floor(newPoint.y / this.cellSize)\n        };\n        if (newPoint.x <= minCoordinate || newPoint.x >= this.size.width || newPoint.y <= minCoordinate || newPoint.y >= this.size.height) {\n            return;\n        }\n        const row = this.grid[newGridCoords.y];\n        if (!row) {\n            return;\n        }\n        const cellValue = row[newGridCoords.x];\n        if (cellValue === undefined) {\n            return;\n        }\n        if (cellValue >= gridMinValue) {\n            return;\n        }\n        for(let i = -1; i <= maxNeighbourIndex; i++){\n            for(let j = -1; j <= maxNeighbourIndex; j++){\n                if (!i && !j) {\n                    continue;\n                }\n                const neighbourGrid = {\n                    x: newGridCoords.x + j,\n                    y: newGridCoords.y + i\n                };\n                if (neighbourGrid.x < minCoordinate || neighbourGrid.y < minCoordinate || neighbourGrid.x >= this.cols || neighbourGrid.y >= this.rows) {\n                    continue;\n                }\n                const neighbourCellValue = this.grid[neighbourGrid.y]?.[neighbourGrid.x];\n                if (neighbourCellValue === undefined || neighbourCellValue < gridMinValue) {\n                    continue;\n                }\n                const neighbour = this.points[neighbourCellValue];\n                if (!neighbour) {\n                    continue;\n                }\n                if ((0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getDistance)(newPoint, neighbour.position) < this.radius) {\n                    return;\n                }\n            }\n        }\n        return newPoint;\n    }\n    _step() {\n        const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);\n        let foundNewPoint = false;\n        for(let tries = 0; tries < this.retries; tries++){\n            const randomActivePointIndex = this.active[randomActive];\n            if (randomActivePointIndex === undefined) {\n                continue;\n            }\n            const point = this.points[randomActivePointIndex];\n            if (!point) {\n                continue;\n            }\n            const newPoint = this._getNewPoint(point, tries);\n            if (newPoint) {\n                foundNewPoint = true;\n                this.addPoint(newPoint);\n                break;\n            }\n        }\n        if (!foundNewPoint) {\n            const deleteCount = 1;\n            this.active.splice(randomActive, deleteCount);\n        }\n    }\n}\n\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/PoissonDisc.js?\n}");
+
+/***/ }
+
+}]);

package/esm/Options/Classes/Poisson.js

@@ -1,5 +1,10 @@
 import { isNull } from "@tsparticles/engine";
 export class Poisson {
+    dimensions;
+    enable;
+    radius;
+    retries;
+    steps;
     constructor() {
         this.enable = false;
         this.dimensions = 2;

package/esm/PoissonDisc.js

@@ -1,5 +1,16 @@
 import { double, doublePI, getDistance, getRandom } from "@tsparticles/engine";
 export class PoissonDisc {
+    active;
+    cellSize;
+    cols;
+    dimensions;
+    firstPoint;
+    grid;
+    points;
+    radius;
+    retries;
+    rows;
+    size;
     constructor(size, radius, retries, dimensions, firstPoint) {
         this.size = { ...size };
         this.radius = radius;
@@ -62,18 +73,22 @@ export class PoissonDisc {
     }
     async run() {
         this.reset();
-        const minCount = 0, step = 1;
+        const minCount = 0, step = 1, yieldEvery = 100, yieldStepModule = 0;
+        let iterations = 0;
         while (this.active.length > minCount) {
-            await this.steps(step);
+            this.steps(step);
+            if (++iterations % yieldEvery === yieldStepModule) {
+                await new Promise(resolve => setTimeout(resolve));
+            }
         }
     }
-    async steps(steps) {
+    steps(steps) {
         const minCount = 0;
         for (let i = 0; i < steps; i++) {
             if (this.active.length <= minCount) {
                 continue;
             }
-            await this._step();
+            this._step();
         }
     }
     _getNewPoint(currentPoint, tries) {
@@ -87,78 +102,75 @@ export class PoissonDisc {
             x: Math.floor(newPoint.x / this.cellSize),
             y: Math.floor(newPoint.y / this.cellSize),
         };
-        if (newPoint.x > minCoordinate &&
-            newPoint.x < this.size.width &&
-            newPoint.y > minCoordinate &&
-            newPoint.y < this.size.height) {
-            const row = this.grid[newGridCoords.y];
-            if (!row) {
-                return;
-            }
-            const point = row[newGridCoords.x];
-            if (point === undefined) {
-                return;
-            }
-            if (point < gridMinValue) {
-                for (let i = -1; i <= maxNeighbourIndex; i++) {
-                    for (let j = -1; j <= maxNeighbourIndex; j++) {
-                        const neighbourGrid = {
-                            x: newGridCoords.x + j,
-                            y: newGridCoords.y + i,
-                        };
-                        if (neighbourGrid.x >= minCoordinate &&
-                            neighbourGrid.y >= minCoordinate &&
-                            neighbourGrid.x < this.cols &&
-                            neighbourGrid.y < this.rows &&
-                            (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {
-                            if (point >= gridMinValue) {
-                                const neighbourIndex = point, neighbour = this.points[neighbourIndex];
-                                if (!neighbour) {
-                                    continue;
-                                }
-                                const dist = getDistance(newPoint, neighbour.position);
-                                if (dist < this.radius) {
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                return;
-            }
+        if (newPoint.x <= minCoordinate ||
+            newPoint.x >= this.size.width ||
+            newPoint.y <= minCoordinate ||
+            newPoint.y >= this.size.height) {
+            return;
         }
-        else {
+        const row = this.grid[newGridCoords.y];
+        if (!row) {
             return;
         }
-        return newPoint;
-    }
-    async _step() {
-        const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
-        return new Promise(resolve => {
-            let foundNewPoint = false;
-            for (let tries = 0; tries < this.retries; tries++) {
-                const randomActivePointIndex = this.active[randomActive];
-                if (randomActivePointIndex === undefined) {
+        const cellValue = row[newGridCoords.x];
+        if (cellValue === undefined) {
+            return;
+        }
+        if (cellValue >= gridMinValue) {
+            return;
+        }
+        for (let i = -1; i <= maxNeighbourIndex; i++) {
+            for (let j = -1; j <= maxNeighbourIndex; j++) {
+                if (!i && !j) {
+                    continue;
+                }
+                const neighbourGrid = {
+                    x: newGridCoords.x + j,
+                    y: newGridCoords.y + i,
+                };
+                if (neighbourGrid.x < minCoordinate ||
+                    neighbourGrid.y < minCoordinate ||
+                    neighbourGrid.x >= this.cols ||
+                    neighbourGrid.y >= this.rows) {
+                    continue;
+                }
+                const neighbourCellValue = this.grid[neighbourGrid.y]?.[neighbourGrid.x];
+                if (neighbourCellValue === undefined || neighbourCellValue < gridMinValue) {
                     continue;
                 }
-                const point = this.points[randomActivePointIndex];
-                if (!point) {
+                const neighbour = this.points[neighbourCellValue];
+                if (!neighbour) {
                     continue;
                 }
-                const newPoint = this._getNewPoint(point, tries);
-                if (newPoint) {
-                    foundNewPoint = true;
-                    this.addPoint(newPoint);
-                    break;
+                if (getDistance(newPoint, neighbour.position) < this.radius) {
+                    return;
                 }
             }
-            if (!foundNewPoint) {
-                const deleteCount = 1;
-                this.active.splice(randomActive, deleteCount);
+        }
+        return newPoint;
+    }
+    _step() {
+        const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
+        let foundNewPoint = false;
+        for (let tries = 0; tries < this.retries; tries++) {
+            const randomActivePointIndex = this.active[randomActive];
+            if (randomActivePointIndex === undefined) {
+                continue;
+            }
+            const point = this.points[randomActivePointIndex];
+            if (!point) {
+                continue;
             }
-            resolve();
-        });
+            const newPoint = this._getNewPoint(point, tries);
+            if (newPoint) {
+                foundNewPoint = true;
+                this.addPoint(newPoint);
+                break;
+            }
+        }
+        if (!foundNewPoint) {
+            const deleteCount = 1;
+            this.active.splice(randomActive, deleteCount);
+        }
     }
 }

package/esm/PoissonDiscPlugin.js

@@ -1,8 +1,6 @@
 import { Poisson } from "./Options/Classes/Poisson.js";
 export class PoissonDiscPlugin {
-    constructor() {
-        this.id = "poisson";
-    }
+    id = "poisson";
     async getPlugin(container) {
         const { PoissonDiscPluginInstance } = await import("./PoissonDiscPluginInstance.js");
         return new PoissonDiscPluginInstance(container);

package/esm/PoissonDiscPluginInstance.js

@@ -1,6 +1,9 @@
 import { getRangeMax } from "@tsparticles/engine";
-import { PoissonDisc } from "./PoissonDisc.js";
 export class PoissonDiscPluginInstance {
+    poissonDisc;
+    redrawTimeout;
+    _container;
+    _currentIndex;
     constructor(container) {
         this._container = container;
         this._currentIndex = 0;
@@ -26,6 +29,9 @@ export class PoissonDiscPluginInstance {
         const timeout = 250;
         this.redrawTimeout = setTimeout(() => {
             void (async () => {
+                if (this._container.destroyed) {
+                    return;
+                }
                 await this._initData();
                 await container.particles.redraw();
             })();
@@ -40,12 +46,13 @@ export class PoissonDiscPluginInstance {
             return;
         }
         this._currentIndex = 0;
+        const { PoissonDisc } = await import("./PoissonDisc.js");
         this.poissonDisc = new PoissonDisc(canvasSize, poissonOptions.radius
             ? poissonOptions.radius * pixelRatio
             : Math.max(getRangeMax(particlesOptions.size.value) * pixelRatio, Math.sqrt((canvasSize.width * canvasSize.height) / particlesOptions.number.value)), poissonOptions.retries, poissonOptions.dimensions);
         const noSteps = 0;
         if (poissonOptions.steps > noSteps) {
-            await this.poissonDisc.steps(poissonOptions.steps);
+            this.poissonDisc.steps(poissonOptions.steps);
         }
         else {
             await this.poissonDisc.run();

package/esm/index.js

@@ -1,5 +1,5 @@
 export async function loadPoissonDiscPlugin(engine) {
-    engine.checkVersion("4.0.0-alpha.5");
+    engine.checkVersion("4.0.0-beta.0");
     await engine.register(async (e) => {
         const { PoissonDiscPlugin } = await import("./PoissonDiscPlugin.js");
         e.addPlugin(new PoissonDiscPlugin());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsparticles/plugin-poisson-disc",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-beta.0",
   "description": "tsParticles poisson disc plugin",
   "homepage": "https://particles.js.org",
   "repository": {
@@ -85,7 +85,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@tsparticles/engine": "4.0.0-alpha.5"
+    "@tsparticles/engine": "4.0.0-beta.0"
   },
   "publishConfig": {
     "access": "public"