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

package/cjs/Utils/CanvasUtils.js

@@ -1,11 +1,4 @@
-import { lFactor, minStrokeWidth, originPoint } from "../Core/Utils/Constants.js";
-import { AlterType } from "../Enums/Types/AlterType.js";
-export function drawLine(context, begin, end) {
-    context.beginPath();
-    context.moveTo(begin.x, begin.y);
-    context.lineTo(end.x, end.y);
-    context.closePath();
-}
+import { defaultZoom, minStrokeWidth, originPoint } from "../Core/Utils/Constants.js";
 export function paintBase(context, dimension, baseColor) {
     context.fillStyle = baseColor ?? "rgba(0,0,0,0)";
     context.fillRect(originPoint.x, originPoint.y, dimension.width, dimension.height);
@@ -14,20 +7,24 @@ export function paintImage(context, dimension, image, opacity) {
     if (!image) {
         return;
     }
+    const prevAlpha = context.globalAlpha;
     context.globalAlpha = opacity;
     context.drawImage(image, originPoint.x, originPoint.y, dimension.width, dimension.height);
-    context.globalAlpha = 1;
+    context.globalAlpha = prevAlpha;
 }
 export function clear(context, dimension) {
     context.clearRect(originPoint.x, originPoint.y, dimension.width, dimension.height);
 }
 export function drawParticle(data) {
-    const { container, context, particle, delta, colorStyles, radius, opacity, transform } = data, pos = particle.getPosition(), transformData = particle.getTransformData(transform);
+    const { container, context, particle, delta, colorStyles, radius, opacity, transform } = data, { effectDrawers, shapeDrawers } = container, pos = particle.getPosition(), transformData = particle.getTransformData(transform), drawScale = defaultZoom, drawPosition = {
+        x: pos.x,
+        y: pos.y,
+    };
     context.setTransform(transformData.a, transformData.b, transformData.c, transformData.d, pos.x, pos.y);
     if (colorStyles.fill) {
         context.fillStyle = colorStyles.fill;
     }
-    const strokeWidth = particle.strokeWidth ?? minStrokeWidth;
+    const fillEnabled = !!particle.fillEnabled, strokeWidth = particle.strokeWidth ?? minStrokeWidth;
     context.lineWidth = strokeWidth;
     if (colorStyles.stroke) {
         context.strokeStyle = colorStyles.stroke;
@@ -36,49 +33,54 @@ export function drawParticle(data) {
         context,
         particle,
         radius,
+        drawRadius: radius * drawScale,
         opacity,
         delta,
         pixelRatio: container.retina.pixelRatio,
-        fill: particle.shapeFill,
-        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
+        fill: fillEnabled,
+        stroke: strokeWidth > minStrokeWidth,
         transformData,
+        position: { ...pos },
+        drawPosition,
+        drawScale,
     };
-    drawBeforeEffect(container, drawData);
-    drawShapeBeforeDraw(container, drawData);
-    drawShape(container, drawData);
-    drawShapeAfterDraw(container, drawData);
-    drawAfterEffect(container, drawData);
+    for (const plugin of container.plugins) {
+        plugin.drawParticleTransform?.(drawData);
+    }
+    const effect = particle.effect ? effectDrawers.get(particle.effect) : undefined, shape = particle.shape ? shapeDrawers.get(particle.shape) : undefined;
+    drawBeforeEffect(effect, drawData);
+    drawShapeBeforeDraw(shape, drawData);
+    drawShape(shape, drawData);
+    drawShapeAfterDraw(shape, drawData);
+    drawAfterEffect(effect, drawData);
     context.resetTransform();
 }
-export function drawAfterEffect(container, data) {
+export function drawAfterEffect(drawer, data) {
+    if (!drawer?.drawAfter) {
+        return;
+    }
     const { particle } = data;
     if (!particle.effect) {
         return;
     }
-    const drawer = container.effectDrawers.get(particle.effect), drawFunc = drawer?.drawAfter;
-    if (!drawFunc) {
+    drawer.drawAfter(data);
+}
+export function drawBeforeEffect(drawer, data) {
+    if (!drawer?.drawBefore) {
         return;
     }
-    drawFunc(data);
-}
-export function drawBeforeEffect(container, data) {
     const { particle } = data;
     if (!particle.effect) {
         return;
     }
-    const drawer = container.effectDrawers.get(particle.effect);
-    if (!drawer?.drawBefore) {
-        return;
-    }
     drawer.drawBefore(data);
 }
-export function drawShape(container, data) {
-    const { context, particle, stroke } = data;
-    if (!particle.shape) {
+export function drawShape(drawer, data) {
+    if (!drawer) {
         return;
     }
-    const drawer = container.shapeDrawers.get(particle.shape);
-    if (!drawer) {
+    const { context, fill, particle, stroke } = data;
+    if (!particle.shape) {
         return;
     }
     context.beginPath();
@@ -89,30 +91,28 @@ export function drawShape(container, data) {
     if (stroke) {
         context.stroke();
     }
-    if (particle.shapeFill) {
+    if (fill) {
         context.fill();
     }
 }
-export function drawShapeAfterDraw(container, data) {
-    const { particle } = data;
-    if (!particle.shape) {
-        return;
-    }
-    const drawer = container.shapeDrawers.get(particle.shape);
+export function drawShapeAfterDraw(drawer, data) {
     if (!drawer?.afterDraw) {
         return;
     }
-    drawer.afterDraw(data);
-}
-export function drawShapeBeforeDraw(container, data) {
     const { particle } = data;
     if (!particle.shape) {
         return;
     }
-    const drawer = container.shapeDrawers.get(particle.shape);
+    drawer.afterDraw(data);
+}
+export function drawShapeBeforeDraw(drawer, data) {
     if (!drawer?.beforeDraw) {
         return;
     }
+    const { particle } = data;
+    if (!particle.shape) {
+        return;
+    }
     drawer.beforeDraw(data);
 }
 export function drawParticlePlugin(context, plugin, particle, delta) {
@@ -121,10 +121,3 @@ export function drawParticlePlugin(context, plugin, particle, delta) {
     }
     plugin.drawParticle(context, particle, delta);
 }
-export function alterHsl(color, type, value) {
-    return {
-        h: color.h,
-        s: color.s,
-        l: color.l + (type === AlterType.darken ? -lFactor : lFactor) * value,
-    };
-}

package/cjs/Utils/ColorUtils.js

@@ -1,6 +1,7 @@
-import { clamp, getRandom, getRandomInRange, getRangeMax, getRangeMin, getRangeValue, mix, randomInRangeValue, setRangeValue, } from "./MathUtils.js";
-import { decayOffset, defaultLoops, defaultOpacity, defaultRgbMin, defaultTime, defaultVelocity, double, hMax, hMin, hPhase, half, identity, lMax, lMin, midColorValue, millisecondsToSeconds, percentDenominator, phaseNumerator, randomColorValue, rgbMax, sMax, sMin, sNormalizedOffset, sextuple, triple, } from "../Core/Utils/Constants.js";
+import { clamp, getRandom, getRandomInRange, getRangeValue, mix, randomInRangeValue, setRangeValue, } from "./MathUtils.js";
+import { decayOffset, defaultLoops, defaultOpacity, defaultRgbMin, defaultTime, defaultVelocity, double, hMax, hMin, hPhase, half, identity, lFactor, lMax, lMin, midColorValue, millisecondsToSeconds, percentDenominator, phaseNumerator, randomColorValue, rgbMax, sMax, sMin, sNormalizedOffset, sextuple, triple, } from "../Core/Utils/Constants.js";
 import { isArray, isString } from "./TypeUtils.js";
+import { AlterType } from "../Enums/Types/AlterType.js";
 import { AnimationStatus } from "../Enums/AnimationStatus.js";
 import { itemFromArray } from "./Utils.js";
 const styleCache = new Map(), maxCacheSize = 1000, firstIndex = 0, rgbFixedPrecision = 2, hslFixedPrecision = 2;
@@ -16,35 +17,35 @@ function getCachedStyle(key, generator) {
     }
     return cached;
 }
-function stringToRgba(engine, input) {
+function stringToRgba(pluginManager, input) {
     if (!input) {
         return;
     }
-    for (const manager of engine.colorManagers.values()) {
+    for (const manager of pluginManager.colorManagers.values()) {
         if (manager.accepts(input)) {
             return manager.parseString(input);
         }
     }
     return undefined;
 }
-export function rangeColorToRgb(engine, input, index, useIndex = true) {
+export function rangeColorToRgb(pluginManager, input, index, useIndex = true) {
     if (!input) {
         return;
     }
     const color = isString(input) ? { value: input } : input;
     if (isString(color.value)) {
-        return colorToRgb(engine, color.value, index, useIndex);
+        return colorToRgb(pluginManager, color.value, index, useIndex);
     }
     if (isArray(color.value)) {
         const value = itemFromArray(color.value, index, useIndex);
         if (!value) {
             return;
         }
-        return rangeColorToRgb(engine, {
+        return rangeColorToRgb(pluginManager, {
             value,
         });
     }
-    for (const manager of engine.colorManagers.values()) {
+    for (const manager of pluginManager.colorManagers.values()) {
         const res = manager.handleRangeColor(color);
         if (res) {
             return res;
@@ -52,24 +53,24 @@ export function rangeColorToRgb(engine, input, index, useIndex = true) {
     }
     return undefined;
 }
-export function colorToRgb(engine, input, index, useIndex = true) {
+export function colorToRgb(pluginManager, input, index, useIndex = true) {
     if (!input) {
         return;
     }
     const color = isString(input) ? { value: input } : input;
     if (isString(color.value)) {
-        return color.value === randomColorValue ? getRandomRgbColor() : stringToRgb(engine, color.value);
+        return color.value === randomColorValue ? getRandomRgbColor() : stringToRgb(pluginManager, color.value);
     }
     if (isArray(color.value)) {
         const value = itemFromArray(color.value, index, useIndex);
         if (!value) {
             return;
         }
-        return colorToRgb(engine, {
+        return colorToRgb(pluginManager, {
             value,
         });
     }
-    for (const manager of engine.colorManagers.values()) {
+    for (const manager of pluginManager.colorManagers.values()) {
         const res = manager.handleColor(color);
         if (res) {
             return res;
@@ -77,12 +78,12 @@ export function colorToRgb(engine, input, index, useIndex = true) {
     }
     return undefined;
 }
-export function colorToHsl(engine, color, index, useIndex = true) {
-    const rgb = colorToRgb(engine, color, index, useIndex);
+export function colorToHsl(pluginManager, color, index, useIndex = true) {
+    const rgb = colorToRgb(pluginManager, color, index, useIndex);
     return rgb ? rgbToHsl(rgb) : undefined;
 }
-export function rangeColorToHsl(engine, color, index, useIndex = true) {
-    const rgb = rangeColorToRgb(engine, color, index, useIndex);
+export function rangeColorToHsl(pluginManager, color, index, useIndex = true) {
+    const rgb = rangeColorToRgb(pluginManager, color, index, useIndex);
     return rgb ? rgbToHsl(rgb) : undefined;
 }
 export function rgbToHsl(color) {
@@ -114,11 +115,11 @@ export function rgbToHsl(color) {
     }
     return res;
 }
-export function stringToAlpha(engine, input) {
-    return stringToRgba(engine, input)?.a;
+export function stringToAlpha(pluginManager, input) {
+    return stringToRgba(pluginManager, input)?.a;
 }
-export function stringToRgb(engine, input) {
-    return stringToRgba(engine, input);
+export function stringToRgb(pluginManager, input) {
+    return stringToRgba(pluginManager, input);
 }
 export function hslToRgb(hsl) {
     const h = ((hsl.h % hMax) + hMax) % hMax, s = Math.max(sMin, Math.min(sMax, hsl.s)), l = Math.max(lMin, Math.min(lMax, hsl.l)), hNormalized = h / hMax, sNormalized = s / sMax, lNormalized = l / lMax;
@@ -189,10 +190,10 @@ function getSdrStyleFromHsl(color, opacity) {
 }
 export function colorMix(color1, color2, size1, size2) {
     let rgb1 = color1, rgb2 = color2;
-    if (!Object.hasOwn(rgb1, "r")) {
+    if (!("r" in rgb1)) {
         rgb1 = hslToRgb(color1);
     }
-    if (!Object.hasOwn(rgb2, "r")) {
+    if (!("r" in rgb2)) {
         rgb2 = hslToRgb(color2);
     }
     return {
@@ -222,11 +223,11 @@ export function getLinkColor(p1, p2, linkColor) {
     }
     return undefined;
 }
-export function getLinkRandomColor(engine, optColor, blink, consent) {
+export function getLinkRandomColor(pluginManager, optColor, blink, consent) {
     const color = isString(optColor) ? optColor : optColor.value;
     if (color === randomColorValue) {
         if (consent) {
-            return rangeColorToRgb(engine, {
+            return rangeColorToRgb(pluginManager, {
                 value: color,
             });
         }
@@ -239,33 +240,39 @@ export function getLinkRandomColor(engine, optColor, blink, consent) {
         return midColorValue;
     }
     else {
-        return rangeColorToRgb(engine, {
+        return rangeColorToRgb(pluginManager, {
             value: color,
         });
     }
 }
 export function getHslFromAnimation(animation) {
-    return animation !== undefined
-        ? {
+    return animation === undefined
+        ? undefined
+        : {
             h: animation.h.value,
             s: animation.s.value,
             l: animation.l.value,
-        }
-        : undefined;
+        };
 }
 export function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
     const resColor = {
         h: {
             enable: false,
             value: hsl.h,
+            min: hMin,
+            max: hMax,
         },
         s: {
             enable: false,
             value: hsl.s,
+            min: sMin,
+            max: sMax,
         },
         l: {
             enable: false,
             value: hsl.l,
+            min: lMin,
+            max: lMax,
         },
     };
     if (animationOptions) {
@@ -277,6 +284,8 @@ export function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
 }
 function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
     colorValue.enable = colorAnimation.enable;
+    colorValue.min = colorAnimation.min;
+    colorValue.max = colorAnimation.max;
     if (colorValue.enable) {
         colorValue.velocity = (getRangeValue(colorAnimation.speed) / percentDenominator) * reduceFactor;
         colorValue.decay = decayOffset - getRangeValue(colorAnimation.decay);
@@ -296,7 +305,7 @@ function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
         colorValue.velocity = defaultVelocity;
     }
 }
-export function updateColorValue(data, range, decrease, delta) {
+export function updateColorValue(data, decrease, delta) {
     const minLoops = 0, minDelay = 0, identity = 1, minVelocity = 0, minOffset = 0, velocityFactor = 3.6;
     if (!data.enable ||
         ((data.maxLoops ?? minLoops) > minLoops && (data.loops ?? minLoops) > (data.maxLoops ?? minLoops))) {
@@ -309,7 +318,7 @@ export function updateColorValue(data, range, decrease, delta) {
     if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
         return;
     }
-    const offset = data.offset ? randomInRangeValue(data.offset) : minOffset, velocity = (data.velocity ?? minVelocity) * delta.factor + offset * velocityFactor, decay = data.decay ?? identity, max = getRangeMax(range), min = getRangeMin(range);
+    const offset = data.offset ? randomInRangeValue(data.offset) : minOffset, velocity = (data.velocity ?? minVelocity) * delta.factor + offset * velocityFactor, decay = data.decay ?? identity, max = data.max, min = data.min;
     if (!decrease || data.status === AnimationStatus.increasing) {
         data.value += velocity;
         if (data.value > max) {
@@ -325,8 +334,7 @@ export function updateColorValue(data, range, decrease, delta) {
     }
     else {
         data.value -= velocity;
-        const minValue = 0;
-        if (data.value < minValue) {
+        if (data.value < min) {
             data.loops ??= 0;
             data.loops++;
             data.status = AnimationStatus.increasing;
@@ -341,12 +349,15 @@ export function updateColor(color, delta) {
     if (!color) {
         return;
     }
-    const { h, s, l } = color, ranges = {
-        h: { min: hMin, max: hMax },
-        s: { min: sMin, max: sMax },
-        l: { min: lMin, max: lMax },
+    const { h, s, l } = color;
+    updateColorValue(h, false, delta);
+    updateColorValue(s, true, delta);
+    updateColorValue(l, true, delta);
+}
+export function alterHsl(color, type, value) {
+    return {
+        h: color.h,
+        s: color.s,
+        l: color.l + (type === AlterType.darken ? -lFactor : lFactor) * value,
     };
-    updateColorValue(h, ranges.h, false, delta);
-    updateColorValue(s, ranges.s, true, delta);
-    updateColorValue(l, ranges.l, true, delta);
 }

package/cjs/Utils/EventDispatcher.js

@@ -1,5 +1,6 @@
 import { deleteCount, minIndex } from "../Core/Utils/Constants.js";
 export class EventDispatcher {
+    _listeners;
     constructor() {
         this._listeners = new Map();
     }

package/cjs/Utils/LogUtils.js

@@ -6,6 +6,7 @@ const _logger = {
     },
     info: console.info,
     log: console.log,
+    trace: console.trace,
     verbose: console.log,
     warning: console.warn,
 };

package/cjs/Utils/MathUtils.js

@@ -21,10 +21,8 @@ export function getRandomInRange(min, max) {
     return getRandom() * (max - min) + min;
 }
 export function setAnimationFunctions(nextFrame, cancel) {
-    _animationLoop.nextFrame = (callback) => nextFrame(callback);
-    _animationLoop.cancel = (handle) => {
-        cancel(handle);
-    };
+    _animationLoop.nextFrame = nextFrame;
+    _animationLoop.cancel = cancel;
 }
 export function animate(fn) {
     return _animationLoop.nextFrame(fn);
@@ -68,11 +66,18 @@ export function setRangeValue(source, value) {
         : setRangeValue(min, max);
 }
 export function getDistances(pointA, pointB) {
-    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y, squareExp = 2;
-    return { dx: dx, dy: dy, distance: Math.sqrt(dx ** squareExp + dy ** squareExp) };
+    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
+    return { dx: dx, dy: dy, distance: Math.hypot(dx, dy) };
+}
+export function getDistanceSq(pointA, pointB) {
+    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
+    return dx * dx + dy * dy;
 }
 export function getDistance(pointA, pointB) {
-    return getDistances(pointA, pointB).distance;
+    return Math.sqrt(getDistanceSq(pointA, pointB));
+}
+export function checkDistance(pointA, pointB, distance) {
+    return getDistanceSq(pointA, pointB) <= distance * distance;
 }
 export function degToRad(degrees) {
     return degrees * degToRadFactor;

package/cjs/Utils/OptionsUtils.js

@@ -4,8 +4,8 @@ export function loadOptions(options, ...sourceOptionsArr) {
         options.load(sourceOptions);
     }
 }
-export function loadParticlesOptions(engine, container, ...sourceOptionsArr) {
-    const options = new ParticlesOptions(engine, container);
+export function loadParticlesOptions(pluginManager, container, ...sourceOptionsArr) {
+    const options = new ParticlesOptions(pluginManager, container);
     loadOptions(options, ...sourceOptionsArr);
     return options;
 }