@tsparticles/plugin-polygon-mask 3.0.3 → 3.2.0

package/umd/PolygonMaskPlugin.js

@@ -0,0 +1,63 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+(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", "./Options/Classes/PolygonMask.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonMaskPlugin = void 0;
+    const PolygonMask_js_1 = require("./Options/Classes/PolygonMask.js");
+    class PolygonMaskPlugin {
+        constructor(engine) {
+            this.id = "polygonMask";
+            this._engine = engine;
+        }
+        async getPlugin(container) {
+            const { PolygonMaskInstance } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./PolygonMaskInstance.js"))) : new Promise((resolve_1, reject_1) => { require(["./PolygonMaskInstance.js"], resolve_1, reject_1); }).then(__importStar));
+            return new PolygonMaskInstance(container, this._engine);
+        }
+        loadOptions(options, source) {
+            if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
+                return;
+            }
+            let polygonOptions = options.polygon;
+            if (polygonOptions?.load === undefined) {
+                options.polygon = polygonOptions = new PolygonMask_js_1.PolygonMask();
+            }
+            polygonOptions.load(source?.polygon);
+        }
+        needsPlugin(options) {
+            return (options?.polygon?.enable ??
+                (options?.polygon?.type !== undefined && options.polygon.type !== "none"));
+        }
+    }
+    exports.PolygonMaskPlugin = PolygonMaskPlugin;
+});

package/umd/index.js

@@ -9,6 +9,18 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
@@ -18,39 +30,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./pathseg.js", "./Options/Classes/PolygonMask.js", "./PolygonMaskInstance.js", "./Enums/PolygonMaskInlineArrangement.js", "./Enums/PolygonMaskMoveType.js", "./Enums/PolygonMaskType.js"], factory);
+        define(["require", "exports", "./pathseg.js", "./Enums/PolygonMaskInlineArrangement.js", "./Enums/PolygonMaskMoveType.js", "./Enums/PolygonMaskType.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.loadPolygonMaskPlugin = void 0;
     require("./pathseg.js");
-    const PolygonMask_js_1 = require("./Options/Classes/PolygonMask.js");
-    const PolygonMaskInstance_js_1 = require("./PolygonMaskInstance.js");
-    class PolygonMaskPlugin {
-        constructor(engine) {
-            this.id = "polygonMask";
-            this._engine = engine;
-        }
-        getPlugin(container) {
-            return new PolygonMaskInstance_js_1.PolygonMaskInstance(container, this._engine);
-        }
-        loadOptions(options, source) {
-            if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
-                return;
-            }
-            let polygonOptions = options.polygon;
-            if (polygonOptions?.load === undefined) {
-                options.polygon = polygonOptions = new PolygonMask_js_1.PolygonMask();
-            }
-            polygonOptions.load(source?.polygon);
-        }
-        needsPlugin(options) {
-            return (options?.polygon?.enable ??
-                (options?.polygon?.type !== undefined && options.polygon.type !== "none"));
-        }
-    }
     async function loadPolygonMaskPlugin(engine, refresh = true) {
+        const { PolygonMaskPlugin } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./PolygonMaskPlugin.js"))) : new Promise((resolve_1, reject_1) => { require(["./PolygonMaskPlugin.js"], resolve_1, reject_1); }).then(__importStar));
         await engine.addPlugin(new PolygonMaskPlugin(engine), refresh);
     }
     exports.loadPolygonMaskPlugin = loadPolygonMaskPlugin;

package/umd/utils.js

@@ -9,15 +9,20 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.segmentBounce = exports.calcClosestPtOnSegment = exports.parsePaths = exports.drawPolygonMaskPath = exports.drawPolygonMask = void 0;
+    exports.segmentBounce = exports.calcClosestPointOnSegment = exports.parsePaths = exports.drawPolygonMaskPath = exports.drawPolygonMask = void 0;
     const engine_1 = require("@tsparticles/engine");
+    const squareExp = 2, inSegmentRange = {
+        min: 0,
+        max: 1,
+    }, double = 2;
     function drawPolygonMask(context, rawData, stroke) {
         const color = (0, engine_1.rangeColorToRgb)(stroke.color);
         if (!color) {
             return;
         }
+        const firstIndex = 0, firstItem = rawData[firstIndex];
         context.beginPath();
-        context.moveTo(rawData[0].x, rawData[0].y);
+        context.moveTo(firstItem.x, firstItem.y);
         for (const item of rawData) {
             context.lineTo(item.x, item.y);
         }
@@ -28,7 +33,13 @@
     }
     exports.drawPolygonMask = drawPolygonMask;
     function drawPolygonMaskPath(context, path, stroke, position) {
-        context.setTransform(1, 0, 0, 1, position.x, position.y);
+        const defaultTransform = {
+            a: 1,
+            b: 0,
+            c: 0,
+            d: 1,
+        };
+        context.setTransform(defaultTransform.a, defaultTransform.b, defaultTransform.c, defaultTransform.d, position.x, position.y);
         const color = (0, engine_1.rangeColorToRgb)(stroke.color);
         if (!color) {
             return;
@@ -36,13 +47,13 @@
         context.strokeStyle = (0, engine_1.getStyleFromRgb)(color, stroke.opacity);
         context.lineWidth = stroke.width;
         context.stroke(path);
-        context.setTransform(1, 0, 0, 1, 0, 0);
+        context.resetTransform();
     }
     exports.drawPolygonMaskPath = drawPolygonMaskPath;
     function parsePaths(paths, scale, offset) {
-        const res = [];
+        const res = [], defaultCount = 0;
         for (const path of paths) {
-            const segments = path.element.pathSegList, len = segments?.numberOfItems ?? 0, p = {
+            const segments = path.element.pathSegList, len = segments?.numberOfItems ?? defaultCount, p = {
                 x: 0,
                 y: 0,
             };
@@ -98,25 +109,25 @@
         return res;
     }
     exports.parsePaths = parsePaths;
-    function calcClosestPtOnSegment(s1, s2, pos) {
-        const { dx: dx1, dy: dy1 } = (0, engine_1.getDistances)(pos, s1), { dx: dx2, dy: dy2 } = (0, engine_1.getDistances)(s2, s1), t = (dx1 * dx2 + dy1 * dy2) / (dx2 ** 2 + dy2 ** 2), res = {
+    function calcClosestPointOnSegment(s1, s2, pos) {
+        const { dx: dx1, dy: dy1 } = (0, engine_1.getDistances)(pos, s1), { dx: dx2, dy: dy2 } = (0, engine_1.getDistances)(s2, s1), t = (dx1 * dx2 + dy1 * dy2) / (dx2 ** squareExp + dy2 ** squareExp), res = {
             x: s1.x + dx2 * t,
             y: s1.y + dy2 * t,
-            isOnSegment: t >= 0 && t <= 1,
+            isOnSegment: t >= inSegmentRange.min && t <= inSegmentRange.max,
         };
-        if (t < 0) {
+        if (t < inSegmentRange.min) {
             res.x = s1.x;
             res.y = s1.y;
         }
-        else if (t > 1) {
+        else if (t > inSegmentRange.max) {
             res.x = s2.x;
             res.y = s2.y;
         }
         return res;
     }
-    exports.calcClosestPtOnSegment = calcClosestPtOnSegment;
+    exports.calcClosestPointOnSegment = calcClosestPointOnSegment;
     function segmentBounce(start, stop, velocity) {
-        const { dx, dy } = (0, engine_1.getDistances)(start, stop), wallAngle = Math.atan2(dy, dx), wallNormal = engine_1.Vector.create(Math.sin(wallAngle), -Math.cos(wallAngle)), d = 2 * (velocity.x * wallNormal.x + velocity.y * wallNormal.y);
+        const { dx, dy } = (0, engine_1.getDistances)(start, stop), wallAngle = Math.atan2(dy, dx), wallNormal = engine_1.Vector.create(Math.sin(wallAngle), -Math.cos(wallAngle)), d = double * (velocity.x * wallNormal.x + velocity.y * wallNormal.y);
         wallNormal.multTo(d);
         velocity.subFrom(wallNormal);
     }