text: var pixi_display;
  (function (pixi_display) {
    Object.assign(PIXI.Container.prototype, {
      renderWebGL: function (renderer) {
        if (this._activeParentLayer && this._activeParentLayer != renderer._activeLayer) {
          return;
        }
        if (!this.visible) {
          this.displayOrder = 0;
          return;
        }
        this.displayOrder = renderer.incDisplayOrder();
        if (this.worldAlpha <= 0 || !this.renderable) {
          return;
        }
        this.containerRenderWebGL(renderer);
      },
      renderCanvas: function (renderer) {
        if (this._activeParentLayer && this._activeParentLayer != renderer._activeLayer) {
          return;
        }
        if (!this.visible) {
          this.displayOrder = 0;
          return;
        }
        this.displayOrder = renderer.incDisplayOrder();
        if (this.worldAlpha <= 0 || !this.renderable) {
          return;
        }
        this.containerRenderCanvas(renderer);
      },
      containerRenderWebGL: PIXI.Container.prototype.renderWebGL,
      containerRenderCanvas: PIXI.Container.prototype.renderCanvas
    });
  })(pixi_display || (pixi_display = {}));
  Object.assign(PIXI.DisplayObject.prototype, {
    parentLayer: null,
    _activeParentLayer: null,
    parentGroup: null,
    zOrder: 0,
    zIndex: 0,
    updateOrder: 0,
    displayOrder: 0,
    layerableChildren: true
  });
  if (PIXI.particles && PIXI.particles.ParticleContainer) {
    PIXI.particles.ParticleContainer.prototype.layerableChildren = false;
  }
  else if (PIXI.ParticleContainer) {
    PIXI.ParticleContainer.prototype.layerableChildren = false;
  }
  var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
      function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
  })();
  var pixi_display;
  (function (pixi_display) {
    var utils = PIXI.utils;
    var Group = (function (_super) {
      __extends(Group, _super);
      function Group(zIndex, sorting) {
        var _this = _super.call(this) || this;
        _this._activeLayer = null;
        _this._activeStage = null;
        _this._activeChildren = [];
        _this._lastUpdateId = -1;
        _this.useRenderTexture = false;
        _this.useDoubleBuffer = false;
        _this.sortPriority = 0;
        _this.clearColor = new Float32Array([0, 0, 0, 0]);
        _this.canDrawWithoutLayer = false;
        _this.canDrawInParentStage = true;
        _this.zIndex = 0;
        _this.enableSort = false;
        _this._tempResult = [];
        _this._tempZero = [];
        _this.useZeroOptimization = false;
        _this.zIndex = zIndex;
        _this.enableSort = !!sorting;
        if (typeof sorting === 'function') {
          _this.on('sort', sorting);
        }
        return _this;
      }
      Group.prototype.doSort = function (layer, sorted) {
        if (this.listeners('sort', true)) {
          for (var i = 0; i < sorted.length; i++) {
            this.emit('sort', sorted[i]);
          }
        }
        if (this.useZeroOptimization) {
          this.doSortWithZeroOptimization(layer, sorted);
        }
        else {
          sorted.sort(Group.compareZIndex);
        }
      };
      Group.compareZIndex = function (a, b) {
        if (a.zIndex !== b.zIndex) {
          return a.zIndex - b.zIndex;
        }
        if (a.zOrder > b.zOrder) {
          return -1;
        }
        if (a.zOrder < b.zOrder) {
          return 1;
        }
        return a.updateOrder - b.updateOrder;
      };
      Group.prototype.doSortWithZeroOptimization = function (layer, sorted) {
        throw new Error("not implemented yet");
      };
      Group.prototype.clear = function () {
        this._activeLayer = null;
        this._activeStage = null;
        this._activeChildren.length = 0;
      };
      Group.prototype.addDisplayObject = function (stage, displayObject) {
        this.check(stage);
        displayObject._activeParentLayer = this._activeLayer;
        if (this._activeLayer) {
          this._activeLayer._activeChildren.push(displayObject);
        }
        else {
          this._activeChildren.push(displayObject);
        }
      };
      Group.prototype.foundLayer = function (stage, layer) {
        this.check(stage);
        if (this._activeLayer != null) {
          Group.conflict();
        }
        this._activeLayer = layer;
        this._activeStage = stage;
      };
      Group.prototype.foundStage = function (stage) {
        if (!this._activeLayer && !this.canDrawInParentStage) {
          this.clear();
        }
      };
      Group.prototype.check = function (stage) {
        if (this._lastUpdateId < Group._layerUpdateId) {
          this._lastUpdateId = Group._layerUpdateId;
          this.clear();
          this._activeStage = stage;
        }
        else if (this.canDrawInParentStage) {
          var current = this._activeStage;
          while (current && current != stage) {
            current = current._activeParentStage;
          }
          this._activeStage = current;
          if (current == null) {
            this.clear();
            return;
          }
        }
      };
      Group.conflict = function () {
        if (Group._lastLayerConflict + 5000 < Date.now()) {
          Group._lastLayerConflict = Date.now();
          console.log("PIXI-display plugin found two layers with the same group in one stage - that's not healthy. Please place a breakpoint here and debug it");
        }
      };
      Group._layerUpdateId = 0;
      Group._lastLayerConflict = 0;
      return Group;
    }(utils.EventEmitter));
    pixi_display.Group = Group;
  })(pixi_display || (pixi_display = {}));
  var pixi_display;
  (function (pixi_display) {
    var InteractionManager = PIXI.interaction.InteractionManager;
    Object.assign(InteractionManager.prototype, {
      _queue: [[], []],
      _displayProcessInteractive: function (point, displayObject, hitTestOrder, interactive, outOfMask) {
        if (!displayObject || !displayObject.visible) {
          return 0;
        }
        var hit = 0, interactiveParent = interactive = displayObject.interactive || interactive;
        if (displayObject.hitArea) {
          interactiveParent = false;
        }
        if (displayObject._activeParentLayer) {
          outOfMask = false;
        }
        var mask = displayObject._mask;
        if (hitTestOrder < Infinity && mask) {
          if (!mask.containsPoint(point)) {
            outOfMask = true;
          }
        }
        if (hitTestOrder < Infinity && displayObject.filterArea) {
          if (!displayObject.filterArea.contains(point.x, point.y)) {
            outOfMask = true;
          }
        }
        var children = displayObject.children;
        if (displayObject.interactiveChildren && children) {
          for (var i = children.length - 1; i >= 0; i--) {
            var child = children[i];
            var hitChild = this._displayProcessInteractive(point, child, hitTestOrder, interactiveParent, outOfMask);
            if (hitChild) {
              if (!child.parent) {
                continue;
              }
              hit = hitChild;
              hitTestOrder = hitChild;
            }
          }
        }
        if (interactive) {
          if (!outOfMask) {
            if (hitTestOrder < displayObject.displayOrder) {
              if (displayObject.hitArea) {
                displayObject.worldTransform.applyInverse(point, this._tempPoint);
                if (displayObject.hitArea.contains(this._tempPoint.x, this._tempPoint.y)) {
                  hit = displayObject.displayOrder;
                }
              }
              else if (displayObject.containsPoint) {
                if (displayObject.containsPoint(point)) {
                  hit = displayObject.displayOrder;
                }
              }
            }
            if (displayObject.interactive) {
              this._queueAdd(displayObject, hit === Infinity ? 0 : hit);
            }
          }
          else {
            if (displayObject.interactive) {
              this._queueAdd(displayObject, 0);
            }
          }
        }
        return hit;
      },
      processInteractive: function (strangeStuff, displayObject, func, hitTest, interactive) {
        var interactionEvent = null;
        var point = null;
        if (strangeStuff.data &&
          strangeStuff.data.global) {
          interactionEvent = strangeStuff;
          point = interactionEvent.data.global;
        }
        else {
          point = strangeStuff;
        }
        this._startInteractionProcess();
        this._displayProcessInteractive(point, displayObject, hitTest ? 0 : Infinity, false);
        this._finishInteractionProcess(interactionEvent, func);
      },
      _startInteractionProcess: function () {
        this._eventDisplayOrder = 1;
        if (!this._queue) {
          this._queue = [[], []];
        }
        this._queue[0].length = 0;
        this._queue[1].length = 0;
      },
      _queueAdd: function (displayObject, order) {
        var queue = this._queue;
        if (order < this._eventDisplayOrder) {
          queue[0].push(displayObject);
        }
        else {
          if (order > this._eventDisplayOrder) {
            this._eventDisplayOrder = order;
            var q = queue[1];
            for (var i = 0; i < q.length; i++) {
              queue[0].push(q[i]);
            }
            queue[1].length = 0;
          }
          queue[1].push(displayObject);
        }
      },
      _finishInteractionProcess: function (event, func) {
        var queue = this._queue;
        var q = queue[0];
        var i = 0;
        for (; i < q.length; i++) {
          if (event) {
            if (func) {
              func(event, q[i], false);
            }
          }
          else {
            func(q[i], false);
          }
        }
        q = queue[1];
        for (i = 0; i < q.length; i++) {
          if (event) {
            if (!event.target) {
              event.target = q[i];
            }
            if (func) {
              func(event, q[i], true);
            }
          }
          else {
            func(q[i], true);
          }
        }
      }
    });
  })(pixi_display || (pixi_display = {}));
  var pixi_display;
  (function (pixi_display) {
    var LayerTextureCache = (function () {
      function LayerTextureCache(layer) {
        this.layer = layer;
        this.renderTexture = null;
        this.doubleBuffer = null;
        this.currentBufferIndex = 0;
        this._tempRenderTarget = null;
      }
      LayerTextureCache.prototype.initRenderTexture = function (renderer) {
        var width = renderer ? renderer.screen.width : 100;
        var height = renderer ? renderer.screen.height : 100;
        var resolution = renderer ? renderer.resolution : PIXI.settings.RESOLUTION;
        this.renderTexture = PIXI.RenderTexture.create(width, height, resolution);
        if (this.layer.group.useDoubleBuffer) {
          this.doubleBuffer = [
            PIXI.RenderTexture.create(width, height, resolution),
            PIXI.RenderTexture.create(width, height, resolution)
          ];
        }
      };
      LayerTextureCache.prototype.getRenderTexture = function () {
        if (!this.renderTexture) {
          this.initRenderTexture();
        }
        return this.renderTexture;
      };
      LayerTextureCache.prototype.pushTexture = function (renderer) {
        var screen = renderer.screen;
        if (!this.renderTexture) {
          this.initRenderTexture(renderer);
        }
        var rt = this.renderTexture;
        var group = this.layer.group;
        var db = this.doubleBuffer;
        if (rt.width !== screen.width ||
          rt.height !== screen.height ||
          rt.baseTexture.resolution !== renderer.resolution) {
          rt.baseTexture.resolution = renderer.resolution;
          rt.resize(screen.width, screen.height);
          if (db) {
            db[0].baseTexture.resolution = renderer.resolution;
            db[0].resize(screen.width, screen.height);
            db[1].baseTexture.resolution = renderer.resolution;
            db[1].resize(screen.width, screen.height);
          }
        }
        this._tempRenderTarget = renderer._activeRenderTarget;
        renderer.currentRenderer.flush();
        if (group.useDoubleBuffer) {
          var buffer = db[this.currentBufferIndex];
          if (!buffer.baseTexture._glTextures[renderer.CONTEXT_UID]) {
            renderer.bindRenderTexture(buffer, null);
            if (group.clearColor) {
              renderer.clear(group.clearColor);
            }
          }
          renderer.unbindTexture(rt);
          rt.baseTexture._glTextures = buffer.baseTexture._glTextures;
          rt.baseTexture._glRenderTargets = buffer.baseTexture._glRenderTargets;
          this.currentBufferIndex = 1 - this.currentBufferIndex;
          buffer = db[this.currentBufferIndex];
          renderer.bindRenderTexture(buffer, null);
        }
        else {
          renderer.bindRenderTexture(rt, undefined);
        }
        if (group.clearColor) {
          renderer.clear(group.clearColor);
        }
      };
      LayerTextureCache.prototype.popTexture = function (renderer) {
        renderer.currentRenderer.flush();
        renderer.bindRenderTarget(this._tempRenderTarget);
        this._tempRenderTarget = null;
      };
      LayerTextureCache.prototype.destroy = function () {
        if (this.renderTexture) {
          this.renderTexture.destroy();
          if (this.doubleBuffer) {
            this.doubleBuffer[0].destroy(true);
            this.doubleBuffer[1].destroy(true);
          }
        }
      };
      return LayerTextureCache;
    }());
    pixi_display.LayerTextureCache = LayerTextureCache;
    var Layer = (function (_super) {
      __extends(Layer, _super);
      function Layer(group) {
        if (group === void 0) { group = null; }
        var _this = _super.call(this) || this;
        _this.isLayer = true;
        _this.group = null;
        _this._activeChildren = [];
        _this._tempChildren = null;
        _this._activeStageParent = null;
        _this._sortedChildren = [];
        _this._tempLayerParent = null;
        _this.insertChildrenBeforeActive = true;
        _this.insertChildrenAfterActive = true;
        if (group != null) {
          _this.group = group;
          _this.zIndex = group.zIndex;
        }
        else {
          _this.group = new pixi_display.Group(0, false);
        }
        _this._tempChildren = _this.children;
        return _this;
      }
      Layer.prototype.beginWork = function (stage) {
        var active = this._activeChildren;
        this._activeStageParent = stage;
        this.group.foundLayer(stage, this);
        var groupChildren = this.group._activeChildren;
        active.length = 0;
        for (var i = 0; i < groupChildren.length; i++) {
          groupChildren[i]._activeParentLayer = this;
          active.push(groupChildren[i]);
        }
        groupChildren.length = 0;
      };
      Layer.prototype.endWork = function () {
        var children = this.children;
        var active = this._activeChildren;
        var sorted = this._sortedChildren;
        for (var i = 0; i < active.length; i++) {
          this.emit("display", active[i]);
        }
        sorted.length = 0;
        if (this.insertChildrenBeforeActive) {
          for (var i = 0; i < children.length; i++) {
            sorted.push(children[i]);
          }
        }
        for (var i = 0; i < active.length; i++) {
          sorted.push(active[i]);
        }
        if (!this.insertChildrenBeforeActive &&
          this.insertChildrenAfterActive) {
          for (var i = 0; i < children.length; i++) {
            sorted.push(children[i]);
          }
        }
        if (this.group.enableSort) {
          this.doSort();
        }
      };
      Object.defineProperty(Layer.prototype, "useRenderTexture", {
        get: function () {
          return this.group.useRenderTexture;
        },
        set: function (value) {
          this.group.useRenderTexture = value;
        },
        enumerable: true,
        configurable: true
      });
      Object.defineProperty(Layer.prototype, "useDoubleBuffer", {
        get: function () {
          return this.group.useDoubleBuffer;
        },
        set: function (value) {
          this.group.useDoubleBuffer = value;
        },
        enumerable: true,
        configurable: true
      });
      Object.defineProperty(Layer.prototype, "clearColor", {
        get: function () {
          return this.group.clearColor;
        },
        set: function (value) {
          this.group.clearColor = value;
        },
        enumerable: true,
        configurable: true
      });
      Object.defineProperty(Layer.prototype, "sortPriority", {
        get: function () {
          return this.group.sortPriority;
        },
        set: function (value) {
          this.group.sortPriority = value;
        },
        enumerable: true,
        configurable: true
      });
      Layer.prototype.getRenderTexture = function () {
        if (!this.textureCache) {
          this.textureCache = new LayerTextureCache(this);
        }
        return this.textureCache.getRenderTexture();
      };
      Layer.prototype.updateDisplayLayers = function () {
      };
      Layer.prototype.doSort = function () {
        this.group.doSort(this, this._sortedChildren);
      };
      Layer.prototype._preRender = function (renderer) {
        if (this._activeParentLayer && this._activeParentLayer != renderer._activeLayer) {
          return false;
        }
        if (!this.visible) {
          this.displayOrder = 0;
          return false;
        }
        this.displayOrder = renderer.incDisplayOrder();
        if (this.worldAlpha <= 0 || !this.renderable) {
          return false;
        }
        if (this.children !== this._sortedChildren &&
          this._tempChildren != this.children) {
          this._tempChildren = this.children;
        }
        this._boundsID++;
        this.children = this._sortedChildren;
        this._tempLayerParent = renderer._activeLayer;
        renderer._activeLayer = this;
        return true;
      };
      Layer.prototype._postRender = function (renderer) {
        this.children = this._tempChildren;
        renderer._activeLayer = this._tempLayerParent;
        this._tempLayerParent = null;
      };
      Layer.prototype.renderWebGL = function (renderer) {
        if (!this._preRender(renderer)) {
          return;
        }
        if (this.group.useRenderTexture) {
          if (!this.textureCache) {
            this.textureCache = new LayerTextureCache(this);
          }
          this.textureCache.pushTexture(renderer);
        }
        this.containerRenderWebGL(renderer);
        this._postRender(renderer);
        if (this.group.useRenderTexture) {
          this.textureCache.popTexture(renderer);
        }
      };
      Layer.prototype.renderCanvas = function (renderer) {
        if (this._preRender(renderer)) {
          this.containerRenderCanvas(renderer);
          this._postRender(renderer);
        }
      };
      Layer.prototype.destroy = function (options) {
        if (this.textureCache) {
          this.textureCache.destroy();
          this.textureCache = null;
        }
        _super.prototype.destroy.call(this, options);
      };
      return Layer;
    }(PIXI.Container));
    pixi_display.Layer = Layer;
  })(pixi_display || (pixi_display = {}));
  var pixi_display;
  (function (pixi_display) {
    var Stage = (function (_super) {
      __extends(Stage, _super);
      function Stage() {
        var _this = _super.call(this) || this;
        _this.isStage = true;
        _this._tempGroups = [];
        _this._activeLayers = [];
        _this._activeParentStage = null;
        return _this;
      }
      Stage.prototype.clear = function () {
        this._activeLayers.length = 0;
        this._tempGroups.length = 0;
      };
      Stage.prototype.destroy = function (options) {
        this.clear();
        _super.prototype.destroy.call(this, options);
      };
      Stage.prototype._addRecursive = function (displayObject) {
        if (!displayObject.visible) {
          return;
        }
        if (displayObject.isLayer) {
          var layer_1 = displayObject;
          this._activeLayers.push(layer_1);
          layer_1.beginWork(this);
        }
        if (displayObject != this && displayObject.isStage) {
          var stage = displayObject;
          stage.updateAsChildStage(this);
          return;
        }
        var group = displayObject.parentGroup;
        if (group !== null) {
          group.addDisplayObject(this, displayObject);
        }
        var layer = displayObject.parentLayer;
        if (layer !== null) {
          group = layer.group;
          group.addDisplayObject(this, displayObject);
        }
        displayObject.updateOrder = ++Stage._updateOrderCounter;
        if (displayObject.alpha <= 0 || !displayObject.renderable
          || !displayObject.layerableChildren
          || group && group.sortPriority) {
          return;
        }
        var children = displayObject.children;
        if (children && children.length) {
          for (var i = 0; i < children.length; i++) {
            this._addRecursive(children[i]);
          }
        }
      };
      Stage.prototype._addRecursiveChildren = function (displayObject) {
        if (displayObject.alpha <= 0 || !displayObject.renderable
          || !displayObject.layerableChildren) {
          return;
        }
        var children = displayObject.children;
        if (children && children.length) {
          for (var i = 0; i < children.length; i++) {
            this._addRecursive(children[i]);
          }
        }
      };
      Stage.prototype._updateStageInner = function () {
        this.clear();
        this._addRecursive(this);
        var layers = this._activeLayers;
        for (var i = 0; i < layers.length; i++) {
          var layer = layers[i];
          if (layer.group.sortPriority) {
            layer.endWork();
            var sorted = layer._sortedChildren;
            for (var j = 0; j < sorted.length; j++) {
              this._addRecursiveChildren(sorted[j]);
            }
          }
        }
        for (var i = 0; i < layers.length; i++) {
          var layer = layers[i];
          if (!layer.group.sortPriority) {
            layer.endWork();
          }
        }
      };
      Stage.prototype.updateAsChildStage = function (stage) {
        this._activeParentStage = stage;
        Stage._updateOrderCounter = 0;
        this._updateStageInner();
      };
      Stage.prototype.updateStage = function () {
        this._activeParentStage = null;
        pixi_display.Group._layerUpdateId++;
        this._updateStageInner();
      };
      ;
      Stage._updateOrderCounter = 0;
      return Stage;
    }(pixi_display.Layer));
    pixi_display.Stage = Stage;
  })(pixi_display || (pixi_display = {}));
  var pixi_display;
  (function (pixi_display) {
    Object.assign(PIXI.WebGLRenderer.prototype, {
      _lastDisplayOrder: 0,
      _activeLayer: null,
      incDisplayOrder: function () {
        return ++this._lastDisplayOrder;
      },
      _oldRender: PIXI.WebGLRenderer.prototype.render,
      render: function (displayObject, renderTexture, clear, transform, skipUpdateTransform) {
        if (!renderTexture) {
          this._lastDisplayOrder = 0;
        }
        this._activeLayer = null;
        if (displayObject.isStage) {
          displayObject.updateStage();
        }
        this._oldRender(displayObject, renderTexture, clear, transform, skipUpdateTransform);
      }
    });
    Object.assign(PIXI.CanvasRenderer.prototype, {
      _lastDisplayOrder: 0,
      _activeLayer: null,
      incDisplayOrder: function () {
        return ++this._lastDisplayOrder;
      },
      _oldRender: PIXI.CanvasRenderer.prototype.render,
      render: function (displayObject, renderTexture, clear, transform, skipUpdateTransform) {
        if (!renderTexture) {
          this._lastDisplayOrder = 0;
        }
        this._activeLayer = null;
        if (displayObject.isStage) {
          displayObject.updateStage();
        }
        this._oldRender(displayObject, renderTexture, clear, transform, skipUpdateTransform);
      }
    });
  })(pixi_display || (pixi_display = {}));
  var pixi_display;
  (function (pixi_display) {
    PIXI.display = pixi_display;
  })(pixi_display || (pixi_display = {}));
  //# sourceMappingURL=pixi-layers.js.map
  