new design/draft_offers_modal_design/user/pixi/pixi-layers.js
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