@tsparticles/plugin-poisson-disc 3.1.0

package/esm/PoissonDisc.js

@@ -0,0 +1,138 @@
+import { getDistance, getRandom } from "@tsparticles/engine";
+const double = 2, doublePI = Math.PI * double;
+export class PoissonDisc {
+    constructor(size, radius, retries, dimensions, firstPoint) {
+        this.size = { ...size };
+        this.radius = radius;
+        this.retries = retries;
+        this.dimensions = dimensions;
+        this.cellSize = Math.floor(this.radius / Math.sqrt(this.dimensions));
+        this.cols = Math.floor(this.size.width / this.cellSize);
+        this.rows = Math.floor(this.size.height / this.cellSize);
+        this.points = [];
+        this.active = [];
+        this.grid = [];
+        this.firstPoint = firstPoint ? { ...firstPoint } : undefined;
+        this.reset();
+    }
+    addPoint(inputPoint) {
+        const point = {
+            position: { ...inputPoint },
+            gridPosition: {
+                x: Math.floor(inputPoint.x / this.cellSize),
+                y: Math.floor(inputPoint.y / this.cellSize),
+            },
+        }, pointIndex = this.points.length;
+        this.points.push(point);
+        this.grid[point.gridPosition.y][point.gridPosition.x] = pointIndex;
+        this.active.push(pointIndex);
+    }
+    getRandom(min, max) {
+        return Math.floor(getRandom() * (max - min)) + min;
+    }
+    initialiseGrid() {
+        for (let y = 0; y <= this.rows; y++) {
+            this.grid[y] = [];
+            for (let x = 0; x <= this.cols; x++) {
+                this.grid[y][x] = -1;
+            }
+        }
+    }
+    reset() {
+        this.points = [];
+        this.active = [];
+        this.grid = [];
+        this.initialiseGrid();
+        if (this.firstPoint) {
+            this.addPoint(this.firstPoint);
+        }
+        else {
+            const minCoordinate = 0;
+            this.addPoint({
+                x: this.getRandom(minCoordinate, this.size.width),
+                y: this.getRandom(minCoordinate, this.size.height),
+            });
+        }
+    }
+    async run() {
+        this.reset();
+        const minCount = 0, step = 1;
+        while (this.active.length > minCount) {
+            await this.steps(step);
+        }
+    }
+    async steps(steps) {
+        const minCount = 0;
+        for (let i = 0; i < steps; i++) {
+            if (this.active.length <= minCount) {
+                continue;
+            }
+            await this._step();
+        }
+    }
+    _getNewPoint(currentPoint, tries) {
+        const minCoordinate = 0, gridMinValue = 0, maxNeighbourIndex = 1, newAngle = tries * (doublePI / this.retries), newDist = this.getRandom(this.radius, this.radius * double), offset = {
+            x: Math.cos(newAngle) * newDist,
+            y: Math.sin(newAngle) * newDist,
+        }, newPoint = {
+            x: Math.floor(currentPoint.position.x + offset.x),
+            y: Math.floor(currentPoint.position.y + offset.y),
+        }, newGridCoords = {
+            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) {
+            if (this.grid[newGridCoords.y][newGridCoords.x] < 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 (this.grid[neighbourGrid.y][neighbourGrid.x] >= gridMinValue) {
+                                const neighbourIndex = this.grid[neighbourGrid.y][neighbourGrid.x], neighbour = this.points[neighbourIndex], dist = getDistance(newPoint, neighbour.position);
+                                if (dist < this.radius) {
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            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 newPoint = this._getNewPoint(this.points[this.active[randomActive]], tries);
+                if (newPoint) {
+                    foundNewPoint = true;
+                    this.addPoint(newPoint);
+                    break;
+                }
+            }
+            if (!foundNewPoint) {
+                const deleteCount = 1;
+                this.active.splice(randomActive, deleteCount);
+            }
+            resolve();
+        });
+    }
+}

package/esm/PoissonInstance.js

@@ -0,0 +1,55 @@
+import { getRangeMax } from "@tsparticles/engine";
+import { PoissonDisc } from "./PoissonDisc.js";
+export class PoissonInstance {
+    constructor(container, engine) {
+        this._container = container;
+        this._engine = engine;
+        this._currentIndex = 0;
+    }
+    async init() {
+        await this._initData();
+    }
+    particlePosition(position) {
+        const container = this._container, options = container.actualOptions.poisson;
+        if (!this.poissonDisc || !(options?.enable ?? false) || this._currentIndex >= this.poissonDisc.points.length) {
+            return;
+        }
+        return position ?? this.poissonDisc?.points[this._currentIndex++]?.position;
+    }
+    resize() {
+        const container = this._container, options = container.actualOptions.poisson;
+        if (!(options?.enable ?? false)) {
+            return;
+        }
+        if (this.redrawTimeout) {
+            clearTimeout(this.redrawTimeout);
+        }
+        const timeout = 250;
+        this.redrawTimeout = window.setTimeout(() => {
+            void (async () => {
+                await this._initData();
+                await container.particles.redraw();
+            })();
+        }, timeout);
+    }
+    stop() {
+        delete this.poissonDisc;
+    }
+    async _initData() {
+        const container = this._container, poissonOptions = container.actualOptions.poisson, particlesOptions = container.actualOptions.particles, canvasSize = container.canvas.size, pixelRatio = container.retina.pixelRatio;
+        if (!poissonOptions?.enable) {
+            return;
+        }
+        this._currentIndex = 0;
+        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);
+        }
+        else {
+            await this.poissonDisc.run();
+        }
+    }
+}

package/esm/index.js

@@ -0,0 +1,27 @@
+import { Poisson } from "./Options/Classes/Poisson.js";
+import { PoissonInstance } from "./PoissonInstance.js";
+class PoissonDiscPlugin {
+    constructor(engine) {
+        this.id = "poisson";
+        this._engine = engine;
+    }
+    getPlugin(container) {
+        return new PoissonInstance(container, this._engine);
+    }
+    loadOptions(options, source) {
+        if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
+            return;
+        }
+        let poissonOptions = options.poisson;
+        if (poissonOptions?.load === undefined) {
+            options.poisson = poissonOptions = new Poisson();
+        }
+        poissonOptions.load(source?.poisson);
+    }
+    needsPlugin(options) {
+        return options?.poisson?.enable ?? false;
+    }
+}
+export async function loadPoissonDiscPlugin(engine, refresh = true) {
+    await engine.addPlugin(new PoissonDiscPlugin(engine), refresh);
+}

package/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@tsparticles/plugin-poisson-disc",
+  "version": "3.1.0",
+  "description": "tsParticles poisson disc plugin",
+  "homepage": "https://particles.js.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tsparticles/tsparticles.git",
+    "directory": "plugins/poisson"
+  },
+  "keywords": [
+    "front-end",
+    "frontend",
+    "tsparticles",
+    "particles.js",
+    "particlesjs",
+    "particles",
+    "particle",
+    "canvas",
+    "jsparticles",
+    "xparticles",
+    "particles-js",
+    "particles-bg",
+    "particles-bg-vue",
+    "particles-ts",
+    "particles.ts",
+    "react-particles-js",
+    "react-particles.js",
+    "react-particles",
+    "react",
+    "reactjs",
+    "vue-particles",
+    "ngx-particles",
+    "angular-particles",
+    "particleground",
+    "vue",
+    "vuejs",
+    "preact",
+    "preactjs",
+    "jquery",
+    "angularjs",
+    "angular",
+    "typescript",
+    "javascript",
+    "animation",
+    "web",
+    "html5",
+    "web-design",
+    "webdesign",
+    "css",
+    "html",
+    "css3",
+    "animated",
+    "background",
+    "confetti",
+    "canvas",
+    "fireworks",
+    "fireworks-js",
+    "confetti-js",
+    "confettijs",
+    "fireworksjs",
+    "canvas-confetti",
+    "tsparticles-plugin"
+  ],
+  "author": "Matteo Bruni <matteo.bruni@me.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tsparticles/tsparticles/issues"
+  },
+  "jsdelivr": "tsparticles.plugin.poisson.min.js",
+  "unpkg": "tsparticles.plugin.poisson.min.js",
+  "browser": "browser/index.js",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "browser": "./browser/index.js",
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js",
+      "umd": "./umd/index.js",
+      "default": "./cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@tsparticles/engine": "^3.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}