@tsparticles/plugin-emitters 3.0.0-alpha.0

package/umd/Emitters.js

@@ -0,0 +1,133 @@
+(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", "@tsparticles/engine", "./Options/Classes/Emitter", "./EmitterInstance"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Emitters = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const Emitter_1 = require("./Options/Classes/Emitter");
+    const EmitterInstance_1 = require("./EmitterInstance");
+    class Emitters {
+        constructor(engine, container) {
+            this.container = container;
+            this._engine = engine;
+            this.array = [];
+            this.emitters = [];
+            this.interactivityEmitters = {
+                random: {
+                    count: 1,
+                    enable: false,
+                },
+                value: [],
+            };
+            container.getEmitter = (idxOrName) => idxOrName === undefined || typeof idxOrName === "number"
+                ? this.array[idxOrName || 0]
+                : this.array.find((t) => t.name === idxOrName);
+            container.addEmitter = (options, position) => this.addEmitter(options, position);
+            container.removeEmitter = (idxOrName) => {
+                const emitter = container.getEmitter(idxOrName);
+                if (emitter) {
+                    this.removeEmitter(emitter);
+                }
+            };
+            container.playEmitter = (idxOrName) => {
+                const emitter = container.getEmitter(idxOrName);
+                if (emitter) {
+                    emitter.externalPlay();
+                }
+            };
+            container.pauseEmitter = (idxOrName) => {
+                const emitter = container.getEmitter(idxOrName);
+                if (emitter) {
+                    emitter.externalPause();
+                }
+            };
+        }
+        addEmitter(options, position) {
+            const emitterOptions = new Emitter_1.Emitter();
+            emitterOptions.load(options);
+            const emitter = new EmitterInstance_1.EmitterInstance(this._engine, this, this.container, emitterOptions, position);
+            this.array.push(emitter);
+            return emitter;
+        }
+        handleClickMode(mode) {
+            const emitterOptions = this.emitters, modeEmitters = this.interactivityEmitters;
+            if (mode === "emitter") {
+                let emittersModeOptions;
+                if (modeEmitters && modeEmitters.value instanceof Array) {
+                    if (modeEmitters.value.length > 0 && modeEmitters.random.enable) {
+                        emittersModeOptions = [];
+                        const usedIndexes = [];
+                        for (let i = 0; i < modeEmitters.random.count; i++) {
+                            const idx = (0, engine_1.arrayRandomIndex)(modeEmitters.value);
+                            if (usedIndexes.includes(idx) && usedIndexes.length < modeEmitters.value.length) {
+                                i--;
+                                continue;
+                            }
+                            usedIndexes.push(idx);
+                            emittersModeOptions.push((0, engine_1.itemFromArray)(modeEmitters.value, idx));
+                        }
+                    }
+                    else {
+                        emittersModeOptions = modeEmitters.value;
+                    }
+                }
+                else {
+                    emittersModeOptions = modeEmitters === null || modeEmitters === void 0 ? void 0 : modeEmitters.value;
+                }
+                const emittersOptions = emittersModeOptions !== null && emittersModeOptions !== void 0 ? emittersModeOptions : emitterOptions, ePosition = this.container.interactivity.mouse.clickPosition;
+                (0, engine_1.executeOnSingleOrMultiple)(emittersOptions, (emitter) => {
+                    this.addEmitter(emitter, ePosition);
+                });
+            }
+        }
+        async init() {
+            this.emitters = this.container.actualOptions.emitters;
+            this.interactivityEmitters = this.container.actualOptions.interactivity.modes.emitters;
+            if (this.emitters instanceof Array) {
+                for (const emitterOptions of this.emitters) {
+                    this.addEmitter(emitterOptions);
+                }
+            }
+            else {
+                this.addEmitter(this.emitters);
+            }
+        }
+        pause() {
+            for (const emitter of this.array) {
+                emitter.pause();
+            }
+        }
+        play() {
+            for (const emitter of this.array) {
+                emitter.play();
+            }
+        }
+        removeEmitter(emitter) {
+            const index = this.array.indexOf(emitter);
+            if (index >= 0) {
+                this.array.splice(index, 1);
+            }
+        }
+        resize() {
+            for (const emitter of this.array) {
+                emitter.resize();
+            }
+        }
+        stop() {
+            this.array = [];
+        }
+        update(delta) {
+            for (const emitter of this.array) {
+                emitter.update(delta);
+            }
+        }
+    }
+    exports.Emitters = Emitters;
+});

package/umd/EmittersEngine.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/EmitterClickMode.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/EmitterShapeType.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/IEmitterShape.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/Options/Classes/Emitter.js

@@ -0,0 +1,76 @@
+(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", "@tsparticles/engine", "./EmitterLife", "./EmitterRate", "./EmitterSize"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Emitter = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const EmitterLife_1 = require("./EmitterLife");
+    const EmitterRate_1 = require("./EmitterRate");
+    const EmitterSize_1 = require("./EmitterSize");
+    class Emitter {
+        constructor() {
+            this.autoPlay = true;
+            this.fill = true;
+            this.life = new EmitterLife_1.EmitterLife();
+            this.rate = new EmitterRate_1.EmitterRate();
+            this.shape = "square";
+            this.startCount = 0;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.autoPlay !== undefined) {
+                this.autoPlay = data.autoPlay;
+            }
+            if (data.size !== undefined) {
+                if (this.size === undefined) {
+                    this.size = new EmitterSize_1.EmitterSize();
+                }
+                this.size.load(data.size);
+            }
+            if (data.direction !== undefined) {
+                this.direction = data.direction;
+            }
+            this.domId = data.domId;
+            if (data.fill !== undefined) {
+                this.fill = data.fill;
+            }
+            this.life.load(data.life);
+            this.name = data.name;
+            this.particles = (0, engine_1.executeOnSingleOrMultiple)(data.particles, (particles) => {
+                return (0, engine_1.deepExtend)({}, particles);
+            });
+            this.rate.load(data.rate);
+            if (data.shape !== undefined) {
+                this.shape = data.shape;
+            }
+            if (data.position !== undefined) {
+                this.position = {};
+                if (data.position.x !== undefined) {
+                    this.position.x = (0, engine_1.setRangeValue)(data.position.x);
+                }
+                if (data.position.y !== undefined) {
+                    this.position.y = (0, engine_1.setRangeValue)(data.position.y);
+                }
+            }
+            if (data.spawnColor !== undefined) {
+                if (this.spawnColor === undefined) {
+                    this.spawnColor = new engine_1.AnimatableColor();
+                }
+                this.spawnColor.load(data.spawnColor);
+            }
+            if (data.startCount !== undefined) {
+                this.startCount = data.startCount;
+            }
+        }
+    }
+    exports.Emitter = Emitter;
+});

package/umd/Options/Classes/EmitterLife.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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EmitterLife = void 0;
+    class EmitterLife {
+        constructor() {
+            this.wait = false;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.count !== undefined) {
+                this.count = data.count;
+            }
+            if (data.delay !== undefined) {
+                this.delay = data.delay;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            if (data.wait !== undefined) {
+                this.wait = data.wait;
+            }
+        }
+    }
+    exports.EmitterLife = EmitterLife;
+});

package/umd/Options/Classes/EmitterRate.js

@@ -0,0 +1,32 @@
+(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", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EmitterRate = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class EmitterRate {
+        constructor() {
+            this.quantity = 1;
+            this.delay = 0.1;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.quantity !== undefined) {
+                this.quantity = (0, engine_1.setRangeValue)(data.quantity);
+            }
+            if (data.delay !== undefined) {
+                this.delay = (0, engine_1.setRangeValue)(data.delay);
+            }
+        }
+    }
+    exports.EmitterRate = EmitterRate;
+});

package/umd/Options/Classes/EmitterSize.js

@@ -0,0 +1,35 @@
+(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.EmitterSize = void 0;
+    class EmitterSize {
+        constructor() {
+            this.mode = "percent";
+            this.height = 0;
+            this.width = 0;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.mode !== undefined) {
+                this.mode = data.mode;
+            }
+            if (data.height !== undefined) {
+                this.height = data.height;
+            }
+            if (data.width !== undefined) {
+                this.width = data.width;
+            }
+        }
+    }
+    exports.EmitterSize = EmitterSize;
+});

package/umd/Options/Interfaces/IEmitter.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/Options/Interfaces/IEmitterLife.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/Options/Interfaces/IEmitterRate.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/Options/Interfaces/IEmitterSize.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/ShapeManager.js

@@ -0,0 +1,31 @@
+(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.ShapeManager = void 0;
+    const shapes = new Map();
+    class ShapeManager {
+        constructor(engine) {
+            this._engine = engine;
+        }
+        addShape(name, drawer) {
+            if (!this.getShape(name)) {
+                shapes.set(name, drawer);
+            }
+        }
+        getShape(name) {
+            return shapes.get(name);
+        }
+        getSupportedShapes() {
+            return shapes.keys();
+        }
+    }
+    exports.ShapeManager = ShapeManager;
+});

package/umd/Shapes/Circle/CircleShape.js

@@ -0,0 +1,38 @@
+(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", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CircleShape = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class CircleShape {
+        randomPosition(position, size, fill) {
+            const generateTheta = (x, y) => {
+                const u = (0, engine_1.getRandom)() / 4.0, theta = Math.atan((y / x) * Math.tan(2 * Math.PI * u)), v = (0, engine_1.getRandom)();
+                if (v < 0.25) {
+                    return theta;
+                }
+                else if (v < 0.5) {
+                    return Math.PI - theta;
+                }
+                else if (v < 0.75) {
+                    return Math.PI + theta;
+                }
+                else {
+                    return -theta;
+                }
+            }, radius = (x, y, theta) => (x * y) / Math.sqrt((y * Math.cos(theta)) ** 2 + (x * Math.sin(theta)) ** 2), [a, b] = [size.width / 2, size.height / 2], randomTheta = generateTheta(a, b), maxRadius = radius(a, b, randomTheta), randomRadius = fill ? maxRadius * Math.sqrt((0, engine_1.getRandom)()) : maxRadius;
+            return {
+                x: position.x + randomRadius * Math.cos(randomTheta),
+                y: position.y + randomRadius * Math.sin(randomTheta),
+            };
+        }
+    }
+    exports.CircleShape = CircleShape;
+});

package/umd/Shapes/Square/SquareShape.js

@@ -0,0 +1,54 @@
+(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", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SquareShape = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    function randomSquareCoordinate(position, offset) {
+        return position + offset * ((0, engine_1.getRandom)() - 0.5);
+    }
+    class SquareShape {
+        randomPosition(position, size, fill) {
+            if (fill) {
+                return {
+                    x: randomSquareCoordinate(position.x, size.width),
+                    y: randomSquareCoordinate(position.y, size.height),
+                };
+            }
+            else {
+                const halfW = size.width / 2, halfH = size.height / 2, side = Math.floor((0, engine_1.getRandom)() * 4), v = ((0, engine_1.getRandom)() - 0.5) * 2;
+                switch (side) {
+                    case 0:
+                        return {
+                            x: position.x + v * halfW,
+                            y: position.y - halfH,
+                        };
+                    case 1:
+                        return {
+                            x: position.x - halfW,
+                            y: position.y + v * halfH,
+                        };
+                    case 2:
+                        return {
+                            x: position.x + v * halfW,
+                            y: position.y + halfH,
+                        };
+                    case 3:
+                    default:
+                        return {
+                            x: position.x + halfW,
+                            y: position.y + v * halfH,
+                        };
+                }
+            }
+        }
+    }
+    exports.SquareShape = SquareShape;
+});