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

package/cjs/Core/Container.js

@@ -1,10 +1,10 @@
 import { animate, cancelAnimation, getRangeValue } from "../Utils/MathUtils.js";
-import { defaultFps, defaultFpsLimit, millisecondsToSeconds, minFpsLimit, removeDeleteCount, removeMinIndex, } from "./Utils/Constants.js";
-import { Canvas } from "./Canvas.js";
+import { defaultFps, defaultFpsLimit, millisecondsToSeconds, minFpsLimit } from "./Utils/Constants.js";
+import { CanvasManager } from "./CanvasManager.js";
 import { EventListeners } from "./Utils/EventListeners.js";
 import { EventType } from "../Enums/Types/EventType.js";
 import { Options } from "../Options/Classes/Options.js";
-import { Particles } from "./Particles.js";
+import { ParticlesManager } from "./ParticlesManager.js";
 import { Retina } from "./Retina.js";
 import { getLogger } from "../Utils/LogUtils.js";
 import { loadOptions } from "../Utils/OptionsUtils.js";
@@ -15,44 +15,52 @@ function updateDelta(delta, value, fpsLimit = defaultFps, smooth = false) {
     delta.value = value;
     delta.factor = smooth ? defaultFps / fpsLimit : (defaultFps * value) / millisecondsToSeconds;
 }
-function loadContainerOptions(engine, container, ...sourceOptionsArr) {
-    const options = new Options(engine, container);
+function loadContainerOptions(pluginManager, container, ...sourceOptionsArr) {
+    const options = new Options(pluginManager, container);
     loadOptions(options, ...sourceOptionsArr);
     return options;
 }
 export class Container {
-    constructor(engine, id, sourceOptions) {
-        this._delta = { value: 0, factor: 0 };
-        this._nextFrame = (timestamp) => {
-            try {
-                if (!this._smooth &&
-                    this._lastFrameTime !== undefined &&
-                    timestamp < this._lastFrameTime + millisecondsToSeconds / this.fpsLimit) {
-                    this.draw(false);
-                    return;
-                }
-                this._lastFrameTime ??= timestamp;
-                updateDelta(this._delta, timestamp - this._lastFrameTime, this.fpsLimit, this._smooth);
-                this.addLifeTime(this._delta.value);
-                this._lastFrameTime = timestamp;
-                if (this._delta.value > millisecondsToSeconds) {
-                    this.draw(false);
-                    return;
-                }
-                this.canvas.drawParticles(this._delta);
-                if (!this.alive()) {
-                    this.destroy();
-                    return;
-                }
-                if (this.animationStatus) {
-                    this.draw(false);
-                }
-            }
-            catch (e) {
-                getLogger().error("error in animation loop", e);
-            }
-        };
-        this._engine = engine;
+    actualOptions;
+    canvas;
+    destroyed;
+    effectDrawers;
+    fpsLimit;
+    hdr;
+    id;
+    pageHidden;
+    particleCreatedPlugins;
+    particleDestroyedPlugins;
+    particlePositionPlugins;
+    particleUpdaters;
+    particles;
+    plugins;
+    retina;
+    shapeDrawers;
+    started;
+    zLayers;
+    _delay;
+    _delayTimeout;
+    _delta = { value: 0, factor: 0 };
+    _dispatchCallback;
+    _drawAnimationFrame;
+    _duration;
+    _eventListeners;
+    _firstStart;
+    _initialSourceOptions;
+    _lastFrameTime;
+    _lifeTime;
+    _onDestroy;
+    _options;
+    _paused;
+    _pluginManager;
+    _smooth;
+    _sourceOptions;
+    constructor(params) {
+        const { dispatchCallback, pluginManager, id, onDestroy, sourceOptions } = params;
+        this._pluginManager = pluginManager;
+        this._dispatchCallback = dispatchCallback;
+        this._onDestroy = onDestroy;
         this.id = Symbol(id);
         this.fpsLimit = 120;
         this.hdr = false;
@@ -69,17 +77,20 @@ export class Container {
         this.pageHidden = false;
         this._sourceOptions = sourceOptions;
         this._initialSourceOptions = sourceOptions;
-        this.retina = new Retina(this);
-        this.canvas = new Canvas(this, this._engine);
-        this.particles = new Particles(this._engine, this);
-        this.pathGenerators = new Map();
-        this.plugins = [];
         this.effectDrawers = new Map();
         this.shapeDrawers = new Map();
-        this._options = loadContainerOptions(this._engine, this);
-        this.actualOptions = loadContainerOptions(this._engine, this);
+        this.particleUpdaters = [];
+        this.retina = new Retina(this);
+        this.canvas = new CanvasManager(this._pluginManager, this);
+        this.particles = new ParticlesManager(this._pluginManager, this);
+        this.plugins = [];
+        this.particleDestroyedPlugins = [];
+        this.particleCreatedPlugins = [];
+        this.particlePositionPlugins = [];
+        this._options = loadContainerOptions(this._pluginManager, this);
+        this.actualOptions = loadContainerOptions(this._pluginManager, this);
         this._eventListeners = new EventListeners(this);
-        this._engine.dispatchEvent(EventType.containerBuilt, { container: this });
+        this.dispatchEvent(EventType.containerBuilt);
     }
     get animationStatus() {
         return !this._paused && !this.pageHidden && guardCheck(this);
@@ -93,13 +104,6 @@ export class Container {
     addLifeTime(value) {
         this._lifeTime += value;
     }
-    addPath(key, generator, override = false) {
-        if (!guardCheck(this) || (!override && this.pathGenerators.has(key))) {
-            return false;
-        }
-        this.pathGenerators.set(key, generator);
-        return true;
-    }
     alive() {
         return !this._duration || this._lifeTime <= this._duration;
     }
@@ -110,42 +114,41 @@ export class Container {
         this.stop();
         this.particles.destroy();
         this.canvas.destroy();
-        for (const effectDrawer of this.effectDrawers.values()) {
+        for (const [, effectDrawer] of this.effectDrawers) {
             effectDrawer.destroy?.(this);
         }
-        this.effectDrawers.clear();
-        for (const shapeDrawer of this.shapeDrawers.values()) {
+        for (const [, shapeDrawer] of this.shapeDrawers) {
             shapeDrawer.destroy?.(this);
         }
-        this.shapeDrawers.clear();
         for (const plugin of this.plugins) {
             plugin.destroy?.();
         }
+        this.effectDrawers = new Map();
+        this.shapeDrawers = new Map();
+        this.particleUpdaters = [];
         this.plugins.length = 0;
-        this._engine.clearPlugins(this);
+        this._pluginManager.clearPlugins(this);
         this.destroyed = true;
-        if (remove) {
-            const mainArr = this._engine.items, idx = mainArr.indexOf(this);
-            if (idx >= removeMinIndex) {
-                mainArr.splice(idx, removeDeleteCount);
-            }
-        }
-        this._engine.dispatchEvent(EventType.containerDestroyed, { container: this });
+        this._onDestroy(remove);
+        this.dispatchEvent(EventType.containerDestroyed);
+    }
+    dispatchEvent(type, data) {
+        this._dispatchCallback(type, {
+            container: this,
+            data,
+        });
     }
     draw(force) {
         if (!guardCheck(this)) {
             return;
         }
         let refreshTime = force;
-        const frame = (timestamp) => {
+        this._drawAnimationFrame = animate((timestamp) => {
             if (refreshTime) {
                 this._lastFrameTime = undefined;
                 refreshTime = false;
             }
             this._nextFrame(timestamp);
-        };
-        this._drawAnimationFrame = animate(timestamp => {
-            frame(timestamp);
         });
     }
     async export(type, options = {}) {
@@ -166,34 +169,33 @@ export class Container {
         if (!guardCheck(this)) {
             return;
         }
-        const effects = this._engine.getSupportedEffects();
-        for (const type of effects) {
-            const drawer = this._engine.getEffectDrawer(type);
-            if (drawer) {
-                this.effectDrawers.set(type, drawer);
-            }
-        }
-        const shapes = this._engine.getSupportedShapes();
-        for (const type of shapes) {
-            const drawer = this._engine.getShapeDrawer(type);
-            if (drawer) {
-                this.shapeDrawers.set(type, drawer);
-            }
-        }
         const allContainerPlugins = new Map();
-        for (const plugin of this._engine.plugins) {
+        for (const plugin of this._pluginManager.plugins) {
             const containerPlugin = await plugin.getPlugin(this);
             if (containerPlugin.preInit) {
                 await containerPlugin.preInit();
             }
             allContainerPlugins.set(plugin, containerPlugin);
         }
-        await this.particles.initPlugins();
-        this._options = loadContainerOptions(this._engine, this, this._initialSourceOptions, this.sourceOptions);
-        this.actualOptions = loadContainerOptions(this._engine, this, this._options);
+        await this.initDrawersAndUpdaters();
+        this._options = loadContainerOptions(this._pluginManager, this, this._initialSourceOptions, this.sourceOptions);
+        this.actualOptions = loadContainerOptions(this._pluginManager, this, this._options);
+        this.plugins.length = 0;
+        this.particleDestroyedPlugins.length = 0;
+        this.particleCreatedPlugins.length = 0;
+        this.particlePositionPlugins.length = 0;
         for (const [plugin, containerPlugin] of allContainerPlugins) {
             if (plugin.needsPlugin(this.actualOptions)) {
                 this.plugins.push(containerPlugin);
+                if (containerPlugin.particleCreated) {
+                    this.particleCreatedPlugins.push(containerPlugin);
+                }
+                if (containerPlugin.particleDestroyed) {
+                    this.particleDestroyedPlugins.push(containerPlugin);
+                }
+                if (containerPlugin.particlePosition) {
+                    this.particlePositionPlugins.push(containerPlugin);
+                }
             }
         }
         this.retina.init();
@@ -212,19 +214,19 @@ export class Container {
         for (const plugin of this.plugins) {
             await plugin.init?.();
         }
-        for (const drawer of this.effectDrawers.values()) {
-            await drawer.init?.(this);
-        }
-        for (const drawer of this.shapeDrawers.values()) {
-            await drawer.init?.(this);
-        }
-        this._engine.dispatchEvent(EventType.containerInit, { container: this });
         await this.particles.init();
+        this.dispatchEvent(EventType.containerInit);
         this.particles.setDensity();
         for (const plugin of this.plugins) {
             plugin.particlesSetup?.();
         }
-        this._engine.dispatchEvent(EventType.particlesSetup, { container: this });
+        this.dispatchEvent(EventType.particlesSetup);
+    }
+    async initDrawersAndUpdaters() {
+        const pluginManager = this._pluginManager;
+        this.effectDrawers = await pluginManager.getEffectDrawers(this, true);
+        this.shapeDrawers = await pluginManager.getShapeDrawers(this, true);
+        this.particleUpdaters = await pluginManager.getUpdaters(this, true);
     }
     pause() {
         if (!guardCheck(this)) {
@@ -243,7 +245,7 @@ export class Container {
         if (!this.pageHidden) {
             this._paused = true;
         }
-        this._engine.dispatchEvent(EventType.containerPaused, { container: this });
+        this.dispatchEvent(EventType.containerPaused);
     }
     play(force) {
         if (!guardCheck(this)) {
@@ -264,7 +266,7 @@ export class Container {
                 }
             }
         }
-        this._engine.dispatchEvent(EventType.containerPlay, { container: this });
+        this.dispatchEvent(EventType.containerPlay);
         this.draw(needsUpdate ?? false);
     }
     async refresh() {
@@ -280,8 +282,8 @@ export class Container {
         }
         this._initialSourceOptions = sourceOptions;
         this._sourceOptions = sourceOptions;
-        this._options = loadContainerOptions(this._engine, this, this._initialSourceOptions, this.sourceOptions);
-        this.actualOptions = loadContainerOptions(this._engine, this, this._options);
+        this._options = loadContainerOptions(this._pluginManager, this, this._initialSourceOptions, this.sourceOptions);
+        this.actualOptions = loadContainerOptions(this._pluginManager, this, this._options);
         return this.refresh();
     }
     async start() {
@@ -296,7 +298,7 @@ export class Container {
                 for (const plugin of this.plugins) {
                     await plugin.start?.();
                 }
-                this._engine.dispatchEvent(EventType.containerStarted, { container: this });
+                this.dispatchEvent(EventType.containerStarted);
                 this.play();
                 resolve();
             };
@@ -320,9 +322,11 @@ export class Container {
         for (const plugin of this.plugins) {
             plugin.stop?.();
         }
-        this.plugins.length = 0;
+        this.particleCreatedPlugins.length = 0;
+        this.particleDestroyedPlugins.length = 0;
+        this.particlePositionPlugins.length = 0;
         this._sourceOptions = this._options;
-        this._engine.dispatchEvent(EventType.containerStopped, { container: this });
+        this.dispatchEvent(EventType.containerStopped);
     }
     updateActualOptions() {
         let refresh = false;
@@ -333,4 +337,33 @@ export class Container {
         }
         return refresh;
     }
+    _nextFrame = (timestamp) => {
+        try {
+            if (!this._smooth &&
+                this._lastFrameTime !== undefined &&
+                timestamp < this._lastFrameTime + millisecondsToSeconds / this.fpsLimit) {
+                this.draw(false);
+                return;
+            }
+            this._lastFrameTime ??= timestamp;
+            updateDelta(this._delta, timestamp - this._lastFrameTime, this.fpsLimit, this._smooth);
+            this.addLifeTime(this._delta.value);
+            this._lastFrameTime = timestamp;
+            if (this._delta.value > millisecondsToSeconds) {
+                this.draw(false);
+                return;
+            }
+            this.canvas.render.drawParticles(this._delta);
+            if (!this.alive()) {
+                this.destroy();
+                return;
+            }
+            if (this.animationStatus) {
+                this.draw(false);
+            }
+        }
+        catch (e) {
+            getLogger().error("error in animation loop", e);
+        }
+    };
 }

package/cjs/Core/Engine.js

@@ -1,7 +1,7 @@
-import { canvasFirstIndex, canvasTag, generatedAttribute, generatedFalse, generatedTrue, loadMinIndex, loadRandomFactor, none, one, removeDeleteCount, } from "./Utils/Constants.js";
-import { getItemsFromInitializer, itemFromSingleOrMultiple, safeDocument } from "../Utils/Utils.js";
+import { canvasFirstIndex, canvasTag, generatedAttribute, generatedFalse, generatedTrue, loadMinIndex, loadRandomFactor, none, one, removeDeleteCount, removeMinIndex, } from "./Utils/Constants.js";
+import { itemFromSingleOrMultiple, safeDocument } from "../Utils/Utils.js";
 import { EventDispatcher } from "../Utils/EventDispatcher.js";
-import { EventType } from "../Enums/Types/EventType.js";
+import { PluginManager } from "./Utils/PluginManager.js";
 import { getLogger } from "../Utils/LogUtils.js";
 import { getRandom } from "../Utils/MathUtils.js";
 const fullPercent = "100%";
@@ -45,163 +45,41 @@ const getCanvasFromContainer = (domContainer) => {
     if (domContainer) {
         return domContainer;
     }
-    domContainer = documentSafe.createElement("div");
+    domContainer = documentSafe.createElement("canvas");
     domContainer.id = id;
     domContainer.dataset[generatedAttribute] = generatedTrue;
     documentSafe.body.append(domContainer);
     return domContainer;
 };
 export class Engine {
-    constructor() {
-        this._configs = new Map();
-        this._domArray = [];
-        this._eventDispatcher = new EventDispatcher();
-        this._initialized = false;
-        this._isRunningLoaders = false;
-        this._loadPromises = new Set();
-        this._allLoadersSet = new Set();
-        this._executedSet = new Set();
-        this.plugins = [];
-        this.colorManagers = new Map();
-        this.easingFunctions = new Map();
-        this._initializers = {
-            movers: new Map(),
-            updaters: new Map(),
-        };
-        this.movers = new Map();
-        this.updaters = new Map();
-        this.presets = new Map();
-        this.effectDrawers = new Map();
-        this.shapeDrawers = new Map();
-        this.pathGenerators = new Map();
-    }
-    get configs() {
-        const res = {};
-        for (const [name, config] of this._configs) {
-            res[name] = config;
-        }
-        return res;
-    }
+    pluginManager = new PluginManager(this);
+    _domArray = [];
+    _eventDispatcher = new EventDispatcher();
+    _initialized = false;
     get items() {
         return this._domArray;
     }
     get version() {
-        return "4.0.0-alpha.8";
-    }
-    addColorManager(manager) {
-        this.colorManagers.set(manager.key, manager);
-    }
-    addConfig(config) {
-        const key = config.key ?? config.name ?? "default";
-        this._configs.set(key, config);
-        this._eventDispatcher.dispatchEvent(EventType.configAdded, { data: { name: key, config } });
-    }
-    addEasing(name, easing) {
-        if (this.easingFunctions.get(name)) {
-            return;
-        }
-        this.easingFunctions.set(name, easing);
-    }
-    addEffect(effect, drawer) {
-        if (this.getEffectDrawer(effect)) {
-            return;
-        }
-        this.effectDrawers.set(effect, drawer);
+        return "4.0.0-beta.1";
     }
     addEventListener(type, listener) {
         this._eventDispatcher.addEventListener(type, listener);
     }
-    addMover(name, moverInitializer) {
-        this._initializers.movers.set(name, moverInitializer);
-    }
-    addParticleUpdater(name, updaterInitializer) {
-        this._initializers.updaters.set(name, updaterInitializer);
-    }
-    addPathGenerator(name, generator) {
-        if (this.getPathGenerator(name)) {
-            return;
-        }
-        this.pathGenerators.set(name, generator);
-    }
-    addPlugin(plugin) {
-        if (this.getPlugin(plugin.id)) {
-            return;
-        }
-        this.plugins.push(plugin);
-    }
-    addPreset(preset, options, override = false) {
-        if (!(override || !this.getPreset(preset))) {
-            return;
-        }
-        this.presets.set(preset, options);
-    }
-    addShape(drawer) {
-        for (const validType of drawer.validTypes) {
-            if (this.getShapeDrawer(validType)) {
-                continue;
-            }
-            this.shapeDrawers.set(validType, drawer);
-        }
-    }
     checkVersion(pluginVersion) {
         if (this.version === pluginVersion) {
             return;
         }
         throw new Error(`The tsParticles version is different from the loaded plugins version. Engine version: ${this.version}. Plugin version: ${pluginVersion}`);
     }
-    clearPlugins(container) {
-        this.updaters.delete(container);
-        this.movers.delete(container);
-    }
     dispatchEvent(type, args) {
         this._eventDispatcher.dispatchEvent(type, args);
     }
-    getEasing(name) {
-        return this.easingFunctions.get(name) ?? ((value) => value);
-    }
-    getEffectDrawer(type) {
-        return this.effectDrawers.get(type);
-    }
-    async 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.shapeDrawers.get(type);
-    }
-    getSupportedEffects() {
-        return this.effectDrawers.keys();
-    }
-    getSupportedShapes() {
-        return this.shapeDrawers.keys();
-    }
-    async getUpdaters(container, force = false) {
-        return getItemsFromInitializer(container, this.updaters, this._initializers.updaters, force);
-    }
     async init() {
-        if (this._initialized || this._isRunningLoaders)
+        if (this._initialized) {
             return;
-        this._isRunningLoaders = true;
-        this._executedSet = new Set();
-        this._allLoadersSet = new Set(this._loadPromises);
-        try {
-            for (const loader of this._allLoadersSet) {
-                await this._runLoader(loader, this._executedSet, this._allLoadersSet);
-            }
-        }
-        finally {
-            this._loadPromises.clear();
-            this._isRunningLoaders = false;
-            this._initialized = true;
         }
+        await this.pluginManager.init();
+        this._initialized = true;
     }
     item(index) {
         const { items } = this, item = items[index];
@@ -213,7 +91,23 @@ export class Engine {
     }
     async load(params) {
         await this.init();
-        const { Container } = await import("./Container.js"), id = params.id ?? params.element?.id ?? `tsparticles${Math.floor(getRandom() * loadRandomFactor).toString()}`, { index, url } = params, options = url ? await getDataFromUrl({ fallback: params.options, url, index }) : params.options, currentOptions = itemFromSingleOrMultiple(options, index), { items } = this, oldIndex = items.findIndex(v => v.id.description === id), newItem = new Container(this, id, currentOptions);
+        const { Container } = await import("./Container.js"), id = params.id ?? params.element?.id ?? `tsparticles${Math.floor(getRandom() * loadRandomFactor).toString()}`, { index, url } = params, options = url ? await getDataFromUrl({ fallback: params.options, url, index }) : params.options, currentOptions = itemFromSingleOrMultiple(options, index), { items } = this, oldIndex = items.findIndex(v => v.id.description === id), newItem = new Container({
+            dispatchCallback: (eventType, args) => {
+                this.dispatchEvent(eventType, args);
+            },
+            id,
+            onDestroy: (remove) => {
+                if (!remove) {
+                    return;
+                }
+                const mainArr = this.items, idx = mainArr.indexOf(newItem);
+                if (idx >= removeMinIndex) {
+                    mainArr.splice(idx, removeDeleteCount);
+                }
+            },
+            pluginManager: this.pluginManager,
+            sourceOptions: currentOptions,
+        });
         if (oldIndex >= loadMinIndex) {
             const old = this.item(oldIndex), deleteCount = old ? one : none;
             if (old && !old.destroyed) {
@@ -229,40 +123,13 @@ export class Engine {
         await newItem.start();
         return newItem;
     }
-    loadParticlesOptions(container, options, ...sourceOptions) {
-        const updaters = this.updaters.get(container);
-        if (!updaters) {
-            return;
-        }
-        updaters.forEach(updater => updater.loadOptions?.(options, ...sourceOptions));
-    }
     async refresh(refresh = true) {
         if (!refresh) {
             return;
         }
         await Promise.all(this.items.map(t => t.refresh()));
     }
-    async register(...loaders) {
-        if (this._initialized) {
-            throw new Error("Register plugins can only be done before calling tsParticles.load()");
-        }
-        for (const loader of loaders) {
-            if (this._isRunningLoaders) {
-                await this._runLoader(loader, this._executedSet, this._allLoadersSet);
-            }
-            else {
-                this._loadPromises.add(loader);
-            }
-        }
-    }
     removeEventListener(type, listener) {
         this._eventDispatcher.removeEventListener(type, listener);
     }
-    async _runLoader(loader, executed, allLoaders) {
-        if (executed.has(loader))
-            return;
-        executed.add(loader);
-        allLoaders.add(loader);
-        await loader(this);
-    }
 }