@tsparticles/engine/cjs/Core/Utils/SpatialHashGrid.js

Easily create highly customizable particle, confetti and fireworks animations and use them as animated backgrounds for your website. Ready to use components available also for React, Vue.js (2.x and 3.x), Angular, Svelte, jQuery, Preact, Riot.js, Inferno.

import { Circle, Rectangle } from "./Ranges.js";
export class SpatialHashGrid {
    #cellSize;
    #cells = new Map();
    #circlePool = [];
    #circlePoolIdx;
    #pendingCellSize;
    #rectanglePool = [];
    #rectanglePoolIdx;
    constructor(cellSize) {
        this.#cellSize = cellSize;
        this.#circlePoolIdx = 0;
        this.#rectanglePoolIdx = 0;
    }
    clear() {
        this.#cells.clear();
        const pendingCellSize = this.#pendingCellSize;
        if (pendingCellSize) {
            this.#cellSize = pendingCellSize;
        }
        this.#pendingCellSize = undefined;
    }
    insert(particle) {
        const { x, y } = particle.getPosition(), key = this.#cellKeyFromCoords(x, y);
        if (!this.#cells.has(key)) {
            this.#cells.set(key, []);
        }
        this.#cells.get(key)?.push(particle);
    }
    query(range, check, out = []) {
        const bounds = this.#getRangeBounds(range);
        if (!bounds) {
            return out;
        }
        const minCellX = Math.floor(bounds.minX / this.#cellSize), maxCellX = Math.floor(bounds.maxX / this.#cellSize), minCellY = Math.floor(bounds.minY / this.#cellSize), maxCellY = Math.floor(bounds.maxY / this.#cellSize);
        for (let cx = minCellX; cx <= maxCellX; cx++) {
            for (let cy = minCellY; cy <= maxCellY; cy++) {
                const key = `${cx}_${cy}`, cellParticles = this.#cells.get(key);
                if (!cellParticles) {
                    continue;
                }
                for (const p of cellParticles) {
                    if (check && !check(p)) {
                        continue;
                    }
                    if (range.contains(p.getPosition())) {
                        out.push(p);
                    }
                }
            }
        }
        return out;
    }
    queryCircle(position, radius, check, out = []) {
        const circle = this.#acquireCircle(position.x, position.y, radius), result = this.query(circle, check, out);
        this.#releaseShapes();
        return result;
    }
    queryRectangle(position, size, check, out = []) {
        const rect = this.#acquireRectangle(position.x, position.y, size.width, size.height), result = this.query(rect, check, out);
        this.#releaseShapes();
        return result;
    }
    setCellSize(cellSize) {
        this.#pendingCellSize = cellSize;
    }
    #acquireCircle(x, y, r) {
        return (this.#circlePool[this.#circlePoolIdx++] ??= new Circle(x, y, r)).reset(x, y, r);
    }
    #acquireRectangle(x, y, w, h) {
        return (this.#rectanglePool[this.#rectanglePoolIdx++] ??= new Rectangle(x, y, w, h)).reset(x, y, w, h);
    }
    #cellKeyFromCoords(x, y) {
        const cellX = Math.floor(x / this.#cellSize), cellY = Math.floor(y / this.#cellSize);
        return `${cellX}_${cellY}`;
    }
    #getRangeBounds(range) {
        if (range instanceof Circle) {
            const r = range.radius, { x, y } = range.position;
            return {
                minX: x - r,
                maxX: x + r,
                minY: y - r,
                maxY: y + r,
            };
        }
        if (range instanceof Rectangle) {
            const { x, y } = range.position, { width, height } = range.size;
            return {
                minX: x,
                maxX: x + width,
                minY: y,
                maxY: y + height,
            };
        }
        return null;
    }
    #releaseShapes() {
        this.#circlePoolIdx = 0;
        this.#rectanglePoolIdx = 0;
    }
}