custom-pixi-particles 2.0.10 → 3.0.2

package/dist/lib/pixi/Renderer.js

@@ -1,438 +1,428 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// tslint:disable:prefer-for-of
-var index_1 = __importDefault(require("../index"));
-var emitter_1 = require("../emitter");
-var turbulencePool_1 = __importDefault(require("../util/turbulencePool"));
-var BehaviourNames_1 = __importDefault(require("../behaviour/BehaviourNames"));
-var List_1 = __importDefault(require("../util/List"));
-var ParticlePool_1 = __importDefault(require("../ParticlePool"));
-var pixi_js_1 = require("pixi.js");
-var Renderer = /** @class */ (function (_super) {
-    __extends(Renderer, _super);
-    function Renderer(settings) {
-        var _this = _super.call(this, 100000, {
-            vertices: true,
-            position: true,
-            rotation: true,
-            uvs: !!(settings.emitterConfig.animatedSprite ||
-                (settings.finishingTextures && settings.finishingTextures.length)),
-            tint: true,
-        }) || this;
-        _this.onComplete = function () { };
-        _this._paused = false;
-        _this.currentTime = 0;
-        _this.lastTime = 0;
-        _this.pausedTime = 0;
-        _this.unusedSprites = [];
-        _this.getByName = function (name) {
-            for (var i = 0; i < _this.config.behaviours.length; ++i) {
-                if (_this.config.behaviours[i].name === name) {
-                    return _this.config.behaviours[i];
-                }
-            }
-            return null;
-        };
-        var textures = settings.textures, emitterConfig = settings.emitterConfig, finishingTextures = settings.finishingTextures;
-        _this.config = emitterConfig;
-        _this.textures = textures;
-        _this.finishingTextureNames = finishingTextures;
-        var turbulenceConfigIndex = _this.getConfigIndexByName(BehaviourNames_1.default.TURBULENCE_BEHAVIOUR, emitterConfig);
-        if (turbulenceConfigIndex !== -1) {
-            var turbulenceConfig = emitterConfig.behaviours[turbulenceConfigIndex];
-            if (turbulenceConfig.enabled === true) {
-                _this.turbulenceEmitter = new index_1.default.Emitter();
-                _this.turbulenceParser = _this.turbulenceEmitter.getParser();
-                _this.turbulenceParser.read(_this.buildTurbulenceConfig(turbulenceConfig));
-                _this.turbulenceEmitter.on(emitter_1.Emitter.CREATE, _this.onCreateTurbulence, _this);
-                _this.turbulenceEmitter.on(emitter_1.Emitter.UPDATE, _this.onUpdateTurbulence, _this);
-                _this.turbulenceEmitter.on(emitter_1.Emitter.REMOVE, _this.onRemoveTurbulence, _this);
-            }
-        }
-        if (typeof emitterConfig.alpha !== 'undefined') {
-            _this.alpha = emitterConfig.alpha;
-        }
-        if (typeof emitterConfig.blendMode !== 'undefined') {
-            _this.blendMode = emitterConfig.blendMode;
-        }
-        _this.emitter = new index_1.default.Emitter();
-        _this.emitterParser = _this.emitter.getParser();
-        _this.emitterParser.read(emitterConfig);
-        _this.emitter.on(emitter_1.Emitter.CREATE, _this.onCreate, _this);
-        _this.emitter.on(emitter_1.Emitter.UPDATE, _this.onUpdate, _this);
-        _this.emitter.on(emitter_1.Emitter.FINISHING, _this.onFinishing, _this);
-        _this.emitter.on(emitter_1.Emitter.REMOVE, _this.onRemove, _this);
-        _this.emitter.on(emitter_1.Emitter.PLAY, _this.onPlay, _this);
-        _this.emitter.on(emitter_1.Emitter.COMPLETE, function () {
-            _this.onComplete();
-        });
-        if (_this.turbulenceEmitter && _this.turbulenceEmitter.list) {
-            turbulencePool_1.default.list = _this.turbulenceEmitter.list;
-        }
-        document.addEventListener('visibilitychange', function () { return _this.paused(document.hidden); });
-        return _this;
-    }
-    Renderer.prototype.updateTransform = function () {
-        if (this._paused)
-            return;
-        this.currentTime = performance.now();
-        if (this.lastTime === 0) {
-            this.lastTime = this.currentTime;
-        }
-        this.emitter.update((this.currentTime - this.lastTime) / 1000);
-        if (this.turbulenceEmitter) {
-            this.turbulenceEmitter.update((this.currentTime - this.lastTime) / 1000);
-        }
-        pixi_js_1.ParticleContainer.prototype.updateTransform.call(this);
-        this.lastTime = this.currentTime;
-    };
-    Renderer.prototype.updateTexture = function () {
-        for (var i = 0; i < this.unusedSprites.length; ++i) {
-            this.unusedSprites[i].texture = pixi_js_1.Texture.from(this.getRandomTexture());
-        }
-        for (var i = 0; i < this.children.length; ++i) {
-            // @ts-ignore
-            this.children[i].texture = pixi_js_1.Texture.from(this.getRandomTexture());
-        }
-    };
-    Renderer.prototype.start = function () {
-        this.emitter.resetAndPlay();
-        if (this.turbulenceEmitter) {
-            this.turbulenceEmitter.resetAndPlay();
-        }
-    };
-    Renderer.prototype.play = function () {
-        this.emitter.resetWithoutRemovingAndPlay();
-        if (this.turbulenceEmitter) {
-            this.turbulenceEmitter.resetWithoutRemovingAndPlay();
-        }
-    };
-    Renderer.prototype.stopImmediately = function () {
-        this.emitter.stop();
-        if (this.turbulenceEmitter) {
-            this.turbulenceEmitter.stop();
-        }
-        this.emitter.emit(emitter_1.Emitter.COMPLETE);
-    };
-    Renderer.prototype.stop = function () {
-        this.emitter.stopWithoutKilling();
-        if (this.turbulenceEmitter) {
-            this.turbulenceEmitter.stop();
-        }
-    };
-    Renderer.prototype.resetEmitter = function () {
-        this.emitter.reset();
-        if (this.turbulenceEmitter) {
-            this.turbulenceEmitter.reset();
-        }
-    };
-    Renderer.prototype.setTextures = function (textures) {
-        this.textures = textures;
-        this.updateTexture();
-    };
-    Renderer.prototype.updateConfig = function (config) {
-        this.emitterParser.update(config);
-        if (this.turbulenceEmitter) {
-            var turbulenceConfigIndex = this.getConfigIndexByName(BehaviourNames_1.default.TURBULENCE_BEHAVIOUR, config);
-            if (turbulenceConfigIndex !== -1) {
-                var turbulenceConfig = config.behaviours[turbulenceConfigIndex];
-                if (turbulenceConfig.enabled === true) {
-                    this.turbulenceParser.update(this.buildTurbulenceConfig(turbulenceConfig));
-                }
-            }
-        }
-    };
-    Renderer.prototype.updatePosition = function (position) {
-        var positionBehaviour = this.getByName(BehaviourNames_1.default.POSITION_BEHAVIOUR);
-        positionBehaviour.position.x = position.x;
-        positionBehaviour.position.y = position.y;
-        this.emitterParser.update(this.config);
-    };
-    Renderer.prototype.clearPool = function () {
-        this.removeChildren();
-        this.unusedSprites = [];
-        if (this.turbulenceEmitter && this.turbulenceEmitter.list) {
-            turbulencePool_1.default.list.reset();
-            turbulencePool_1.default.list = new List_1.default();
-        }
-        this.emitter.list.reset();
-        this.emitter.list = new List_1.default();
-        ParticlePool_1.default.global.reset();
-    };
-    Renderer.prototype.getOrCreateSprite = function () {
-        if (this.unusedSprites.length > 0) {
-            var sprite_1 = this.unusedSprites.pop();
-            if (this.finishingTextureNames && this.finishingTextureNames.length) {
-                sprite_1.texture = pixi_js_1.Texture.from(this.getRandomTexture());
-            }
-            return sprite_1;
-        }
-        if (this.emitter.animatedSprite) {
-            var textures = this.createFrameAnimationByName(this.getRandomTexture(), 2);
-            if (textures.length) {
-                var animation = new pixi_js_1.AnimatedSprite(textures);
-                animation.anchor.set(0.5);
-                animation.loop = this.emitter.animatedSprite.loop;
-                animation.play();
-                animation.animationSpeed = this.emitter.animatedSprite.frameRate;
-                return this.addChild(animation);
-            }
-        }
-        var sprite = new pixi_js_1.Sprite(pixi_js_1.Texture.from(this.getRandomTexture()));
-        sprite.anchor.set(0.5);
-        return this.addChild(sprite);
-    };
-    Renderer.prototype.createFrameAnimationByName = function (prefix, zeroPad, imageFileExtension) {
-        if (zeroPad === void 0) { zeroPad = 0; }
-        if (imageFileExtension === void 0) { imageFileExtension = 'png'; }
-        var textures = [];
-        var frame = '';
-        var indexFrame = 0;
-        var padding = 0;
-        var texture;
-        var sheets = [];
-        var resources = pixi_js_1.Loader.shared.resources;
-        for (var key in resources) {
-            if (resources[key].extension === 'json') {
-                // @ts-ignore
-                sheets.push(resources[key].spritesheet);
-            }
-        }
-        do {
-            frame = indexFrame.toString();
-            padding = zeroPad - frame.length;
-            if (padding > 0) {
-                frame = '0'.repeat(padding) + frame;
-            }
-            try {
-                var found = false;
-                for (var _i = 0, sheets_1 = sheets; _i < sheets_1.length; _i++) {
-                    var sheet = sheets_1[_i];
-                    if (sheet && sheet.textures[prefix + "_" + frame + "." + imageFileExtension]) {
-                        found = true;
-                    }
-                }
-                if (found) {
-                    texture = pixi_js_1.Texture.from(prefix + "_" + frame + "." + imageFileExtension);
-                    textures.push(texture);
-                    indexFrame += 1;
-                }
-                else {
-                    texture = null;
-                    for (var key in resources) {
-                        if (key === prefix + "_" + frame + "." + imageFileExtension) {
-                            texture = pixi_js_1.Texture.from(prefix + "_" + frame + "." + imageFileExtension);
-                            textures.push(texture);
-                            indexFrame += 1;
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                texture = null;
-            }
-        } while (texture);
-        return textures;
-    };
-    Renderer.prototype.onPlay = function () {
-        this.currentTime = 0;
-        this.lastTime = 0;
-    };
-    Renderer.prototype.onCreate = function (particle) {
-        var sprite = this.getOrCreateSprite();
-        sprite.visible = true;
-        sprite.alpha = 1;
-        if (this.blendMode) {
-            sprite.blendMode = this.blendMode;
-        }
-        particle.sprite = sprite;
-    };
-    Renderer.prototype.onCreateTurbulence = function (particle) {
-        var sprite = new pixi_js_1.Sprite(pixi_js_1.Texture.from('vortex.png'));
-        sprite.anchor.set(0.5);
-        this.addChild(sprite);
-        sprite.visible = false;
-        sprite.alpha = 0;
-        particle.sprite = sprite;
-        if (particle.showVortices && sprite) {
-            sprite.visible = true;
-            sprite.alpha = 1;
-        }
-    };
-    Renderer.prototype.onUpdate = function (particle) {
-        var sprite = particle.sprite;
-        sprite.x = particle.x;
-        sprite.y = particle.y;
-        sprite.scale.x = particle.size.x;
-        sprite.scale.y = particle.size.y;
-        sprite.tint = particle.color.hex;
-        sprite.alpha = particle.color.alpha;
-        sprite.rotation = particle.rotation;
-    };
-    Renderer.prototype.onUpdateTurbulence = function (particle) {
-        var sprite = particle.sprite;
-        sprite.x = particle.x;
-        sprite.y = particle.y;
-        if (particle.showVortices && sprite) {
-            sprite.scale.x = particle.size.x;
-            sprite.scale.y = particle.size.y;
-            sprite.tint = particle.color.hex;
-            sprite.alpha = particle.color.alpha;
-            sprite.rotation = particle.rotation;
-        }
-    };
-    Renderer.prototype.onFinishing = function (particle) {
-        if (!this.finishingTextureNames || !this.finishingTextureNames.length)
-            return;
-        var sprite = particle.sprite;
-        if (particle.finishingTexture <= this.finishingTextureNames.length - 1) {
-            sprite.texture = pixi_js_1.Texture.from(this.finishingTextureNames[particle.finishingTexture]);
-            particle.finishingTexture++;
-        }
-    };
-    Renderer.prototype.onRemove = function (particle) {
-        var sprite = particle.sprite;
-        if (!particle.showVortices && sprite) {
-            sprite.visible = false;
-            sprite.alpha = 0;
-        }
-        particle.finishingTexture = 0;
-        this.unusedSprites.push(sprite);
-        // this.removeChild(sprite)
-        // delete particle.sprite
-    };
-    Renderer.prototype.onRemoveTurbulence = function (particle) {
-        var sprite = particle.sprite;
-        if (!particle.showVortices && sprite) {
-            sprite.visible = false;
-            sprite.alpha = 0;
-        }
-        this.removeChild(sprite);
-        delete particle.sprite;
-    };
-    Renderer.prototype.getRandomTexture = function () {
-        return this.textures[Math.floor(Math.random() * this.textures.length)];
-    };
-    Renderer.prototype.paused = function (paused) {
-        if (paused === this._paused)
-            return;
-        if (paused) {
-            this.pausedTime = performance.now();
-        }
-        else {
-            this.pausedTime = 0;
-            this.lastTime = performance.now() - this.pausedTime;
-        }
-        this._paused = paused;
-    };
-    Renderer.prototype.getConfigIndexByName = function (name, config) {
-        var index = -1;
-        config.behaviours.forEach(function (behaviour, i) {
-            if (behaviour.name === name) {
-                index = i;
-            }
-        });
-        return index;
-    };
-    Renderer.prototype.buildTurbulenceConfig = function (turbulenceConfig) {
-        var config = {
-            behaviours: [
-                {
-                    enabled: true,
-                    priority: 10000,
-                    maxLifeTime: turbulenceConfig.maxLifeTime || 2,
-                    timeVariance: turbulenceConfig.maxLifeTimeVariance || 0,
-                    name: 'LifeBehaviour',
-                },
-                {
-                    enabled: true,
-                    priority: 100,
-                    position: {
-                        x: turbulenceConfig.position.x || 0,
-                        y: turbulenceConfig.position.y || 0,
-                    },
-                    positionVariance: {
-                        x: turbulenceConfig.positionVariance.x || 0,
-                        y: turbulenceConfig.positionVariance.y || 0,
-                    },
-                    velocity: {
-                        x: turbulenceConfig.velocity.x || 0,
-                        y: turbulenceConfig.velocity.y || 0,
-                    },
-                    velocityVariance: {
-                        x: turbulenceConfig.velocityVariance.x || 0,
-                        y: turbulenceConfig.velocityVariance.y || 0,
-                    },
-                    acceleration: {
-                        x: turbulenceConfig.acceleration.x || 0,
-                        y: turbulenceConfig.acceleration.y || 0,
-                    },
-                    accelerationVariance: {
-                        x: turbulenceConfig.accelerationVariance.x || 0,
-                        y: turbulenceConfig.accelerationVariance.y || 0,
-                    },
-                    name: 'PositionBehaviour',
-                },
-                {
-                    enabled: true,
-                    priority: 0,
-                    sizeStart: {
-                        x: turbulenceConfig.sizeStart.x || 1,
-                        y: turbulenceConfig.sizeStart.y || 1,
-                    },
-                    sizeEnd: {
-                        x: turbulenceConfig.sizeEnd.x || 1,
-                        y: turbulenceConfig.sizeEnd.y || 1,
-                    },
-                    startVariance: turbulenceConfig.startVariance || 0,
-                    endVariance: turbulenceConfig.endVariance || 0,
-                    name: 'SizeBehaviour',
-                },
-                {
-                    enabled: true,
-                    priority: 0,
-                    rotation: 12,
-                    variance: 0,
-                    name: 'RotationBehaviour',
-                },
-                {
-                    enabled: true,
-                    priority: 0,
-                    showVortices: turbulenceConfig.showVortices || false,
-                    turbulence: true,
-                    name: 'TurbulenceBehaviour',
-                },
-            ],
-            emitController: {
-                _maxParticles: 0,
-                _maxLife: 1,
-                _emitPerSecond: turbulenceConfig.emitPerSecond || 2,
-                _frames: 0,
-                name: 'UniformEmission',
-            },
-            duration: turbulenceConfig.duration || -1,
-        };
-        return config;
-    };
-    return Renderer;
-}(pixi_js_1.ParticleContainer));
-exports.default = Renderer;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tslint:disable:prefer-for-of
+var index_1 = __importDefault(require("../index"));
+var emitter_1 = require("../emitter");
+var turbulencePool_1 = __importDefault(require("../util/turbulencePool"));
+var BehaviourNames_1 = __importDefault(require("../behaviour/BehaviourNames"));
+var List_1 = __importDefault(require("../util/List"));
+var ParticlePool_1 = __importDefault(require("../ParticlePool"));
+var Renderer = /** @class */ (function () {
+    function Renderer(settings) {
+        var _this = this;
+        this.onComplete = function () { };
+        this._paused = false;
+        this.currentTime = 0;
+        this.lastTime = 0;
+        this.pausedTime = 0;
+        this.unusedSprites = [];
+        this.getByName = function (name) {
+            for (var i = 0; i < _this.config.behaviours.length; ++i) {
+                if (_this.config.behaviours[i].name === name) {
+                    return _this.config.behaviours[i];
+                }
+            }
+            return null;
+        };
+        var textures = settings.textures, emitterConfig = settings.emitterConfig, finishingTextures = settings.finishingTextures, PIXI = settings.PIXI;
+        this.particlesContainer = new PIXI.ParticleContainer(100000, {
+            vertices: true,
+            position: true,
+            rotation: true,
+            uvs: !!(settings.emitterConfig.animatedSprite ||
+                (settings.finishingTextures && settings.finishingTextures.length)),
+            tint: true,
+        });
+        this.PIXI = PIXI;
+        this.config = emitterConfig;
+        this.textures = textures;
+        this.finishingTextureNames = finishingTextures;
+        var turbulenceConfigIndex = this.getConfigIndexByName(BehaviourNames_1.default.TURBULENCE_BEHAVIOUR, emitterConfig);
+        if (turbulenceConfigIndex !== -1) {
+            var turbulenceConfig = emitterConfig.behaviours[turbulenceConfigIndex];
+            if (turbulenceConfig.enabled === true) {
+                this.turbulenceEmitter = new index_1.default.Emitter();
+                this.turbulenceParser = this.turbulenceEmitter.getParser();
+                this.turbulenceParser.read(this.buildTurbulenceConfig(turbulenceConfig));
+                this.turbulenceEmitter.on(emitter_1.Emitter.CREATE, this.onCreateTurbulence, this);
+                this.turbulenceEmitter.on(emitter_1.Emitter.UPDATE, this.onUpdateTurbulence, this);
+                this.turbulenceEmitter.on(emitter_1.Emitter.REMOVE, this.onRemoveTurbulence, this);
+            }
+        }
+        if (typeof emitterConfig.alpha !== 'undefined') {
+            this.particlesContainer.alpha = emitterConfig.alpha;
+        }
+        if (typeof emitterConfig.blendMode !== 'undefined') {
+            this.blendMode = emitterConfig.blendMode;
+        }
+        this.emitter = new index_1.default.Emitter();
+        this.emitterParser = this.emitter.getParser();
+        this.emitterParser.read(emitterConfig);
+        this.emitter.on(emitter_1.Emitter.CREATE, this.onCreate, this);
+        this.emitter.on(emitter_1.Emitter.UPDATE, this.onUpdate, this);
+        this.emitter.on(emitter_1.Emitter.FINISHING, this.onFinishing, this);
+        this.emitter.on(emitter_1.Emitter.REMOVE, this.onRemove, this);
+        this.emitter.on(emitter_1.Emitter.PLAY, this.onPlay, this);
+        this.emitter.on(emitter_1.Emitter.COMPLETE, function () {
+            _this.onComplete();
+        });
+        if (this.turbulenceEmitter && this.turbulenceEmitter.list) {
+            turbulencePool_1.default.list = this.turbulenceEmitter.list;
+        }
+        document.addEventListener('visibilitychange', function () { return _this.paused(document.hidden); });
+        var ticker = this.PIXI.Ticker.shared;
+        ticker.add(function () {
+            _this.updateTransform();
+        });
+    }
+    Renderer.prototype.updateTransform = function () {
+        if (this._paused)
+            return;
+        this.currentTime = performance.now();
+        if (this.lastTime === 0) {
+            this.lastTime = this.currentTime;
+        }
+        this.emitter.update((this.currentTime - this.lastTime) / 1000);
+        if (this.turbulenceEmitter) {
+            this.turbulenceEmitter.update((this.currentTime - this.lastTime) / 1000);
+        }
+        this.lastTime = this.currentTime;
+    };
+    Renderer.prototype.updateTexture = function () {
+        for (var i = 0; i < this.unusedSprites.length; ++i) {
+            this.unusedSprites[i].texture = this.PIXI.Texture.from(this.getRandomTexture());
+        }
+        for (var i = 0; i < this.particlesContainer.children.length; ++i) {
+            // @ts-ignore
+            this.children[i].texture = this.PIXI.Texture.from(this.getRandomTexture());
+        }
+    };
+    Renderer.prototype.start = function () {
+        this.emitter.resetAndPlay();
+        if (this.turbulenceEmitter) {
+            this.turbulenceEmitter.resetAndPlay();
+        }
+    };
+    Renderer.prototype.play = function () {
+        this.emitter.resetWithoutRemovingAndPlay();
+        if (this.turbulenceEmitter) {
+            this.turbulenceEmitter.resetWithoutRemovingAndPlay();
+        }
+    };
+    Renderer.prototype.stopImmediately = function () {
+        this.emitter.stop();
+        if (this.turbulenceEmitter) {
+            this.turbulenceEmitter.stop();
+        }
+        this.emitter.emit(emitter_1.Emitter.COMPLETE);
+    };
+    Renderer.prototype.stop = function () {
+        this.emitter.stopWithoutKilling();
+        if (this.turbulenceEmitter) {
+            this.turbulenceEmitter.stop();
+        }
+    };
+    Renderer.prototype.resetEmitter = function () {
+        this.emitter.reset();
+        if (this.turbulenceEmitter) {
+            this.turbulenceEmitter.reset();
+        }
+    };
+    Renderer.prototype.setTextures = function (textures) {
+        this.textures = textures;
+        this.updateTexture();
+    };
+    Renderer.prototype.updateConfig = function (config) {
+        this.emitterParser.update(config);
+        if (this.turbulenceEmitter) {
+            var turbulenceConfigIndex = this.getConfigIndexByName(BehaviourNames_1.default.TURBULENCE_BEHAVIOUR, config);
+            if (turbulenceConfigIndex !== -1) {
+                var turbulenceConfig = config.behaviours[turbulenceConfigIndex];
+                if (turbulenceConfig.enabled === true) {
+                    this.turbulenceParser.update(this.buildTurbulenceConfig(turbulenceConfig));
+                }
+            }
+        }
+    };
+    Renderer.prototype.updatePosition = function (position) {
+        var positionBehaviour = this.getByName(BehaviourNames_1.default.POSITION_BEHAVIOUR);
+        positionBehaviour.position.x = position.x;
+        positionBehaviour.position.y = position.y;
+        this.emitterParser.update(this.config);
+    };
+    Renderer.prototype.clearPool = function () {
+        this.particlesContainer.removeChildren();
+        this.unusedSprites = [];
+        if (this.turbulenceEmitter && this.turbulenceEmitter.list) {
+            turbulencePool_1.default.list.reset();
+            turbulencePool_1.default.list = new List_1.default();
+        }
+        this.emitter.list.reset();
+        this.emitter.list = new List_1.default();
+        ParticlePool_1.default.global.reset();
+    };
+    Renderer.prototype.getOrCreateSprite = function () {
+        if (this.unusedSprites.length > 0) {
+            var sprite_1 = this.unusedSprites.pop();
+            if (this.finishingTextureNames && this.finishingTextureNames.length) {
+                sprite_1.texture = this.PIXI.Texture.from(this.getRandomTexture());
+            }
+            return sprite_1;
+        }
+        if (this.emitter.animatedSprite) {
+            var textures = this.createFrameAnimationByName(this.getRandomTexture(), 2);
+            if (textures.length) {
+                var animation = new this.PIXI.AnimatedSprite(textures);
+                animation.anchor.set(0.5);
+                animation.loop = this.emitter.animatedSprite.loop;
+                animation.play();
+                animation.animationSpeed = this.emitter.animatedSprite.frameRate;
+                return this.particlesContainer.addChild(animation);
+            }
+        }
+        var sprite = new this.PIXI.Sprite(this.PIXI.Texture.from(this.getRandomTexture()));
+        sprite.anchor.set(0.5);
+        return this.particlesContainer.addChild(sprite);
+    };
+    Renderer.prototype.createFrameAnimationByName = function (prefix, zeroPad, imageFileExtension) {
+        if (zeroPad === void 0) { zeroPad = 0; }
+        if (imageFileExtension === void 0) { imageFileExtension = 'png'; }
+        var textures = [];
+        var frame = '';
+        var indexFrame = 0;
+        var padding = 0;
+        var texture;
+        var sheets = [];
+        var resources = this.PIXI.Loader.shared.resources;
+        for (var key in resources) {
+            if (resources[key].extension === 'json') {
+                // @ts-ignore
+                sheets.push(resources[key].spritesheet);
+            }
+        }
+        do {
+            frame = indexFrame.toString();
+            padding = zeroPad - frame.length;
+            if (padding > 0) {
+                frame = '0'.repeat(padding) + frame;
+            }
+            try {
+                var found = false;
+                for (var _i = 0, sheets_1 = sheets; _i < sheets_1.length; _i++) {
+                    var sheet = sheets_1[_i];
+                    if (sheet && sheet.textures[prefix + "_" + frame + "." + imageFileExtension]) {
+                        found = true;
+                    }
+                }
+                if (found) {
+                    texture = this.PIXI.Texture.from(prefix + "_" + frame + "." + imageFileExtension);
+                    textures.push(texture);
+                    indexFrame += 1;
+                }
+                else {
+                    texture = null;
+                    for (var key in resources) {
+                        if (key === prefix + "_" + frame + "." + imageFileExtension) {
+                            texture = this.PIXI.Texture.from(prefix + "_" + frame + "." + imageFileExtension);
+                            textures.push(texture);
+                            indexFrame += 1;
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                texture = null;
+            }
+        } while (texture);
+        return textures;
+    };
+    Renderer.prototype.onPlay = function () {
+        this.currentTime = 0;
+        this.lastTime = 0;
+    };
+    Renderer.prototype.onCreate = function (particle) {
+        var sprite = this.getOrCreateSprite();
+        sprite.visible = true;
+        sprite.alpha = 1;
+        if (this.blendMode) {
+            sprite.blendMode = this.blendMode;
+        }
+        particle.sprite = sprite;
+    };
+    Renderer.prototype.onCreateTurbulence = function (particle) {
+        var vortexTexture = this.PIXI.Texture.from('vortex.png');
+        if (!vortexTexture)
+            return;
+        var sprite = new this.PIXI.Sprite(vortexTexture);
+        sprite.anchor.set(0.5);
+        this.particlesContainer.addChild(sprite);
+        sprite.visible = false;
+        sprite.alpha = 0;
+        particle.sprite = sprite;
+        if (particle.showVortices && sprite) {
+            sprite.visible = true;
+            sprite.alpha = 1;
+        }
+    };
+    Renderer.prototype.onUpdate = function (particle) {
+        var sprite = particle.sprite;
+        sprite.x = particle.x;
+        sprite.y = particle.y;
+        sprite.scale.x = particle.size.x;
+        sprite.scale.y = particle.size.y;
+        sprite.tint = particle.color.hex;
+        sprite.alpha = particle.color.alpha;
+        sprite.rotation = particle.rotation;
+    };
+    Renderer.prototype.onUpdateTurbulence = function (particle) {
+        var sprite = particle.sprite;
+        sprite.x = particle.x;
+        sprite.y = particle.y;
+        if (particle.showVortices && sprite) {
+            sprite.scale.x = particle.size.x;
+            sprite.scale.y = particle.size.y;
+            sprite.tint = particle.color.hex;
+            sprite.alpha = particle.color.alpha;
+            sprite.rotation = particle.rotation;
+        }
+    };
+    Renderer.prototype.onFinishing = function (particle) {
+        if (!this.finishingTextureNames || !this.finishingTextureNames.length)
+            return;
+        var sprite = particle.sprite;
+        if (particle.finishingTexture <= this.finishingTextureNames.length - 1) {
+            sprite.texture = this.PIXI.Texture.from(this.finishingTextureNames[particle.finishingTexture]);
+            particle.finishingTexture++;
+        }
+    };
+    Renderer.prototype.onRemove = function (particle) {
+        var sprite = particle.sprite;
+        if (!particle.showVortices && sprite) {
+            sprite.visible = false;
+            sprite.alpha = 0;
+        }
+        particle.finishingTexture = 0;
+        this.unusedSprites.push(sprite);
+        // this.removeChild(sprite)
+        // delete particle.sprite
+    };
+    Renderer.prototype.onRemoveTurbulence = function (particle) {
+        var sprite = particle.sprite;
+        if (!particle.showVortices && sprite) {
+            sprite.visible = false;
+            sprite.alpha = 0;
+        }
+        this.particlesContainer.removeChild(sprite);
+        delete particle.sprite;
+    };
+    Renderer.prototype.getRandomTexture = function () {
+        return this.textures[Math.floor(Math.random() * this.textures.length)];
+    };
+    Renderer.prototype.paused = function (paused) {
+        if (paused === this._paused)
+            return;
+        if (paused) {
+            this.pausedTime = performance.now();
+        }
+        else {
+            this.pausedTime = 0;
+            this.lastTime = performance.now() - this.pausedTime;
+        }
+        this._paused = paused;
+    };
+    Renderer.prototype.getConfigIndexByName = function (name, config) {
+        var index = -1;
+        config.behaviours.forEach(function (behaviour, i) {
+            if (behaviour.name === name) {
+                index = i;
+            }
+        });
+        return index;
+    };
+    Renderer.prototype.buildTurbulenceConfig = function (turbulenceConfig) {
+        var config = {
+            behaviours: [
+                {
+                    enabled: true,
+                    priority: 10000,
+                    maxLifeTime: turbulenceConfig.maxLifeTime || 2,
+                    timeVariance: turbulenceConfig.maxLifeTimeVariance || 0,
+                    name: 'LifeBehaviour',
+                },
+                {
+                    enabled: true,
+                    priority: 100,
+                    position: {
+                        x: turbulenceConfig.position.x || 0,
+                        y: turbulenceConfig.position.y || 0,
+                    },
+                    positionVariance: {
+                        x: turbulenceConfig.positionVariance.x || 0,
+                        y: turbulenceConfig.positionVariance.y || 0,
+                    },
+                    velocity: {
+                        x: turbulenceConfig.velocity.x || 0,
+                        y: turbulenceConfig.velocity.y || 0,
+                    },
+                    velocityVariance: {
+                        x: turbulenceConfig.velocityVariance.x || 0,
+                        y: turbulenceConfig.velocityVariance.y || 0,
+                    },
+                    acceleration: {
+                        x: turbulenceConfig.acceleration.x || 0,
+                        y: turbulenceConfig.acceleration.y || 0,
+                    },
+                    accelerationVariance: {
+                        x: turbulenceConfig.accelerationVariance.x || 0,
+                        y: turbulenceConfig.accelerationVariance.y || 0,
+                    },
+                    name: 'PositionBehaviour',
+                },
+                {
+                    enabled: true,
+                    priority: 0,
+                    sizeStart: {
+                        x: turbulenceConfig.sizeStart.x || 1,
+                        y: turbulenceConfig.sizeStart.y || 1,
+                    },
+                    sizeEnd: {
+                        x: turbulenceConfig.sizeEnd.x || 1,
+                        y: turbulenceConfig.sizeEnd.y || 1,
+                    },
+                    startVariance: turbulenceConfig.startVariance || 0,
+                    endVariance: turbulenceConfig.endVariance || 0,
+                    name: 'SizeBehaviour',
+                },
+                {
+                    enabled: true,
+                    priority: 0,
+                    rotation: 12,
+                    variance: 0,
+                    name: 'RotationBehaviour',
+                },
+                {
+                    enabled: true,
+                    priority: 0,
+                    showVortices: turbulenceConfig.showVortices || false,
+                    turbulence: true,
+                    name: 'TurbulenceBehaviour',
+                },
+            ],
+            emitController: {
+                _maxParticles: 0,
+                _maxLife: 1,
+                _emitPerSecond: turbulenceConfig.emitPerSecond || 2,
+                _frames: 0,
+                name: 'UniformEmission',
+            },
+            duration: turbulenceConfig.duration || -1,
+        };
+        return config;
+    };
+    return Renderer;
+}());
+exports.default = Renderer;
 //# sourceMappingURL=Renderer.js.map