@tsparticles/engine 3.0.0-alpha.0

package/umd/Core/Utils/ExternalInteractorBase.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExternalInteractorBase = void 0;
+    class ExternalInteractorBase {
+        constructor(container) {
+            this.container = container;
+            this.type = "external";
+        }
+    }
+    exports.ExternalInteractorBase = ExternalInteractorBase;
+});

package/umd/Core/Utils/FrameManager.js

@@ -0,0 +1,56 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FrameManager = void 0;
+    function initDelta(value, fpsLimit = 60, smooth = false) {
+        return {
+            value,
+            factor: smooth ? 60 / fpsLimit : (60 * value) / 1000,
+        };
+    }
+    class FrameManager {
+        constructor(container) {
+            this.container = container;
+        }
+        async nextFrame(timestamp) {
+            var _a;
+            try {
+                const container = this.container;
+                if (!container.smooth &&
+                    container.lastFrameTime !== undefined &&
+                    timestamp < container.lastFrameTime + 1000 / container.fpsLimit) {
+                    container.draw(false);
+                    return;
+                }
+                (_a = container.lastFrameTime) !== null && _a !== void 0 ? _a : (container.lastFrameTime = timestamp);
+                const delta = initDelta(timestamp - container.lastFrameTime, container.fpsLimit, container.smooth);
+                container.lifeTime += delta.value;
+                container.lastFrameTime = timestamp;
+                if (delta.value > 1000) {
+                    container.draw(false);
+                    return;
+                }
+                await container.particles.draw(delta);
+                if (container.duration > 0 && container.lifeTime > container.duration) {
+                    container.destroy();
+                    return;
+                }
+                if (container.getAnimationStatus()) {
+                    container.draw(false);
+                }
+            }
+            catch (e) {
+                console.error("tsParticles error in animation loop", e);
+            }
+        }
+    }
+    exports.FrameManager = FrameManager;
+});

package/umd/Core/Utils/InteractionManager.js

@@ -0,0 +1,74 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.InteractionManager = void 0;
+    class InteractionManager {
+        constructor(engine, container) {
+            this.container = container;
+            this._engine = engine;
+            this._interactors = this._engine.plugins.getInteractors(this.container, true);
+            this._externalInteractors = [];
+            this._particleInteractors = [];
+        }
+        async externalInteract(delta) {
+            for (const interactor of this._externalInteractors) {
+                if (interactor.isEnabled()) {
+                    await interactor.interact(delta);
+                }
+            }
+        }
+        handleClickMode(mode) {
+            for (const interactor of this._externalInteractors) {
+                if (interactor.handleClickMode) {
+                    interactor.handleClickMode(mode);
+                }
+            }
+        }
+        init() {
+            this._externalInteractors = [];
+            this._particleInteractors = [];
+            for (const interactor of this._interactors) {
+                switch (interactor.type) {
+                    case "external":
+                        this._externalInteractors.push(interactor);
+                        break;
+                    case "particles":
+                        this._particleInteractors.push(interactor);
+                        break;
+                }
+                interactor.init();
+            }
+        }
+        async particlesInteract(particle, delta) {
+            for (const interactor of this._externalInteractors) {
+                interactor.clear(particle, delta);
+            }
+            for (const interactor of this._particleInteractors) {
+                if (interactor.isEnabled(particle)) {
+                    await interactor.interact(particle, delta);
+                }
+            }
+        }
+        async reset(particle) {
+            for (const interactor of this._externalInteractors) {
+                if (interactor.isEnabled()) {
+                    await interactor.reset(particle);
+                }
+            }
+            for (const interactor of this._particleInteractors) {
+                if (interactor.isEnabled(particle)) {
+                    await interactor.reset(particle);
+                }
+            }
+        }
+    }
+    exports.InteractionManager = InteractionManager;
+});

package/umd/Core/Utils/ParticlesInteractorBase.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ParticlesInteractorBase = void 0;
+    class ParticlesInteractorBase {
+        constructor(container) {
+            this.container = container;
+            this.type = "particles";
+        }
+    }
+    exports.ParticlesInteractorBase = ParticlesInteractorBase;
+});

package/umd/Core/Utils/Plugins.js

@@ -0,0 +1,126 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../Utils/Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Plugins = void 0;
+    const Utils_1 = require("../../Utils/Utils");
+    function getItemsFromInitializer(container, map, initializers, force = false) {
+        let res = map.get(container);
+        if (!res || force) {
+            res = [...initializers.values()].map((t) => t(container));
+            map.set(container, res);
+        }
+        return res;
+    }
+    class Plugins {
+        constructor(engine) {
+            this._engine = engine;
+            this.plugins = [];
+            this._initializers = {
+                interactors: new Map(),
+                movers: new Map(),
+                updaters: new Map(),
+            };
+            this.interactors = new Map();
+            this.movers = new Map();
+            this.updaters = new Map();
+            this.presets = new Map();
+            this.drawers = new Map();
+            this.pathGenerators = new Map();
+        }
+        addInteractor(name, initInteractor) {
+            this._initializers.interactors.set(name, initInteractor);
+        }
+        addParticleMover(name, initMover) {
+            this._initializers.movers.set(name, initMover);
+        }
+        addParticleUpdater(name, initUpdater) {
+            this._initializers.updaters.set(name, initUpdater);
+        }
+        addPathGenerator(type, pathGenerator) {
+            if (!this.getPathGenerator(type)) {
+                this.pathGenerators.set(type, pathGenerator);
+            }
+        }
+        addPlugin(plugin) {
+            if (!this.getPlugin(plugin.id)) {
+                this.plugins.push(plugin);
+            }
+        }
+        addPreset(presetKey, options, override = false) {
+            if (override || !this.getPreset(presetKey)) {
+                this.presets.set(presetKey, options);
+            }
+        }
+        addShapeDrawer(types, drawer) {
+            (0, Utils_1.executeOnSingleOrMultiple)(types, (type) => {
+                if (!this.getShapeDrawer(type)) {
+                    this.drawers.set(type, drawer);
+                }
+            });
+        }
+        destroy(container) {
+            this.updaters.delete(container);
+            this.movers.delete(container);
+            this.interactors.delete(container);
+        }
+        getAvailablePlugins(container) {
+            const res = new Map();
+            for (const plugin of this.plugins) {
+                if (!plugin.needsPlugin(container.actualOptions)) {
+                    continue;
+                }
+                res.set(plugin.id, plugin.getPlugin(container));
+            }
+            return res;
+        }
+        getInteractors(container, force = false) {
+            return getItemsFromInitializer(container, this.interactors, this._initializers.interactors, force);
+        }
+        getMovers(container, force = false) {
+            return getItemsFromInitializer(container, this.movers, this._initializers.movers, force);
+        }
+        getPathGenerator(type) {
+            return this.pathGenerators.get(type);
+        }
+        getPlugin(plugin) {
+            return this.plugins.find((t) => t.id === plugin);
+        }
+        getPreset(preset) {
+            return this.presets.get(preset);
+        }
+        getShapeDrawer(type) {
+            return this.drawers.get(type);
+        }
+        getSupportedShapes() {
+            return this.drawers.keys();
+        }
+        getUpdaters(container, force = false) {
+            return getItemsFromInitializer(container, this.updaters, this._initializers.updaters, force);
+        }
+        loadOptions(options, sourceOptions) {
+            for (const plugin of this.plugins) {
+                plugin.loadOptions(options, sourceOptions);
+            }
+        }
+        loadParticlesOptions(container, options, ...sourceOptions) {
+            const updaters = this.updaters.get(container);
+            if (!updaters) {
+                return;
+            }
+            for (const updater of updaters) {
+                if (updater.loadOptions) {
+                    updater.loadOptions(options, ...sourceOptions);
+                }
+            }
+        }
+    }
+    exports.Plugins = Plugins;
+});

package/umd/Core/Utils/Point.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Point = void 0;
+    class Point {
+        constructor(position, particle) {
+            this.position = position;
+            this.particle = particle;
+        }
+    }
+    exports.Point = Point;
+});

package/umd/Core/Utils/QuadTree.js

@@ -0,0 +1,78 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Circle", "./Rectangle", "../../Utils/NumberUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.QuadTree = void 0;
+    const Circle_1 = require("./Circle");
+    const Rectangle_1 = require("./Rectangle");
+    const NumberUtils_1 = require("../../Utils/NumberUtils");
+    class QuadTree {
+        constructor(rectangle, capacity) {
+            this.rectangle = rectangle;
+            this.capacity = capacity;
+            this._points = [];
+            this._divided = false;
+        }
+        insert(point) {
+            var _a, _b, _c, _d, _e;
+            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 ((_e = (((_a = this._NE) === null || _a === void 0 ? void 0 : _a.insert(point)) ||
+                ((_b = this._NW) === null || _b === void 0 ? void 0 : _b.insert(point)) ||
+                ((_c = this._SE) === null || _c === void 0 ? void 0 : _c.insert(point)) ||
+                ((_d = this._SW) === null || _d === void 0 ? void 0 : _d.insert(point)))) !== null && _e !== void 0 ? _e : false);
+        }
+        query(range, check, found) {
+            var _a, _b, _c, _d;
+            const res = found !== null && found !== void 0 ? found : [];
+            if (!range.intersects(this.rectangle)) {
+                return [];
+            }
+            for (const p of this._points) {
+                if (!range.contains(p.position) &&
+                    (0, NumberUtils_1.getDistance)(range.position, p.position) > p.particle.getRadius() &&
+                    (!check || check(p.particle))) {
+                    continue;
+                }
+                res.push(p.particle);
+            }
+            if (this._divided) {
+                (_a = this._NE) === null || _a === void 0 ? void 0 : _a.query(range, check, res);
+                (_b = this._NW) === null || _b === void 0 ? void 0 : _b.query(range, check, res);
+                (_c = this._SE) === null || _c === void 0 ? void 0 : _c.query(range, check, res);
+                (_d = this._SW) === null || _d === void 0 ? void 0 : _d.query(range, check, res);
+            }
+            return res;
+        }
+        queryCircle(position, radius, check) {
+            return this.query(new Circle_1.Circle(position.x, position.y, radius), check);
+        }
+        queryRectangle(position, size, check) {
+            return this.query(new Rectangle_1.Rectangle(position.x, position.y, size.width, size.height), check);
+        }
+        subdivide() {
+            const x = this.rectangle.position.x, y = this.rectangle.position.y, w = this.rectangle.size.width, h = this.rectangle.size.height, capacity = this.capacity;
+            this._NE = new QuadTree(new Rectangle_1.Rectangle(x, y, w / 2, h / 2), capacity);
+            this._NW = new QuadTree(new Rectangle_1.Rectangle(x + w / 2, y, w / 2, h / 2), capacity);
+            this._SE = new QuadTree(new Rectangle_1.Rectangle(x, y + h / 2, w / 2, h / 2), capacity);
+            this._SW = new QuadTree(new Rectangle_1.Rectangle(x + w / 2, y + h / 2, w / 2, h / 2), capacity);
+            this._divided = true;
+        }
+    }
+    exports.QuadTree = QuadTree;
+});

package/umd/Core/Utils/Range.js

@@ -0,0 +1,22 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Range = void 0;
+    class Range {
+        constructor(x, y) {
+            this.position = {
+                x: x,
+                y: y,
+            };
+        }
+    }
+    exports.Range = Range;
+});

package/umd/Core/Utils/Rectangle.js

@@ -0,0 +1,36 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Circle", "./Range"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Rectangle = void 0;
+    const Circle_1 = require("./Circle");
+    const Range_1 = require("./Range");
+    class Rectangle extends Range_1.Range {
+        constructor(x, y, width, height) {
+            super(x, y);
+            this.size = {
+                height: height,
+                width: width,
+            };
+        }
+        contains(point) {
+            const w = this.size.width, h = this.size.height, pos = this.position;
+            return point.x >= pos.x && point.x <= pos.x + w && point.y >= pos.y && point.y <= pos.y + h;
+        }
+        intersects(range) {
+            if (range instanceof Circle_1.Circle) {
+                range.intersects(this);
+            }
+            const w = this.size.width, h = this.size.height, pos1 = this.position, pos2 = range.position, size2 = range instanceof Rectangle ? range.size : { width: 0, height: 0 }, w2 = size2.width, h2 = size2.height;
+            return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
+        }
+    }
+    exports.Rectangle = Rectangle;
+});

package/umd/Core/Utils/Vector.js

@@ -0,0 +1,29 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Vector3d"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Vector = void 0;
+    const Vector3d_1 = require("./Vector3d");
+    class Vector extends Vector3d_1.Vector3d {
+        constructor(xOrCoords, y) {
+            super(xOrCoords, y, 0);
+        }
+        static get origin() {
+            return Vector.create(0, 0);
+        }
+        static clone(source) {
+            return Vector.create(source.x, source.y);
+        }
+        static create(x, y) {
+            return new Vector(x, y);
+        }
+    }
+    exports.Vector = Vector;
+});

package/umd/Core/Utils/Vector3d.js

@@ -0,0 +1,110 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Vector3d = void 0;
+    class Vector3d {
+        constructor(xOrCoords, y, z) {
+            if (typeof xOrCoords !== "number" && xOrCoords) {
+                this.x = xOrCoords.x;
+                this.y = xOrCoords.y;
+                const coords3d = xOrCoords;
+                this.z = coords3d.z ? coords3d.z : 0;
+            }
+            else if (xOrCoords !== undefined && y !== undefined) {
+                this.x = xOrCoords;
+                this.y = y;
+                this.z = z !== null && z !== void 0 ? z : 0;
+            }
+            else {
+                throw new Error("tsParticles - Vector3d not initialized correctly");
+            }
+        }
+        static get origin() {
+            return Vector3d.create(0, 0, 0);
+        }
+        get angle() {
+            return Math.atan2(this.y, this.x);
+        }
+        set angle(angle) {
+            this.updateFromAngle(angle, this.length);
+        }
+        get length() {
+            return Math.sqrt(this.getLengthSq());
+        }
+        set length(length) {
+            this.updateFromAngle(this.angle, length);
+        }
+        static clone(source) {
+            return Vector3d.create(source.x, source.y, source.z);
+        }
+        static create(x, y, z) {
+            return new Vector3d(x, y, z);
+        }
+        add(v) {
+            return Vector3d.create(this.x + v.x, this.y + v.y, this.z + v.z);
+        }
+        addTo(v) {
+            this.x += v.x;
+            this.y += v.y;
+            this.z += v.z;
+        }
+        copy() {
+            return Vector3d.clone(this);
+        }
+        distanceTo(v) {
+            return this.sub(v).length;
+        }
+        distanceToSq(v) {
+            return this.sub(v).getLengthSq();
+        }
+        div(n) {
+            return Vector3d.create(this.x / n, this.y / n, this.z / n);
+        }
+        divTo(n) {
+            this.x /= n;
+            this.y /= n;
+            this.z /= n;
+        }
+        getLengthSq() {
+            return this.x ** 2 + this.y ** 2;
+        }
+        mult(n) {
+            return Vector3d.create(this.x * n, this.y * n, this.z * n);
+        }
+        multTo(n) {
+            this.x *= n;
+            this.y *= n;
+            this.z *= n;
+        }
+        rotate(angle) {
+            return Vector3d.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle), 0);
+        }
+        setTo(c) {
+            this.x = c.x;
+            this.y = c.y;
+            const v3d = c;
+            this.z = v3d.z ? v3d.z : 0;
+        }
+        sub(v) {
+            return Vector3d.create(this.x - v.x, this.y - v.y, this.z - v.z);
+        }
+        subFrom(v) {
+            this.x -= v.x;
+            this.y -= v.y;
+            this.z -= v.z;
+        }
+        updateFromAngle(angle, length) {
+            this.x = Math.cos(angle) * length;
+            this.y = Math.sin(angle) * length;
+        }
+    }
+    exports.Vector3d = Vector3d;
+});

package/umd/Enums/AnimationStatus.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Enums/Directions/MoveDirection.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Enums/Directions/OutModeDirection.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Enums/Directions/RotateDirection.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Enums/InteractivityDetect.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});