428 lines
22 KiB
JavaScript
428 lines
22 KiB
JavaScript
var __extends = (this && this.__extends) || function (d, b) {
|
|
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
var shaderLib = [
|
|
{
|
|
vertUniforms: "",
|
|
vertCode: "vTextureCoord = aTextureCoord;",
|
|
fragUniforms: "uniform vec4 uTextureClamp;",
|
|
fragCode: "vec2 textureCoord = clamp(vTextureCoord, uTextureClamp.xy, uTextureClamp.zw);"
|
|
},
|
|
{
|
|
vertUniforms: "uniform mat3 uTransform;",
|
|
vertCode: "vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;",
|
|
fragUniforms: "",
|
|
fragCode: "vec2 textureCoord = vTextureCoord;"
|
|
},
|
|
{
|
|
vertUniforms: "uniform mat3 uTransform;",
|
|
vertCode: "vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;",
|
|
fragUniforms: "uniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;",
|
|
fragCode: "vec2 textureCoord = mod(vTextureCoord - uClampOffset, vec2(1.0, 1.0)) + uClampOffset;" +
|
|
"\ntextureCoord = (uMapCoord * vec3(textureCoord, 1.0)).xy;" +
|
|
"\ntextureCoord = clamp(textureCoord, uClampFrame.xy, uClampFrame.zw);"
|
|
}
|
|
];
|
|
var PictureShader = (function (_super) {
|
|
__extends(PictureShader, _super);
|
|
function PictureShader(gl, vert, frag, tilingMode) {
|
|
var lib = shaderLib[tilingMode];
|
|
_super.call(this, gl, vert.replace(/%SPRITE_UNIFORMS%/gi, lib.vertUniforms)
|
|
.replace(/%SPRITE_CODE%/gi, lib.vertCode), frag.replace(/%SPRITE_UNIFORMS%/gi, lib.fragUniforms)
|
|
.replace(/%SPRITE_CODE%/gi, lib.fragCode));
|
|
this.bind();
|
|
this.tilingMode = tilingMode;
|
|
this.tempQuad = new PIXI.Quad(gl);
|
|
this.tempQuad.initVao(this);
|
|
this.uniforms.uColor = new Float32Array([1, 1, 1, 1]);
|
|
this.uniforms.uSampler = [0, 1];
|
|
}
|
|
PictureShader.blendVert = "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\n\nuniform mat3 projectionMatrix;\nuniform mat3 mapMatrix;\n\nvarying vec2 vTextureCoord;\nvarying vec2 vMapCoord;\n%SPRITE_UNIFORMS%\n\nvoid main(void)\n{\n gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n %SPRITE_CODE%\n vMapCoord = (mapMatrix * vec3(aVertexPosition, 1.0)).xy;\n}\n";
|
|
return PictureShader;
|
|
}(PIXI.Shader));
|
|
extras.PictureShader = PictureShader;
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
var overlayFrag = "\nvarying vec2 vTextureCoord;\nvarying vec2 vMapCoord;\nvarying vec4 vColor;\n\nuniform sampler2D uSampler[2];\nuniform vec4 uColor;\n%SPRITE_UNIFORMS%\n\nvoid main(void)\n{\n %SPRITE_CODE%\n vec4 source = texture2D(uSampler[0], textureCoord) * uColor;\n vec4 target = texture2D(uSampler[1], vMapCoord);\n\n //reverse hardlight\n if (source.a == 0.0) {\n gl_FragColor = vec4(0, 0, 0, 0);\n return;\n }\n //yeah, premultiplied\n vec3 Cb = source.rgb/source.a, Cs;\n if (target.a > 0.0) {\n Cs = target.rgb / target.a;\n }\n vec3 multiply = Cb * Cs * 2.0;\n vec3 Cs2 = Cs * 2.0 - 1.0;\n vec3 screen = Cb + Cs2 - Cb * Cs2;\n vec3 B;\n if (Cb.r <= 0.5) {\n B.r = multiply.r;\n } else {\n B.r = screen.r;\n }\n if (Cb.g <= 0.5) {\n B.g = multiply.g;\n } else {\n B.g = screen.g;\n }\n if (Cb.b <= 0.5) {\n B.b = multiply.b;\n } else {\n B.b = screen.b;\n }\n vec4 res;\n res.xyz = (1.0 - source.a) * Cs + source.a * B;\n res.a = source.a + target.a * (1.0-source.a);\n gl_FragColor = vec4(res.xyz * res.a, res.a);\n}\n";
|
|
var HardLightShader = (function (_super) {
|
|
__extends(HardLightShader, _super);
|
|
function HardLightShader(gl, tilingMode) {
|
|
_super.call(this, gl, extras.PictureShader.blendVert, overlayFrag, tilingMode);
|
|
}
|
|
return HardLightShader;
|
|
}(extras.PictureShader));
|
|
extras.HardLightShader = HardLightShader;
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
function mapFilterBlendModesToPixi(gl, array) {
|
|
if (array === void 0) { array = []; }
|
|
array[PIXI.BLEND_MODES.OVERLAY] = [new extras.OverlayShader(gl, 0), new extras.OverlayShader(gl, 1), new extras.OverlayShader(gl, 2)];
|
|
array[PIXI.BLEND_MODES.HARD_LIGHT] = [new extras.HardLightShader(gl, 0), new extras.HardLightShader(gl, 1), new extras.HardLightShader(gl, 2)];
|
|
return array;
|
|
}
|
|
extras.mapFilterBlendModesToPixi = mapFilterBlendModesToPixi;
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
var normalFrag = "\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform sampler2D uSampler[2];\nuniform vec4 uColor;\n%SPRITE_UNIFORMS%\n\nvoid main(void)\n{\n %SPRITE_CODE%\n\n vec4 sample = texture2D(uSampler[0], textureCoord);\n gl_FragColor = sample * uColor;\n}\n";
|
|
var normalVert = "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n%SPRITE_UNIFORMS%\n\nvoid main(void)\n{\n gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n %SPRITE_CODE%\n}\n";
|
|
var NormalShader = (function (_super) {
|
|
__extends(NormalShader, _super);
|
|
function NormalShader(gl, tilingMode) {
|
|
_super.call(this, gl, normalVert, normalFrag, tilingMode);
|
|
}
|
|
return NormalShader;
|
|
}(extras.PictureShader));
|
|
extras.NormalShader = NormalShader;
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
var overlayFrag = "\nvarying vec2 vTextureCoord;\nvarying vec2 vMapCoord;\nvarying vec4 vColor;\n\nuniform sampler2D uSampler[2];\nuniform vec4 uColor;\n%SPRITE_UNIFORMS%\n\nvoid main(void)\n{\n %SPRITE_CODE%\n vec4 source = texture2D(uSampler[0], textureCoord) * uColor;\n vec4 target = texture2D(uSampler[1], vMapCoord);\n\n //reverse hardlight\n if (source.a == 0.0) {\n gl_FragColor = vec4(0, 0, 0, 0);\n return;\n }\n //yeah, premultiplied\n vec3 Cb = source.rgb/source.a, Cs;\n if (target.a > 0.0) {\n Cs = target.rgb / target.a;\n }\n vec3 multiply = Cb * Cs * 2.0;\n vec3 Cb2 = Cb * 2.0 - 1.0;\n vec3 screen = Cb2 + Cs - Cb2 * Cs;\n vec3 B;\n if (Cs.r <= 0.5) {\n B.r = multiply.r;\n } else {\n B.r = screen.r;\n }\n if (Cs.g <= 0.5) {\n B.g = multiply.g;\n } else {\n B.g = screen.g;\n }\n if (Cs.b <= 0.5) {\n B.b = multiply.b;\n } else {\n B.b = screen.b;\n }\n vec4 res;\n res.xyz = (1.0 - source.a) * Cs + source.a * B;\n res.a = source.a + target.a * (1.0-source.a);\n gl_FragColor = vec4(res.xyz * res.a, res.a);\n}\n";
|
|
var OverlayShader = (function (_super) {
|
|
__extends(OverlayShader, _super);
|
|
function OverlayShader(gl, tilingMode) {
|
|
_super.call(this, gl, extras.PictureShader.blendVert, overlayFrag, tilingMode);
|
|
}
|
|
return OverlayShader;
|
|
}(extras.PictureShader));
|
|
extras.OverlayShader = OverlayShader;
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
function nextPow2(v) {
|
|
v += (v === 0) ? 1 : 0;
|
|
--v;
|
|
v |= v >>> 1;
|
|
v |= v >>> 2;
|
|
v |= v >>> 4;
|
|
v |= v >>> 8;
|
|
v |= v >>> 16;
|
|
return v + 1;
|
|
}
|
|
var PictureRenderer = (function (_super) {
|
|
__extends(PictureRenderer, _super);
|
|
function PictureRenderer(renderer) {
|
|
_super.call(this, renderer);
|
|
}
|
|
PictureRenderer.prototype.onContextChange = function () {
|
|
var gl = this.renderer.gl;
|
|
this.drawModes = extras.mapFilterBlendModesToPixi(gl);
|
|
this.normalShader = [new extras.NormalShader(gl, 0), new extras.NormalShader(gl, 1), new extras.NormalShader(gl, 2)];
|
|
this._tempClamp = new Float32Array(4);
|
|
this._tempColor = new Float32Array(4);
|
|
this._tempRect = new PIXI.Rectangle();
|
|
this._tempRect2 = new PIXI.Rectangle();
|
|
this._tempRect3 = new PIXI.Rectangle();
|
|
this._tempMatrix = new PIXI.Matrix();
|
|
this._tempMatrix2 = new PIXI.Matrix();
|
|
this._bigBuf = new Uint8Array(1 << 20);
|
|
this._renderTexture = new PIXI.BaseRenderTexture(1024, 1024);
|
|
};
|
|
PictureRenderer.prototype.start = function () {
|
|
};
|
|
PictureRenderer.prototype.flush = function () {
|
|
};
|
|
PictureRenderer.prototype._getRenderTexture = function (minWidth, minHeight) {
|
|
if (this._renderTexture.width < minWidth ||
|
|
this._renderTexture.height < minHeight) {
|
|
minHeight = nextPow2(minWidth);
|
|
minHeight = nextPow2(minHeight);
|
|
this._renderTexture.resize(minWidth, minHeight);
|
|
}
|
|
return this._renderTexture;
|
|
};
|
|
PictureRenderer.prototype._getBuf = function (size) {
|
|
var buf = this._bigBuf;
|
|
if (buf.length < size) {
|
|
size = nextPow2(size);
|
|
buf = new Uint8Array(size);
|
|
this._bigBuf = buf;
|
|
}
|
|
return buf;
|
|
};
|
|
PictureRenderer.prototype.render = function (sprite) {
|
|
if (!sprite.texture.valid) {
|
|
return;
|
|
}
|
|
var tilingMode = 0;
|
|
if (sprite.tileTransform) {
|
|
tilingMode = this._isSimpleSprite(sprite) ? 1 : 2;
|
|
}
|
|
var blendShader = this.drawModes[sprite.blendMode];
|
|
if (blendShader) {
|
|
this._renderBlend(sprite, blendShader[tilingMode]);
|
|
}
|
|
else {
|
|
this._renderNormal(sprite, this.normalShader[tilingMode]);
|
|
}
|
|
};
|
|
PictureRenderer.prototype._renderNormal = function (sprite, shader) {
|
|
var renderer = this.renderer;
|
|
renderer.bindShader(shader);
|
|
renderer.state.setBlendMode(sprite.blendMode);
|
|
this._renderInner(sprite, shader);
|
|
};
|
|
PictureRenderer.prototype._renderBlend = function (sprite, shader) {
|
|
var renderer = this.renderer;
|
|
var spriteBounds = sprite.getBounds();
|
|
var renderTarget = renderer._activeRenderTarget;
|
|
var matrix = renderTarget.projectionMatrix;
|
|
var flipX = matrix.a < 0;
|
|
var flipY = matrix.d < 0;
|
|
var resolution = renderTarget.resolution;
|
|
var screen = this._tempRect;
|
|
var fr = renderTarget.sourceFrame || renderTarget.destinationFrame;
|
|
screen.x = 0;
|
|
screen.y = 0;
|
|
screen.width = fr.width;
|
|
screen.height = fr.height;
|
|
var bounds = this._tempRect2;
|
|
var fbw = fr.width * resolution, fbh = fr.height * resolution;
|
|
bounds.x = (spriteBounds.x + matrix.tx / matrix.a) * resolution + fbw / 2;
|
|
bounds.y = (spriteBounds.y + matrix.ty / matrix.d) * resolution + fbh / 2;
|
|
bounds.width = spriteBounds.width * resolution;
|
|
bounds.height = spriteBounds.height * resolution;
|
|
if (flipX) {
|
|
bounds.y = fbw - bounds.width - bounds.x;
|
|
}
|
|
if (flipY) {
|
|
bounds.y = fbh - bounds.height - bounds.y;
|
|
}
|
|
var screenBounds = this._tempRect3;
|
|
var x_1 = Math.floor(Math.max(screen.x, bounds.x));
|
|
var x_2 = Math.ceil(Math.min(screen.x + screen.width, bounds.x + bounds.width));
|
|
var y_1 = Math.floor(Math.max(screen.y, bounds.y));
|
|
var y_2 = Math.ceil(Math.min(screen.y + screen.height, bounds.y + bounds.height));
|
|
var pixelsWidth = x_2 - x_1;
|
|
var pixelsHeight = y_2 - y_1;
|
|
if (pixelsWidth <= 0 || pixelsHeight <= 0) {
|
|
return;
|
|
}
|
|
var rt = this._getRenderTexture(pixelsWidth, pixelsHeight);
|
|
renderer.bindTexture(rt, 1, true);
|
|
var gl = renderer.gl;
|
|
if (renderer.renderingToScreen && renderTarget.root) {
|
|
var buf = this._getBuf(pixelsWidth * pixelsHeight * 4);
|
|
gl.readPixels(x_1, y_1, pixelsWidth, pixelsHeight, gl.RGBA, gl.UNSIGNED_BYTE, this._bigBuf);
|
|
gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, pixelsWidth, pixelsHeight, gl.RGBA, gl.UNSIGNED_BYTE, this._bigBuf);
|
|
}
|
|
else {
|
|
gl.copyTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, x_1, y_1, pixelsWidth, pixelsHeight);
|
|
}
|
|
renderer.bindShader(shader);
|
|
renderer.state.setBlendMode(PIXI.BLEND_MODES.NORMAL);
|
|
if (shader.uniforms.mapMatrix) {
|
|
var mapMatrix = this._tempMatrix;
|
|
mapMatrix.a = bounds.width / rt.width / spriteBounds.width;
|
|
if (flipX) {
|
|
mapMatrix.a = -mapMatrix.a;
|
|
mapMatrix.tx = (bounds.x - x_1) / rt.width - (spriteBounds.x + spriteBounds.width) * mapMatrix.a;
|
|
}
|
|
else {
|
|
mapMatrix.tx = (bounds.x - x_1) / rt.width - spriteBounds.x * mapMatrix.a;
|
|
}
|
|
mapMatrix.d = bounds.height / rt.height / spriteBounds.height;
|
|
if (flipY) {
|
|
mapMatrix.d = -mapMatrix.d;
|
|
mapMatrix.ty = (bounds.y - y_1) / rt.height - (spriteBounds.y + spriteBounds.height) * mapMatrix.d;
|
|
}
|
|
else {
|
|
mapMatrix.ty = (bounds.y - y_1) / rt.height - spriteBounds.y * mapMatrix.d;
|
|
}
|
|
shader.uniforms.mapMatrix = mapMatrix.toArray(true);
|
|
}
|
|
this._renderInner(sprite, shader);
|
|
};
|
|
PictureRenderer.prototype._renderInner = function (sprite, shader) {
|
|
var renderer = this.renderer;
|
|
if (shader.tilingMode > 0) {
|
|
this._renderWithShader(sprite, shader.tilingMode === 1, shader);
|
|
}
|
|
else {
|
|
this._renderSprite(sprite, shader);
|
|
}
|
|
};
|
|
PictureRenderer.prototype._renderWithShader = function (ts, isSimple, shader) {
|
|
var quad = shader.tempQuad;
|
|
var renderer = this.renderer;
|
|
renderer.bindVao(quad.vao);
|
|
var vertices = quad.vertices;
|
|
var _width = ts._width;
|
|
var _height = ts._height;
|
|
var _anchorX = ts._anchor._x;
|
|
var _anchorY = ts._anchor._y;
|
|
var w0 = _width * (1 - _anchorX);
|
|
var w1 = _width * -_anchorX;
|
|
var h0 = _height * (1 - _anchorY);
|
|
var h1 = _height * -_anchorY;
|
|
var wt = ts.transform.worldTransform;
|
|
var a = wt.a;
|
|
var b = wt.b;
|
|
var c = wt.c;
|
|
var d = wt.d;
|
|
var tx = wt.tx;
|
|
var ty = wt.ty;
|
|
vertices[0] = (a * w1) + (c * h1) + tx;
|
|
vertices[1] = (d * h1) + (b * w1) + ty;
|
|
vertices[2] = (a * w0) + (c * h1) + tx;
|
|
vertices[3] = (d * h1) + (b * w0) + ty;
|
|
vertices[4] = (a * w0) + (c * h0) + tx;
|
|
vertices[5] = (d * h0) + (b * w0) + ty;
|
|
vertices[6] = (a * w1) + (c * h0) + tx;
|
|
vertices[7] = (d * h0) + (b * w1) + ty;
|
|
vertices = quad.uvs;
|
|
vertices[0] = vertices[6] = -ts.anchor.x;
|
|
vertices[1] = vertices[3] = -ts.anchor.y;
|
|
vertices[2] = vertices[4] = 1.0 - ts.anchor.x;
|
|
vertices[5] = vertices[7] = 1.0 - ts.anchor.y;
|
|
quad.upload();
|
|
var tex = ts._texture;
|
|
var lt = ts.tileTransform.localTransform;
|
|
var uv = ts.uvTransform;
|
|
var mapCoord = uv.mapCoord;
|
|
var uClampFrame = uv.uClampFrame;
|
|
var uClampOffset = uv.uClampOffset;
|
|
var w = tex.width;
|
|
var h = tex.height;
|
|
var W = _width;
|
|
var H = _height;
|
|
var tempMat = this._tempMatrix2;
|
|
tempMat.set(lt.a * w / W, lt.b * w / H, lt.c * h / W, lt.d * h / H, lt.tx / W, lt.ty / H);
|
|
tempMat.invert();
|
|
if (isSimple) {
|
|
tempMat.append(mapCoord);
|
|
}
|
|
else {
|
|
shader.uniforms.uMapCoord = mapCoord.toArray(true);
|
|
shader.uniforms.uClampFrame = uClampFrame;
|
|
shader.uniforms.uClampOffset = uClampOffset;
|
|
}
|
|
shader.uniforms.uTransform = tempMat.toArray(true);
|
|
var color = this._tempColor;
|
|
var alpha = ts.worldAlpha;
|
|
PIXI.utils.hex2rgb(ts.tint, color);
|
|
color[0] *= alpha;
|
|
color[1] *= alpha;
|
|
color[2] *= alpha;
|
|
color[3] = alpha;
|
|
shader.uniforms.uColor = color;
|
|
renderer.bindTexture(tex, 0, true);
|
|
quad.vao.draw(this.renderer.gl.TRIANGLES, 6, 0);
|
|
};
|
|
PictureRenderer.prototype._renderSprite = function (sprite, shader) {
|
|
var renderer = this.renderer;
|
|
var quad = shader.tempQuad;
|
|
renderer.bindVao(quad.vao);
|
|
var uvs = sprite.texture._uvs;
|
|
var vertices = quad.vertices;
|
|
var vd = sprite.vertexData;
|
|
for (var i = 0; i < 8; i++) {
|
|
quad.vertices[i] = vd[i];
|
|
}
|
|
quad.uvs[0] = uvs.x0;
|
|
quad.uvs[1] = uvs.y0;
|
|
quad.uvs[2] = uvs.x1;
|
|
quad.uvs[3] = uvs.y1;
|
|
quad.uvs[4] = uvs.x2;
|
|
quad.uvs[5] = uvs.y2;
|
|
quad.uvs[6] = uvs.x3;
|
|
quad.uvs[7] = uvs.y3;
|
|
quad.upload();
|
|
var frame = sprite.texture.frame;
|
|
var base = sprite.texture.baseTexture;
|
|
var clamp = this._tempClamp;
|
|
var eps = 0.5 / base.resolution;
|
|
clamp[0] = (frame.x + eps) / base.width;
|
|
clamp[1] = (frame.y + eps) / base.height;
|
|
clamp[2] = (frame.x + frame.width - eps) / base.width;
|
|
clamp[3] = (frame.y + frame.height - eps) / base.height;
|
|
shader.uniforms.uTextureClamp = clamp;
|
|
var color = this._tempColor;
|
|
PIXI.utils.hex2rgb(sprite.tint, color);
|
|
var alpha = sprite.worldAlpha;
|
|
color[0] *= alpha;
|
|
color[1] *= alpha;
|
|
color[2] *= alpha;
|
|
color[3] = alpha;
|
|
shader.uniforms.uColor = color;
|
|
renderer.bindTexture(base, 0, true);
|
|
quad.vao.draw(this.renderer.gl.TRIANGLES, 6, 0);
|
|
};
|
|
PictureRenderer.prototype._isSimpleSprite = function (ts) {
|
|
var renderer = this.renderer;
|
|
var tex = ts._texture;
|
|
var baseTex = tex.baseTexture;
|
|
var isSimple = baseTex.isPowerOfTwo && tex.frame.width === baseTex.width && tex.frame.height === baseTex.height;
|
|
if (isSimple) {
|
|
if (!baseTex._glTextures[renderer.CONTEXT_UID]) {
|
|
if (baseTex.wrapMode === PIXI.WRAP_MODES.CLAMP) {
|
|
baseTex.wrapMode = PIXI.WRAP_MODES.REPEAT;
|
|
}
|
|
}
|
|
else {
|
|
isSimple = baseTex.wrapMode !== PIXI.WRAP_MODES.CLAMP;
|
|
}
|
|
}
|
|
return isSimple;
|
|
};
|
|
return PictureRenderer;
|
|
}(PIXI.ObjectRenderer));
|
|
extras.PictureRenderer = PictureRenderer;
|
|
PIXI.WebGLRenderer.registerPlugin('picture', PictureRenderer);
|
|
PIXI.CanvasRenderer.registerPlugin('picture', PIXI.CanvasSpriteRenderer);
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
var PictureSprite = (function (_super) {
|
|
__extends(PictureSprite, _super);
|
|
function PictureSprite(texture) {
|
|
_super.call(this, texture);
|
|
this.pluginName = 'picture';
|
|
}
|
|
return PictureSprite;
|
|
}(PIXI.Sprite));
|
|
extras.PictureSprite = PictureSprite;
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
var PIXI;
|
|
(function (PIXI) {
|
|
var extras;
|
|
(function (extras) {
|
|
var PictureTilingSprite = (function (_super) {
|
|
__extends(PictureTilingSprite, _super);
|
|
function PictureTilingSprite(texture) {
|
|
_super.call(this, texture);
|
|
this.pluginName = 'picture';
|
|
}
|
|
return PictureTilingSprite;
|
|
}(extras.TilingSprite));
|
|
extras.PictureTilingSprite = PictureTilingSprite;
|
|
})(extras = PIXI.extras || (PIXI.extras = {}));
|
|
})(PIXI || (PIXI = {}));
|
|
//# sourceMappingURL=pixi-picture.js.map
|