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

package/esm/Core/Particle.js

@@ -1,26 +1,23 @@
 import { Vector, Vector3d } from "./Utils/Vectors.js";
+import { alterHsl, getHslFromAnimation } from "../Utils/ColorUtils.js";
 import { calcExactPositionOrRandomFromSize, clamp, degToRad, getParticleBaseVelocity, getParticleDirectionAngle, getRandom, getRangeValue, randomInRangeValue, setRangeValue, } from "../Utils/MathUtils.js";
-import { decayOffset, defaultAngle, defaultOpacity, defaultRetryCount, defaultTransform, double, doublePI, half, identity, millisecondsToSeconds, minZ, randomColorValue, squareExp, triple, tryCountIncrement, zIndexFactorOffset, } from "./Utils/Constants.js";
 import { deepExtend, getPosition, initParticleNumericAnimationValue, isInArray, itemFromSingleOrMultiple, } from "../Utils/Utils.js";
+import { defaultAngle, defaultOpacity, defaultRetryCount, defaultTransform, double, doublePI, half, identity, minZ, randomColorValue, squareExp, triple, tryCountIncrement, zIndexFactorOffset, } from "./Utils/Constants.js";
 import { EventType } from "../Enums/Types/EventType.js";
 import { MoveDirection } from "../Enums/Directions/MoveDirection.js";
 import { OutMode } from "../Enums/Modes/OutMode.js";
 import { ParticleOutType } from "../Enums/Types/ParticleOutType.js";
-import { alterHsl } from "../Utils/CanvasUtils.js";
-import { getHslFromAnimation } from "../Utils/ColorUtils.js";
 import { loadParticlesOptions } from "../Utils/OptionsUtils.js";
 function loadEffectData(effect, effectOptions, id, reduceDuplicates) {
     const effectData = effectOptions.options[effect];
     return deepExtend({
         close: effectOptions.close,
-        fill: effectOptions.fill,
     }, itemFromSingleOrMultiple(effectData, id, reduceDuplicates));
 }
 function loadShapeData(shape, shapeOptions, id, reduceDuplicates) {
     const shapeData = shapeOptions.options[shape];
     return deepExtend({
         close: shapeOptions.close,
-        fill: shapeOptions.fill,
     }, itemFromSingleOrMultiple(shapeData, id, reduceDuplicates));
 }
 function fixOutMode(data) {
@@ -36,131 +33,66 @@ function fixOutMode(data) {
     }
 }
 export class Particle {
-    constructor(engine, container) {
-        this.container = container;
-        this._cachedOpacityData = {
-            opacity: defaultOpacity,
-            strokeOpacity: defaultOpacity,
-        };
-        this._cachedPosition = Vector3d.origin;
-        this._cachedRotateData = { sin: 0, cos: 0 };
-        this._cachedTransform = {
-            a: 1,
-            b: 0,
-            c: 0,
-            d: 1,
-        };
-        this._calcPosition = (position, zIndex) => {
-            let tryCount = defaultRetryCount, posVec = position ? Vector3d.create(position.x, position.y, zIndex) : undefined;
-            const container = this.container, plugins = Array.from(container.plugins), outModes = this.options.move.outModes, radius = this.getRadius(), canvasSize = container.canvas.size, abortController = new AbortController(), { signal } = abortController;
-            while (!signal.aborted) {
-                for (const plugin of plugins) {
-                    const pluginPos = plugin.particlePosition?.(posVec, this);
-                    if (pluginPos) {
-                        return Vector3d.create(pluginPos.x, pluginPos.y, zIndex);
-                    }
-                }
-                const exactPosition = calcExactPositionOrRandomFromSize({
-                    size: canvasSize,
-                    position: posVec,
-                }), pos = Vector3d.create(exactPosition.x, exactPosition.y, zIndex);
-                this._fixHorizontal(pos, radius, outModes.left ?? outModes.default);
-                this._fixHorizontal(pos, radius, outModes.right ?? outModes.default);
-                this._fixVertical(pos, radius, outModes.top ?? outModes.default);
-                this._fixVertical(pos, radius, outModes.bottom ?? outModes.default);
-                let isValidPosition = true;
-                for (const plugin of plugins) {
-                    isValidPosition = plugin.checkParticlePosition?.(this, pos, tryCount) ?? true;
-                    if (!isValidPosition) {
-                        break;
-                    }
-                }
-                if (isValidPosition) {
-                    return pos;
-                }
-                tryCount += tryCountIncrement;
-                posVec = undefined;
-            }
-            return posVec;
-        };
-        this._calculateVelocity = () => {
-            const baseVelocity = getParticleBaseVelocity(this.direction), res = baseVelocity.copy(), moveOptions = this.options.move;
-            if (moveOptions.direction === MoveDirection.inside || moveOptions.direction === MoveDirection.outside) {
-                return res;
-            }
-            const rad = degToRad(getRangeValue(moveOptions.angle.value)), radOffset = degToRad(getRangeValue(moveOptions.angle.offset)), range = {
-                left: radOffset - rad * half,
-                right: radOffset + rad * half,
-            };
-            if (!moveOptions.straight) {
-                res.angle += randomInRangeValue(setRangeValue(range.left, range.right));
-            }
-            if (moveOptions.random && typeof moveOptions.speed === "number") {
-                res.length *= getRandom();
-            }
-            return res;
-        };
-        this._fixHorizontal = (pos, radius, outMode) => {
-            fixOutMode({
-                outMode,
-                checkModes: [OutMode.bounce],
-                coord: pos.x,
-                maxCoord: this.container.canvas.size.width,
-                setCb: (value) => (pos.x += value),
-                radius,
-            });
-        };
-        this._fixVertical = (pos, radius, outMode) => {
-            fixOutMode({
-                outMode,
-                checkModes: [OutMode.bounce],
-                coord: pos.y,
-                maxCoord: this.container.canvas.size.height,
-                setCb: (value) => (pos.y += value),
-                radius,
-            });
-        };
-        this._getRollColor = color => {
-            if (!color || !this.roll || (!this.backColor && !this.roll.alter)) {
-                return color;
-            }
-            if (!this.isShowingBack()) {
-                return color;
-            }
-            if (this.backColor) {
-                return this.backColor;
-            }
-            if (this.roll.alter) {
-                return alterHsl(color, this.roll.alter.type, this.roll.alter.value);
-            }
-            return color;
-        };
-        this._initPosition = position => {
-            const container = this.container, zIndexValue = getRangeValue(this.options.zIndex.value);
-            const initialPosition = this._calcPosition(position, clamp(zIndexValue, minZ, container.zLayers));
-            if (!initialPosition) {
-                throw new Error("a valid position cannot be found for particle");
-            }
-            this.position = initialPosition;
-            this.initialPosition = this.position.copy();
-            const canvasSize = container.canvas.size;
-            this.moveCenter = {
-                ...getPosition(this.options.move.center, canvasSize),
-                radius: this.options.move.center.radius,
-                mode: this.options.move.center.mode,
-            };
-            this.direction = getParticleDirectionAngle(this.options.move.direction, this.position, this.moveCenter);
-            switch (this.options.move.direction) {
-                case MoveDirection.inside:
-                    this.outType = ParticleOutType.inside;
-                    break;
-                case MoveDirection.outside:
-                    this.outType = ParticleOutType.outside;
-                    break;
-            }
-            this.offset = Vector.origin;
-        };
-        this._engine = engine;
+    backColor;
+    bubble;
+    destroyed;
+    direction;
+    effect;
+    effectClose;
+    effectData;
+    fillColor;
+    fillEnabled;
+    fillOpacity;
+    group;
+    id;
+    ignoresResizeRatio;
+    initialPosition;
+    initialVelocity;
+    isRotating;
+    lastPathTime;
+    misplaced;
+    moveCenter;
+    offset;
+    opacity;
+    options;
+    outType;
+    pathRotation;
+    position;
+    randomIndexData;
+    retina;
+    roll;
+    rotation;
+    shape;
+    shapeClose;
+    shapeData;
+    sides;
+    size;
+    slow;
+    spawning;
+    strokeColor;
+    strokeOpacity;
+    strokeWidth;
+    unbreakable;
+    velocity;
+    zIndexFactor;
+    _cachedOpacityData = {
+        fillOpacity: defaultOpacity,
+        opacity: defaultOpacity,
+        strokeOpacity: defaultOpacity,
+    };
+    _cachedPosition = Vector3d.origin;
+    _cachedRotateData = { sin: 0, cos: 0 };
+    _cachedTransform = {
+        a: 1,
+        b: 0,
+        c: 0,
+        d: 1,
+    };
+    _container;
+    _pluginManager;
+    constructor(pluginManager, container) {
+        this._pluginManager = pluginManager;
+        this._container = container;
     }
     destroy(override) {
         if (this.unbreakable || this.destroyed) {
@@ -169,42 +101,37 @@ export class Particle {
         this.destroyed = true;
         this.bubble.inRange = false;
         this.slow.inRange = false;
-        const container = this.container, pathGenerator = this.pathGenerator, shapeDrawer = this.shape ? container.shapeDrawers.get(this.shape) : undefined;
+        const container = this._container, shapeDrawer = this.shape ? container.shapeDrawers.get(this.shape) : undefined;
         shapeDrawer?.particleDestroy?.(this);
-        for (const plugin of container.plugins) {
+        for (const plugin of container.particleDestroyedPlugins) {
             plugin.particleDestroyed?.(this, override);
         }
-        for (const updater of container.particles.updaters) {
+        for (const updater of container.particleUpdaters) {
             updater.particleDestroyed?.(this, override);
         }
-        pathGenerator?.reset(this);
-        this._engine.dispatchEvent(EventType.particleDestroyed, {
-            container: this.container,
-            data: {
-                particle: this,
-            },
+        this._container.dispatchEvent(EventType.particleDestroyed, {
+            particle: this,
         });
     }
     draw(delta) {
-        const container = this.container, canvas = container.canvas;
-        for (const plugin of container.plugins) {
-            canvas.drawParticlePlugin(plugin, this, delta);
-        }
-        canvas.drawParticle(this, delta);
+        const container = this._container, render = container.canvas.render;
+        render.drawParticlePlugins(this, delta);
+        render.drawParticle(this, delta);
     }
     getAngle() {
         return this.rotation + (this.pathRotation ? this.velocity.angle : defaultAngle);
     }
     getFillColor() {
-        return this._getRollColor(this.bubble.color ?? getHslFromAnimation(this.color));
+        return this._getRollColor(this.bubble.color ?? getHslFromAnimation(this.fillColor));
     }
     getMass() {
         return this.getRadius() ** squareExp * Math.PI * half;
     }
     getOpacity() {
-        const zIndexOptions = this.options.zIndex, zIndexFactor = zIndexFactorOffset - this.zIndexFactor, zOpacityFactor = zIndexFactor ** zIndexOptions.opacityRate, opacity = this.bubble.opacity ?? getRangeValue(this.opacity?.value ?? defaultOpacity), strokeOpacity = this.strokeOpacity ?? opacity;
+        const zIndexOptions = this.options.zIndex, zIndexFactor = zIndexFactorOffset - this.zIndexFactor, zOpacityFactor = zIndexFactor ** zIndexOptions.opacityRate, opacity = this.bubble.opacity ?? getRangeValue(this.opacity?.value ?? defaultOpacity), fillOpacity = this.fillOpacity ?? defaultOpacity, strokeOpacity = this.strokeOpacity ?? defaultOpacity;
+        this._cachedOpacityData.fillOpacity = opacity * fillOpacity * zOpacityFactor;
         this._cachedOpacityData.opacity = opacity * zOpacityFactor;
-        this._cachedOpacityData.strokeOpacity = strokeOpacity * zOpacityFactor;
+        this._cachedOpacityData.strokeOpacity = opacity * strokeOpacity * zOpacityFactor;
         return this._cachedOpacityData;
     }
     getPosition() {
@@ -238,13 +165,11 @@ export class Particle {
         return this._cachedTransform;
     }
     init(id, position, overrideOptions, group) {
-        const container = this.container;
+        const container = this._container;
         this.id = id;
         this.group = group;
         this.effectClose = true;
-        this.effectFill = true;
         this.shapeClose = true;
-        this.shapeFill = true;
         this.pathRotation = false;
         this.lastPathTime = 0;
         this.destroyed = false;
@@ -254,10 +179,14 @@ export class Particle {
         this.misplaced = false;
         this.retina = {
             maxDistance: {},
+            maxSpeed: 0,
+            moveDrift: 0,
+            moveSpeed: 0,
+            sizeAnimationSpeed: 0,
         };
         this.outType = ParticleOutType.normal;
         this.ignoresResizeRatio = true;
-        const pxRatio = container.retina.pixelRatio, mainOptions = container.actualOptions, particlesOptions = loadParticlesOptions(this._engine, container, mainOptions.particles), reduceDuplicates = particlesOptions.reduceDuplicates, effectType = particlesOptions.effect.type, shapeType = particlesOptions.shape.type;
+        const pxRatio = container.retina.pixelRatio, mainOptions = container.actualOptions, particlesOptions = loadParticlesOptions(this._pluginManager, container, mainOptions.particles), reduceDuplicates = particlesOptions.reduceDuplicates, effectType = particlesOptions.effect.type, shapeType = particlesOptions.shape.type;
         this.effect = itemFromSingleOrMultiple(effectType, this.id, reduceDuplicates);
         this.shape = itemFromSingleOrMultiple(shapeType, this.id, reduceDuplicates);
         const effectOptions = particlesOptions.effect, shapeOptions = particlesOptions.shape;
@@ -278,11 +207,11 @@ export class Particle {
             }
         }
         if (this.effect === randomColorValue) {
-            const availableEffects = [...this.container.effectDrawers.keys()];
+            const availableEffects = [...this._container.effectDrawers.keys()];
             this.effect = availableEffects[Math.floor(getRandom() * availableEffects.length)];
         }
         if (this.shape === randomColorValue) {
-            const availableShapes = [...this.container.shapeDrawers.keys()];
+            const availableShapes = [...this._container.shapeDrawers.keys()];
             this.shape = availableShapes[Math.floor(getRandom() * availableShapes.length)];
         }
         this.effectData = this.effect ? loadEffectData(this.effect, effectOptions, this.id, reduceDuplicates) : undefined;
@@ -296,19 +225,9 @@ export class Particle {
         if (shapeData) {
             particlesOptions.load(shapeData.particles);
         }
-        this.effectFill = effectData?.fill ?? particlesOptions.effect.fill;
         this.effectClose = effectData?.close ?? particlesOptions.effect.close;
-        this.shapeFill = shapeData?.fill ?? particlesOptions.shape.fill;
         this.shapeClose = shapeData?.close ?? particlesOptions.shape.close;
         this.options = particlesOptions;
-        const pathOptions = this.options.move.path;
-        this.pathDelay = getRangeValue(pathOptions.delay.value) * millisecondsToSeconds;
-        if (pathOptions.generator) {
-            this.pathGenerator = this._engine.getPathGenerator(pathOptions.generator);
-            if (this.pathGenerator && container.addPath(pathOptions.generator, this.pathGenerator)) {
-                this.pathGenerator.init(container);
-            }
-        }
         container.retina.initParticle(this);
         this.size = initParticleNumericAnimationValue(this.options.size, pxRatio);
         this.bubble = {
@@ -321,7 +240,6 @@ export class Particle {
         this._initPosition(position);
         this.initialVelocity = this._calculateVelocity();
         this.velocity = this.initialVelocity.copy();
-        this.moveDecay = decayOffset - getRangeValue(this.options.move.decay);
         const particles = container.particles;
         particles.setLastZIndex(this.position.z);
         this.zIndexFactor = this.position.z / container.zLayers;
@@ -329,24 +247,12 @@ export class Particle {
         let effectDrawer, shapeDrawer;
         if (this.effect) {
             effectDrawer = container.effectDrawers.get(this.effect);
-            if (!effectDrawer) {
-                effectDrawer = this._engine.getEffectDrawer(this.effect);
-                if (effectDrawer) {
-                    container.effectDrawers.set(this.effect, effectDrawer);
-                }
-            }
         }
         if (effectDrawer?.loadEffect) {
             effectDrawer.loadEffect(this);
         }
         if (this.shape) {
             shapeDrawer = container.shapeDrawers.get(this.shape);
-            if (!shapeDrawer) {
-                shapeDrawer = this._engine.getShapeDrawer(this.shape);
-                if (shapeDrawer) {
-                    container.shapeDrawers.set(this.shape, shapeDrawer);
-                }
-            }
         }
         if (shapeDrawer?.loadShape) {
             shapeDrawer.loadShape(this);
@@ -356,20 +262,17 @@ export class Particle {
             this.sides = sideCountFunc(this);
         }
         this.spawning = false;
-        for (const updater of particles.updaters) {
+        for (const updater of container.particleUpdaters) {
             updater.init(this);
         }
-        for (const mover of particles.movers) {
-            mover.init(this);
-        }
         effectDrawer?.particleInit?.(container, this);
         shapeDrawer?.particleInit?.(container, this);
-        for (const plugin of container.plugins) {
+        for (const plugin of container.particleCreatedPlugins) {
             plugin.particleCreated?.(this);
         }
     }
     isInsideCanvas() {
-        const radius = this.getRadius(), canvasSize = this.container.canvas.size, position = this.position;
+        const radius = this.getRadius(), canvasSize = this._container.canvas.size, position = this.position;
         return (position.x >= -radius &&
             position.y >= -radius &&
             position.y <= canvasSize.height + radius &&
@@ -398,8 +301,119 @@ export class Particle {
         return !this.destroyed && !this.spawning && this.isInsideCanvas();
     }
     reset() {
-        for (const updater of this.container.particles.updaters) {
+        for (const updater of this._container.particleUpdaters) {
             updater.reset?.(this);
         }
     }
+    _calcPosition = (position, zIndex) => {
+        let tryCount = defaultRetryCount, posVec = position ? Vector3d.create(position.x, position.y, zIndex) : undefined;
+        const container = this._container, plugins = container.particlePositionPlugins, outModes = this.options.move.outModes, radius = this.getRadius(), canvasSize = container.canvas.size, abortController = new AbortController(), { signal } = abortController;
+        while (!signal.aborted) {
+            for (const plugin of plugins) {
+                const pluginPos = plugin.particlePosition?.(posVec, this);
+                if (pluginPos) {
+                    return Vector3d.create(pluginPos.x, pluginPos.y, zIndex);
+                }
+            }
+            const exactPosition = calcExactPositionOrRandomFromSize({
+                size: canvasSize,
+                position: posVec,
+            }), pos = Vector3d.create(exactPosition.x, exactPosition.y, zIndex);
+            this._fixHorizontal(pos, radius, outModes.left ?? outModes.default);
+            this._fixHorizontal(pos, radius, outModes.right ?? outModes.default);
+            this._fixVertical(pos, radius, outModes.top ?? outModes.default);
+            this._fixVertical(pos, radius, outModes.bottom ?? outModes.default);
+            let isValidPosition = true;
+            for (const plugin of container.particles.checkParticlePositionPlugins) {
+                isValidPosition = plugin.checkParticlePosition?.(this, pos, tryCount) ?? true;
+                if (!isValidPosition) {
+                    break;
+                }
+            }
+            if (isValidPosition) {
+                return pos;
+            }
+            tryCount += tryCountIncrement;
+            posVec = undefined;
+        }
+        return posVec;
+    };
+    _calculateVelocity = () => {
+        const baseVelocity = getParticleBaseVelocity(this.direction), res = baseVelocity.copy(), moveOptions = this.options.move;
+        if (moveOptions.direction === MoveDirection.inside || moveOptions.direction === MoveDirection.outside) {
+            return res;
+        }
+        const rad = degToRad(getRangeValue(moveOptions.angle.value)), radOffset = degToRad(getRangeValue(moveOptions.angle.offset)), range = {
+            left: radOffset - rad * half,
+            right: radOffset + rad * half,
+        };
+        if (!moveOptions.straight) {
+            res.angle += randomInRangeValue(setRangeValue(range.left, range.right));
+        }
+        if (moveOptions.random && typeof moveOptions.speed === "number") {
+            res.length *= getRandom();
+        }
+        return res;
+    };
+    _fixHorizontal = (pos, radius, outMode) => {
+        fixOutMode({
+            outMode,
+            checkModes: [OutMode.bounce],
+            coord: pos.x,
+            maxCoord: this._container.canvas.size.width,
+            setCb: (value) => (pos.x += value),
+            radius,
+        });
+    };
+    _fixVertical = (pos, radius, outMode) => {
+        fixOutMode({
+            outMode,
+            checkModes: [OutMode.bounce],
+            coord: pos.y,
+            maxCoord: this._container.canvas.size.height,
+            setCb: (value) => (pos.y += value),
+            radius,
+        });
+    };
+    _getRollColor = color => {
+        if (!color || !this.roll || (!this.backColor && !this.roll.alter)) {
+            return color;
+        }
+        if (!this.isShowingBack()) {
+            return color;
+        }
+        if (this.backColor) {
+            return this.backColor;
+        }
+        if (this.roll.alter) {
+            return alterHsl(color, this.roll.alter.type, this.roll.alter.value);
+        }
+        return color;
+    };
+    _initPosition = position => {
+        const container = this._container, zIndexValue = getRangeValue(this.options.zIndex.value), initialPosition = this._calcPosition(position, clamp(zIndexValue, minZ, container.zLayers));
+        if (!initialPosition) {
+            throw new Error("a valid position cannot be found for particle");
+        }
+        this.position = initialPosition;
+        this.initialPosition = this.position.copy();
+        const canvasSize = container.canvas.size;
+        this.moveCenter = {
+            ...getPosition(this.options.move.center, canvasSize),
+            radius: this.options.move.center.radius,
+            mode: this.options.move.center.mode,
+        };
+        this.direction = getParticleDirectionAngle(this.options.move.direction, this.position, this.moveCenter);
+        switch (this.options.move.direction) {
+            case MoveDirection.inside:
+                this.outType = ParticleOutType.inside;
+                break;
+            case MoveDirection.outside:
+                this.outType = ParticleOutType.outside;
+                break;
+            default:
+                break;
+        }
+        this.offset = Vector.origin;
+    };
 }