@tsparticles/engine 4.0.0-alpha.8 → 4.0.0-beta.1

package/browser/Core/Particles.js

@@ -1,344 +0,0 @@
-import { countOffset, defaultDensityFactor, defaultRemoveQuantity, deleteCount, lengthOffset, minCount, minIndex, minLimit, posOffset, qTreeCapacity, sizeFactor, squareExp, } from "./Utils/Constants.js";
-import { EventType } from "../Enums/Types/EventType.js";
-import { LimitMode } from "../Enums/Modes/LimitMode.js";
-import { Particle } from "./Particle.js";
-import { Point } from "./Utils/Point.js";
-import { QuadTree } from "./Utils/QuadTree.js";
-import { Rectangle } from "./Utils/Ranges.js";
-import { getLogger } from "../Utils/LogUtils.js";
-import { loadParticlesOptions } from "../Utils/OptionsUtils.js";
-const qTreeRectangle = (canvasSize) => {
-    const { height, width } = canvasSize;
-    return new Rectangle(posOffset * width, posOffset * height, sizeFactor * width, sizeFactor * height);
-};
-export class Particles {
-    constructor(engine, container) {
-        this._addToPool = (...particles) => {
-            this._pool.push(...particles);
-        };
-        this._applyDensity = (options, pluginsCount, group, groupOptions) => {
-            const numberOptions = options.number;
-            if (!numberOptions.density.enable) {
-                if (group === undefined) {
-                    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);
-                }
-                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);
-            if (group === undefined) {
-                this._limit = numberOptions.limit.value * densityFactor;
-            }
-            else {
-                this._groupLimits.set(group, numberOptions.limit.value * densityFactor);
-            }
-            if (particlesCount < particlesNumber) {
-                this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
-            }
-            else if (particlesCount > particlesNumber) {
-                this.removeQuantity(particlesCount - particlesNumber, group);
-            }
-        };
-        this._initDensityFactor = densityOptions => {
-            const container = this._container;
-            if (!container.canvas.element || !densityOptions.enable) {
-                return defaultDensityFactor;
-            }
-            const canvas = container.canvas.element, pxRatio = container.retina.pixelRatio;
-            return (canvas.width * canvas.height) / (densityOptions.height * densityOptions.width * pxRatio ** squareExp);
-        };
-        this._pushParticle = (position, overrideOptions, group, initializer) => {
-            try {
-                const particle = this._pool.pop() ?? new Particle(this._engine, this._container);
-                particle.init(this._nextId, position, overrideOptions, group);
-                let canAdd = true;
-                if (initializer) {
-                    canAdd = initializer(particle);
-                }
-                if (!canAdd) {
-                    return;
-                }
-                this._array.push(particle);
-                this._zArray.push(particle);
-                this._nextId++;
-                this._engine.dispatchEvent(EventType.particleAdded, {
-                    container: this._container,
-                    data: {
-                        particle,
-                    },
-                });
-                return particle;
-            }
-            catch (e) {
-                getLogger().warning(`error adding particle: ${e}`);
-            }
-            return undefined;
-        };
-        this._removeParticle = (index, group, override) => {
-            const particle = this._array[index];
-            if (!particle) {
-                return false;
-            }
-            if (particle.group !== group) {
-                return false;
-            }
-            const zIdx = this._zArray.indexOf(particle);
-            this._array.splice(index, deleteCount);
-            this._zArray.splice(zIdx, deleteCount);
-            particle.destroy(override);
-            this._engine.dispatchEvent(EventType.particleRemoved, {
-                container: this._container,
-                data: {
-                    particle,
-                },
-            });
-            this._addToPool(particle);
-            return true;
-        };
-        this._engine = engine;
-        this._container = container;
-        this._nextId = 0;
-        this._array = [];
-        this._zArray = [];
-        this._pool = [];
-        this._limit = 0;
-        this._groupLimits = new Map();
-        this._needsSort = false;
-        this._lastZIndex = 0;
-        this._pluginsInitialized = false;
-        const canvasSize = container.canvas.size;
-        this.quadTree = new QuadTree(qTreeRectangle(canvasSize), qTreeCapacity);
-        this.movers = [];
-        this.updaters = [];
-    }
-    get count() {
-        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;
-        if (limit > minLimit) {
-            switch (limitMode) {
-                case LimitMode.delete: {
-                    const countToRemove = currentCount + countOffset - limit;
-                    if (countToRemove > minCount) {
-                        this.removeQuantity(countToRemove);
-                    }
-                    break;
-                }
-                case LimitMode.wait:
-                    if (currentCount >= limit) {
-                        return;
-                    }
-                    break;
-            }
-        }
-        return this._pushParticle(position, overrideOptions, group, initializer);
-    }
-    clear() {
-        this._array = [];
-        this._zArray = [];
-        this._pluginsInitialized = false;
-    }
-    destroy() {
-        this._array = [];
-        this._zArray = [];
-        this.movers = [];
-        this.updaters = [];
-    }
-    drawParticles(delta) {
-        for (const particle of this._zArray) {
-            particle.draw(delta);
-        }
-    }
-    filter(condition) {
-        return this._array.filter(condition);
-    }
-    find(condition) {
-        return this._array.find(condition);
-    }
-    get(index) {
-        return this._array[index];
-    }
-    async init() {
-        const container = this._container, options = container.actualOptions;
-        this._lastZIndex = 0;
-        this._needsSort = false;
-        for (const plugin of container.plugins) {
-            if (plugin.redrawInit) {
-                await plugin.redrawInit();
-            }
-        }
-        await this.initPlugins();
-        let handled = false;
-        for (const plugin of container.plugins) {
-            handled = plugin.particlesInitialization?.() ?? handled;
-            if (handled) {
-                break;
-            }
-        }
-        if (!handled) {
-            const particlesOptions = options.particles, groups = particlesOptions.groups;
-            for (const group in groups) {
-                const groupOptions = groups[group];
-                if (!groupOptions) {
-                    continue;
-                }
-                for (let i = this.count, j = 0; j < groupOptions.number.value && i < particlesOptions.number.value; i++, j++) {
-                    this.addParticle(undefined, groupOptions, group);
-                }
-            }
-            for (let i = this.count; i < particlesOptions.number.value; i++) {
-                this.addParticle();
-            }
-        }
-    }
-    async initPlugins() {
-        if (this._pluginsInitialized) {
-            return;
-        }
-        const container = this._container;
-        this.movers = await this._engine.getMovers(container, true);
-        this.updaters = await this._engine.getUpdaters(container, true);
-        for (const pathGenerator of container.pathGenerators.values()) {
-            pathGenerator.init(container);
-        }
-    }
-    push(nb, position, overrideOptions, group) {
-        for (let i = 0; i < nb; i++) {
-            this.addParticle(position, overrideOptions, group);
-        }
-    }
-    async redraw() {
-        this.clear();
-        await this.init();
-        this._container.canvas.drawParticles({ value: 0, factor: 0 });
-    }
-    remove(particle, group, override) {
-        this.removeAt(this._array.indexOf(particle), undefined, group, override);
-    }
-    removeAt(index, quantity = defaultRemoveQuantity, group, override) {
-        if (index < minIndex || index > this.count) {
-            return;
-        }
-        let deleted = 0;
-        for (let i = index; deleted < quantity && i < this.count; i++) {
-            if (this._removeParticle(i, group, override)) {
-                i--;
-                deleted++;
-            }
-        }
-    }
-    removeQuantity(quantity, group) {
-        this.removeAt(minIndex, quantity, group);
-    }
-    setDensity() {
-        const options = this._container.actualOptions, groups = options.particles.groups;
-        let pluginsCount = 0;
-        for (const plugin of this._container.plugins) {
-            if (plugin.particlesDensityCount) {
-                pluginsCount += plugin.particlesDensityCount();
-            }
-        }
-        for (const group in groups) {
-            const groupData = groups[group];
-            if (!groupData) {
-                continue;
-            }
-            const groupDataOptions = loadParticlesOptions(this._engine, this._container, groupData);
-            this._applyDensity(groupDataOptions, pluginsCount, group);
-        }
-        this._applyDensity(options.particles, pluginsCount);
-    }
-    setLastZIndex(zIndex) {
-        this._lastZIndex = zIndex;
-        this._needsSort = this._needsSort || this._lastZIndex < zIndex;
-    }
-    setResizeFactor(factor) {
-        this._resizeFactor = factor;
-    }
-    update(delta) {
-        const container = this._container, particlesToDelete = new Set();
-        this.quadTree = new QuadTree(qTreeRectangle(container.canvas.size), qTreeCapacity);
-        for (const pathGenerator of container.pathGenerators.values()) {
-            pathGenerator.update();
-        }
-        for (const plugin of container.plugins) {
-            plugin.update?.(delta);
-        }
-        const resizeFactor = this._resizeFactor;
-        for (const particle of this._array) {
-            if (resizeFactor && !particle.ignoresResizeRatio) {
-                particle.position.x *= resizeFactor.width;
-                particle.position.y *= resizeFactor.height;
-                particle.initialPosition.x *= resizeFactor.width;
-                particle.initialPosition.y *= resizeFactor.height;
-            }
-            particle.ignoresResizeRatio = false;
-            for (const plugin of this._container.plugins) {
-                if (plugin.particleReset) {
-                    plugin.particleReset(particle);
-                }
-            }
-            for (const plugin of this._container.plugins) {
-                if (particle.destroyed) {
-                    break;
-                }
-                plugin.particleUpdate?.(particle, delta);
-            }
-            for (const mover of this.movers) {
-                if (mover.isEnabled(particle)) {
-                    mover.move(particle, delta);
-                }
-            }
-            if (particle.destroyed) {
-                particlesToDelete.add(particle);
-                continue;
-            }
-            this.quadTree.insert(new Point(particle.getPosition(), particle));
-        }
-        if (particlesToDelete.size) {
-            const checkDelete = (p) => !particlesToDelete.has(p);
-            this._array = this.filter(checkDelete);
-            this._zArray = this._zArray.filter(checkDelete);
-            for (const particle of particlesToDelete) {
-                this._engine.dispatchEvent(EventType.particleRemoved, {
-                    container: this._container,
-                    data: {
-                        particle,
-                    },
-                });
-            }
-            this._addToPool(...particlesToDelete);
-        }
-        for (const plugin of container.plugins) {
-            if (plugin.postUpdate) {
-                plugin.postUpdate(delta);
-            }
-        }
-        for (const particle of this._array) {
-            for (const updater of this.updaters) {
-                updater.update(particle, delta);
-            }
-            if (!particle.destroyed && !particle.spawning) {
-                for (const plugin of container.plugins) {
-                    if (plugin.postParticleUpdate) {
-                        plugin.postParticleUpdate(particle, delta);
-                    }
-                }
-            }
-        }
-        delete this._resizeFactor;
-        if (this._needsSort) {
-            const zArray = this._zArray;
-            zArray.sort((a, b) => b.position.z - a.position.z || a.id - b.id);
-            const lastItem = zArray[zArray.length - lengthOffset];
-            if (!lastItem) {
-                return;
-            }
-            this._lastZIndex = lastItem.position.z;
-            this._needsSort = false;
-        }
-    }
-}

package/browser/Core/Utils/Point.js

@@ -1,6 +0,0 @@
-export class Point {
-    constructor(position, particle) {
-        this.position = position;
-        this.particle = particle;
-    }
-}

package/browser/Core/Utils/QuadTree.js

@@ -1,59 +0,0 @@
-import { Circle, Rectangle } from "./Ranges.js";
-import { double, half, subdivideCount } from "./Constants.js";
-import { getDistance } from "../../Utils/MathUtils.js";
-export class QuadTree {
-    constructor(rectangle, capacity) {
-        this.rectangle = rectangle;
-        this.capacity = capacity;
-        this._subdivide = () => {
-            const { x, y } = this.rectangle.position, { width, height } = this.rectangle.size, { capacity } = this;
-            for (let i = 0; i < subdivideCount; i++) {
-                const fixedIndex = i % double;
-                this._subs.push(new QuadTree(new Rectangle(x + width * half * fixedIndex, y + height * half * (Math.round(i * half) - fixedIndex), width * half, height * half), capacity));
-            }
-            this._divided = true;
-        };
-        this._points = [];
-        this._divided = false;
-        this._subs = [];
-    }
-    insert(point) {
-        if (!this.rectangle.contains(point.position)) {
-            return false;
-        }
-        if (this._points.length < this.capacity) {
-            this._points.push(point);
-            return true;
-        }
-        if (!this._divided) {
-            this._subdivide();
-        }
-        return this._subs.some(sub => sub.insert(point));
-    }
-    query(range, check) {
-        const res = [];
-        if (!range.intersects(this.rectangle)) {
-            return [];
-        }
-        for (const p of this._points) {
-            if (!range.contains(p.position) &&
-                getDistance(range.position, p.position) > p.particle.getRadius() &&
-                (!check || check(p.particle))) {
-                continue;
-            }
-            res.push(p.particle);
-        }
-        if (this._divided) {
-            for (const sub of this._subs) {
-                res.push(...sub.query(range, check));
-            }
-        }
-        return res;
-    }
-    queryCircle(position, radius, check) {
-        return this.query(new Circle(position.x, position.y, radius), check);
-    }
-    queryRectangle(position, size, check) {
-        return this.query(new Rectangle(position.x, position.y, size.width, size.height), check);
-    }
-}

package/browser/Options/Classes/Particles/Move/MoveAttract.js

@@ -1,33 +0,0 @@
-import { isNull } from "../../../../Utils/TypeUtils.js";
-import { setRangeValue } from "../../../../Utils/MathUtils.js";
-export class MoveAttract {
-    constructor() {
-        this.distance = 200;
-        this.enable = false;
-        this.rotate = {
-            x: 3000,
-            y: 3000,
-        };
-    }
-    load(data) {
-        if (isNull(data)) {
-            return;
-        }
-        if (data.distance !== undefined) {
-            this.distance = setRangeValue(data.distance);
-        }
-        if (data.enable !== undefined) {
-            this.enable = data.enable;
-        }
-        if (data.rotate) {
-            const rotateX = data.rotate.x;
-            if (rotateX !== undefined) {
-                this.rotate.x = rotateX;
-            }
-            const rotateY = data.rotate.y;
-            if (rotateY !== undefined) {
-                this.rotate.y = rotateY;
-            }
-        }
-    }
-}