IWMBrowser/iwmlib
4
0
Fork 0
Code Issues 6 Pull Requests Releases Wiki Activity

Added icons.

Browse Source
This commit is contained in:
Sebastian Kupke
2019-04-11 11:28:43 +02:00
parent 1fbbbbe9a9
commit d2fc9820b2
965 changed files with 244 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dist/iwmlib.3rdparty.js
Vendored
+223 -197
View File
@@ -70535,8 +70535,8 @@ var __filters=function(e,t){"use strict";var n="attribute vec2 aVertexPosition;\
//# sourceMappingURL=pixi-filters.js.map
/*!
* pixi-particles - v4.0.1
* Compiled Wed, 13 Mar 2019 00:29:53 UTC
* pixi-particles - v4.1.0
* Compiled Tue, 09 Apr 2019 13:12:08 UTC
*
* pixi-particles is licensed under the MIT License.
* http://www.opensource.org/licenses/mit-license
@@ -70555,7 +70555,7 @@ this.PIXI = this.PIXI || {};
* @param [ease] Custom ease for this list. Only relevant for the first node.
*/
function PropertyNode(value, time, ease) {
this.value = typeof value == "string" ? exports.ParticleUtils.hexToRGB(value) : value;
this.value = value;
this.time = time;
this.next = null;
this.isStepped = false;
@@ -70577,14 +70577,16 @@ this.PIXI = this.PIXI || {};
* @return The first node in the list
*/
PropertyNode.createList = function (data) {
if (Array.isArray(data.list)) {
if ("list" in data) {
var array = data.list;
var node = void 0, first = void 0;
first = node = new PropertyNode(array[0].value, array[0].time, data.ease);
var _a = array[0], value = _a.value, time = _a.time;
first = node = new PropertyNode(typeof value === 'string' ? exports.ParticleUtils.hexToRGB(value) : value, time, data.ease);
//only set up subsequent nodes if there are a bunch or the 2nd one is different from the first
if (array.length > 2 || (array.length === 2 && array[1].value !== array[0].value)) {
if (array.length > 2 || (array.length === 2 && array[1].value !== value)) {
for (var i = 1; i < array.length; ++i) {
node.next = new PropertyNode(array[i].value, array[i].time);
var _b = array[i], value_1 = _b.value, time_1 = _b.time;
node.next = new PropertyNode(typeof value_1 === 'string' ? exports.ParticleUtils.hexToRGB(value_1) : value_1, time_1);
node = node.next;
}
}
@@ -70593,10 +70595,10 @@ this.PIXI = this.PIXI || {};
}
else {
//Handle deprecated version here
var start = new PropertyNode(data.start, 0);
var start = new PropertyNode(typeof data.start === 'string' ? exports.ParticleUtils.hexToRGB(data.start) : data.start, 0);
//only set up a next value if it is different from the starting value
if (data.end !== data.start)
start.next = new PropertyNode(data.end, 1);
start.next = new PropertyNode(typeof data.end === 'string' ? exports.ParticleUtils.hexToRGB(data.end) : data.end, 1);
return start;
}
};
@@ -70746,7 +70748,7 @@ this.PIXI = this.PIXI || {};
if (numSteps === void 0) { numSteps = 10; }
if (typeof numSteps !== 'number' || numSteps <= 0)
numSteps = 10;
var first = new PropertyNode(list[0].value, list[0].time);
var first = new PropertyNode(ParticleUtils.hexToRGB(list[0].value), list[0].time);
first.isStepped = true;
var currentNode = first;
var current = list[0];
@@ -70763,10 +70765,11 @@ this.PIXI = this.PIXI || {};
lerp = (lerp - current.time) / (next.time - current.time);
var curVal = ParticleUtils.hexToRGB(current.value);
var nextVal = ParticleUtils.hexToRGB(next.value);
var output = {};
output.r = (nextVal.r - curVal.r) * lerp + curVal.r;
output.g = (nextVal.g - curVal.g) * lerp + curVal.g;
output.b = (nextVal.b - curVal.b) * lerp + curVal.b;
var output = {
r: (nextVal.r - curVal.r) * lerp + curVal.r,
g: (nextVal.g - curVal.g) * lerp + curVal.g,
b: (nextVal.b - curVal.b) * lerp + curVal.b,
};
currentNode.next = new PropertyNode(output, i / numSteps);
currentNode = currentNode.next;
}
@@ -71083,6 +71086,8 @@ this.PIXI = this.PIXI || {};
//particles should be centered
_this.anchor.x = _this.anchor.y = 0.5;
_this.velocity = new pixi.Point();
_this.rotationSpeed = 0;
_this.rotationAcceleration = 0;
_this.maxLife = 0;
_this.age = 0;
_this.ease = null;
@@ -71135,6 +71140,7 @@ this.PIXI = this.PIXI || {};
}
//convert rotation speed to Radians from Degrees
this.rotationSpeed *= exports.ParticleUtils.DEG_TO_RADS;
this.rotationAcceleration *= exports.ParticleUtils.DEG_TO_RADS;
//set alpha to inital alpha
this.alpha = this.alphaList.current.value;
//set scale to initial scale
@@ -71202,13 +71208,19 @@ this.PIXI = this.PIXI || {};
}
//handle movement
if (this._doNormalMovement) {
var deltaX = void 0;
var deltaY = void 0;
//interpolate speed
if (this._doSpeed) {
var speed = this.speedList.interpolate(lerp) * this.speedMultiplier;
exports.ParticleUtils.normalize(this.velocity);
exports.ParticleUtils.scaleBy(this.velocity, speed);
deltaX = this.velocity.x * delta;
deltaY = this.velocity.y * delta;
}
else if (this._doAcceleration) {
var oldVX = this.velocity.x;
var oldVY = this.velocity.y;
this.velocity.x += this.acceleration.x * delta;
this.velocity.y += this.acceleration.y * delta;
if (this.maxSpeed) {
@@ -71219,17 +71231,29 @@ this.PIXI = this.PIXI || {};
exports.ParticleUtils.scaleBy(this.velocity, this.maxSpeed / currentSpeed);
}
}
// calculate position delta by the midpoint between our old velocity and our new velocity
deltaX = (oldVX + this.velocity.x) / 2 * delta;
deltaY = (oldVY + this.velocity.y) / 2 * delta;
}
else {
deltaX = this.velocity.x * delta;
deltaY = this.velocity.y * delta;
}
//adjust position based on velocity
this.position.x += this.velocity.x * delta;
this.position.y += this.velocity.y * delta;
this.position.x += deltaX;
this.position.y += deltaY;
}
//interpolate color
if (this._doColor) {
this.tint = this.colorList.interpolate(lerp);
}
//update rotation
if (this.rotationSpeed !== 0) {
if (this.rotationAcceleration !== 0) {
var newRotationSpeed = this.rotationSpeed + this.rotationAcceleration * delta;
this.rotation += (this.rotationSpeed + newRotationSpeed) / 2 * delta;
this.rotationSpeed = newRotationSpeed;
}
else if (this.rotationSpeed !== 0) {
this.rotation += this.rotationSpeed * delta;
}
else if (this.acceleration && !this.noRotation) {
@@ -71571,7 +71595,7 @@ this.PIXI = this.PIXI || {};
//set up the speed
if (config.speed) {
this.startSpeed = PropertyNode.createList(config.speed);
this.minimumSpeedMultiplier = config.speed.minimumSpeedMultiplier || 1;
this.minimumSpeedMultiplier = ('minimumSpeedMultiplier' in config ? config.minimumSpeedMultiplier : config.speed.minimumSpeedMultiplier) || 1;
}
else {
this.minimumSpeedMultiplier = 1;
@@ -71590,7 +71614,7 @@ this.PIXI = this.PIXI || {};
//set up the scale
if (config.scale) {
this.startScale = PropertyNode.createList(config.scale);
this.minimumScaleMultiplier = config.scale.minimumScaleMultiplier || 1;
this.minimumScaleMultiplier = ('minimumScaleMultiplier' in config ? config.minimumScaleMultiplier : config.scale.minimumScaleMultiplier) || 1;
}
else {
this.startScale = new PropertyNode(1, 0);
@@ -71623,6 +71647,7 @@ this.PIXI = this.PIXI || {};
}
else
this.minRotationSpeed = this.maxRotationSpeed = 0;
this.rotationAcceleration = config.rotationAcceleration || 0;
//set up the lifetime
this.minLifetime = config.lifetime.min;
this.maxLifetime = config.lifetime.max;
@@ -71711,7 +71736,7 @@ this.PIXI = this.PIXI || {};
//start emitting
this._spawnTimer = 0;
this.emit = config.emit === undefined ? true : !!config.emit;
this.autoUpdate = config.autoUpdate === undefined ? false : !!config.autoUpdate;
this.autoUpdate = !!config.autoUpdate;
};
/**
* Recycles an individual particle. For internal use only.
@@ -71946,6 +71971,7 @@ this.PIXI = this.PIXI || {};
p.rotationSpeed = this.minRotationSpeed;
else
p.rotationSpeed = Math.random() * (this.maxRotationSpeed - this.minRotationSpeed) + this.minRotationSpeed;
p.rotationAcceleration = this.rotationAcceleration;
p.noRotation = this.noRotation;
//set up the lifetime
p.maxLife = lifetime;
@@ -72462,6 +72488,8 @@ this.PIXI = this.PIXI || {};
else
this.elapsed = this.duration - 0.000001;
}
// add a very small number to the frame and then floor it to avoid
// the frame being one short due to floating point errors.
var frame = (this.elapsed * this.framerate + 0.0000001) | 0;
this.texture = this.textures[frame] || pixi.Texture.EMPTY;
}
@@ -72529,6 +72557,7 @@ this.PIXI = this.PIXI || {};
exports.Particle = Particle;
exports.Emitter = Emitter;
exports.PathParticle = PathParticle;
exports.AnimatedParticle = AnimatedParticle;
exports.PolygonalChain = PolygonalChain;
exports.PropertyList = PropertyList;
@@ -72618,14 +72647,6 @@ var pixi_projection;
})(utils = pixi_projection.utils || (pixi_projection.utils = {}));
})(pixi_projection || (pixi_projection = {}));
PIXI.projection = pixi_projection;
var pixi_heaven;
(function (pixi_heaven) {
if (!PIXI.spine) {
PIXI.spine = {
Spine: function () { }
};
}
})(pixi_heaven || (pixi_heaven = {}));
var pixi_projection;
(function (pixi_projection) {
var AbstractProjection = (function () {
@@ -72799,6 +72820,44 @@ var pixi_projection;
})(webgl = pixi_projection.webgl || (pixi_projection.webgl = {}));
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var webgl;
(function (webgl) {
function generateMultiTextureShader(vertexSrc, fragmentSrc, gl, maxTextures) {
fragmentSrc = fragmentSrc.replace(/%count%/gi, maxTextures + '');
fragmentSrc = fragmentSrc.replace(/%forloop%/gi, generateSampleSrc(maxTextures));
var shader = new PIXI.Shader(gl, vertexSrc, fragmentSrc);
var sampleValues = new Int32Array(maxTextures);
for (var i = 0; i < maxTextures; i++) {
sampleValues[i] = i;
}
shader.bind();
shader.uniforms.uSamplers = sampleValues;
return shader;
}
webgl.generateMultiTextureShader = generateMultiTextureShader;
function generateSampleSrc(maxTextures) {
var src = '';
src += '\n';
src += '\n';
for (var i = 0; i < maxTextures; i++) {
if (i > 0) {
src += '\nelse ';
}
if (i < maxTextures - 1) {
src += "if(textureId == " + i + ".0)";
}
src += '\n{';
src += "\n\tcolor = texture2D(uSamplers[" + i + "], textureCoord);";
src += '\n}';
}
src += '\n';
src += '\n';
return src;
}
})(webgl = pixi_projection.webgl || (pixi_projection.webgl = {}));
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var webgl;
(function (webgl) {
@@ -73044,44 +73103,6 @@ var pixi_projection;
})(webgl = pixi_projection.webgl || (pixi_projection.webgl = {}));
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var webgl;
(function (webgl) {
function generateMultiTextureShader(vertexSrc, fragmentSrc, gl, maxTextures) {
fragmentSrc = fragmentSrc.replace(/%count%/gi, maxTextures + '');
fragmentSrc = fragmentSrc.replace(/%forloop%/gi, generateSampleSrc(maxTextures));
var shader = new PIXI.Shader(gl, vertexSrc, fragmentSrc);
var sampleValues = new Int32Array(maxTextures);
for (var i = 0; i < maxTextures; i++) {
sampleValues[i] = i;
}
shader.bind();
shader.uniforms.uSamplers = sampleValues;
return shader;
}
webgl.generateMultiTextureShader = generateMultiTextureShader;
function generateSampleSrc(maxTextures) {
var src = '';
src += '\n';
src += '\n';
for (var i = 0; i < maxTextures; i++) {
if (i > 0) {
src += '\nelse ';
}
if (i < maxTextures - 1) {
src += "if(textureId == " + i + ".0)";
}
src += '\n{';
src += "\n\tcolor = texture2D(uSamplers[" + i + "], textureCoord);";
src += '\n}';
}
src += '\n';
src += '\n';
return src;
}
})(webgl = pixi_projection.webgl || (pixi_projection.webgl = {}));
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var p = [new PIXI.Point(), new PIXI.Point(), new PIXI.Point(), new PIXI.Point()];
var a = [0, 0, 0, 0];
@@ -73754,6 +73775,37 @@ var pixi_projection;
pixi_projection.StrangeSurface = StrangeSurface;
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
PIXI.Sprite.prototype.convertTo2s = function () {
if (this.proj)
return;
this.pluginName = 'sprite_bilinear';
this.aTrans = new PIXI.Matrix();
this.calculateVertices = pixi_projection.Sprite2s.prototype.calculateVertices;
this.calculateTrimmedVertices = pixi_projection.Sprite2s.prototype.calculateTrimmedVertices;
this._calculateBounds = pixi_projection.Sprite2s.prototype._calculateBounds;
PIXI.Container.prototype.convertTo2s.call(this);
};
PIXI.Container.prototype.convertTo2s = function () {
if (this.proj)
return;
this.proj = new pixi_projection.Projection2d(this.transform);
Object.defineProperty(this, "worldTransform", {
get: function () {
return this.proj;
},
enumerable: true,
configurable: true
});
};
PIXI.Container.prototype.convertSubtreeTo2s = function () {
this.convertTo2s();
for (var i = 0; i < this.children.length; i++) {
this.children[i].convertSubtreeTo2s();
}
};
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var Sprite2s = (function (_super) {
__extends(Sprite2s, _super);
@@ -73928,37 +73980,6 @@ var pixi_projection;
Text2s.prototype._calculateBounds = pixi_projection.Sprite2s.prototype._calculateBounds;
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
PIXI.Sprite.prototype.convertTo2s = function () {
if (this.proj)
return;
this.pluginName = 'sprite_bilinear';
this.aTrans = new PIXI.Matrix();
this.calculateVertices = pixi_projection.Sprite2s.prototype.calculateVertices;
this.calculateTrimmedVertices = pixi_projection.Sprite2s.prototype.calculateTrimmedVertices;
this._calculateBounds = pixi_projection.Sprite2s.prototype._calculateBounds;
PIXI.Container.prototype.convertTo2s.call(this);
};
PIXI.Container.prototype.convertTo2s = function () {
if (this.proj)
return;
this.proj = new pixi_projection.Projection2d(this.transform);
Object.defineProperty(this, "worldTransform", {
get: function () {
return this.proj;
},
enumerable: true,
configurable: true
});
};
PIXI.Container.prototype.convertSubtreeTo2s = function () {
this.convertTo2s();
for (var i = 0; i < this.children.length; i++) {
this.children[i].convertSubtreeTo2s();
}
};
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
function container2dWorldTransform() {
return this.proj.affine ? this.transform.worldTransform : this.proj.world;
@@ -74022,6 +74043,7 @@ var pixi_projection;
AFFINE[AFFINE["AXIS_X"] = 2] = "AXIS_X";
AFFINE[AFFINE["AXIS_Y"] = 3] = "AXIS_Y";
AFFINE[AFFINE["POINT"] = 4] = "POINT";
AFFINE[AFFINE["AXIS_XR"] = 5] = "AXIS_XR";
})(AFFINE = pixi_projection.AFFINE || (pixi_projection.AFFINE = {}));
var Matrix2d = (function () {
function Matrix2d(backingArray) {
@@ -74271,6 +74293,10 @@ var pixi_projection;
matrix.a = D;
matrix.c = 0;
}
else if (affine === AFFINE.AXIS_XR) {
matrix.a = matrix.d * D;
matrix.c = -matrix.b * D;
}
}
};
Matrix2d.prototype.copyFrom = function (matrix) {
@@ -74509,6 +74535,43 @@ var pixi_projection;
PIXI.WebGLRenderer.registerPlugin('mesh2d', Mesh2dRenderer);
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
function convertTo2d() {
if (this.proj)
return;
this.proj = new pixi_projection.Projection2d(this.transform);
this.toLocal = pixi_projection.Container2d.prototype.toLocal;
Object.defineProperty(this, "worldTransform", {
get: pixi_projection.container2dWorldTransform,
enumerable: true,
configurable: true
});
}
PIXI.Container.prototype.convertTo2d = convertTo2d;
PIXI.Sprite.prototype.convertTo2d = function () {
if (this.proj)
return;
this.calculateVertices = pixi_projection.Sprite2d.prototype.calculateVertices;
this.calculateTrimmedVertices = pixi_projection.Sprite2d.prototype.calculateTrimmedVertices;
this._calculateBounds = pixi_projection.Sprite2d.prototype._calculateBounds;
this.pluginName = 'sprite2d';
this.vertexData = new Float32Array(12);
convertTo2d.call(this);
};
PIXI.mesh.Mesh.prototype.convertTo2d = function () {
if (this.proj)
return;
this.pluginName = 'mesh2d';
convertTo2d.call(this);
};
PIXI.Container.prototype.convertSubtreeTo2d = function () {
this.convertTo2d();
for (var i = 0; i < this.children.length; i++) {
this.children[i].convertSubtreeTo2d();
}
};
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var Sprite2d = (function (_super) {
__extends(Sprite2d, _super);
@@ -74739,43 +74802,6 @@ var pixi_projection;
Text2d.prototype._calculateBounds = pixi_projection.Sprite2d.prototype._calculateBounds;
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
function convertTo2d() {
if (this.proj)
return;
this.proj = new pixi_projection.Projection2d(this.transform);
this.toLocal = pixi_projection.Container2d.prototype.toLocal;
Object.defineProperty(this, "worldTransform", {
get: pixi_projection.container2dWorldTransform,
enumerable: true,
configurable: true
});
}
PIXI.Container.prototype.convertTo2d = convertTo2d;
PIXI.Sprite.prototype.convertTo2d = function () {
if (this.proj)
return;
this.calculateVertices = pixi_projection.Sprite2d.prototype.calculateVertices;
this.calculateTrimmedVertices = pixi_projection.Sprite2d.prototype.calculateTrimmedVertices;
this._calculateBounds = pixi_projection.Sprite2d.prototype._calculateBounds;
this.pluginName = 'sprite2d';
this.vertexData = new Float32Array(12);
convertTo2d.call(this);
};
PIXI.mesh.Mesh.prototype.convertTo2d = function () {
if (this.proj)
return;
this.pluginName = 'mesh2d';
convertTo2d.call(this);
};
PIXI.Container.prototype.convertSubtreeTo2d = function () {
this.convertTo2d();
for (var i = 0; i < this.children.length; i++) {
this.children[i].convertSubtreeTo2d();
}
};
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var tempTransform = new PIXI.TransformStatic();
var TilingSprite2d = (function (_super) {
@@ -75021,9 +75047,9 @@ var pixi_projection;
this.displayObjectUpdateTransform();
}
if (this.proj.affine) {
return this.transform.worldTransform.applyInverse(point, point);
return this.transform.worldTransform.applyInverse(position, point);
}
return this.proj.world.applyInverse(point, point);
return this.proj.world.applyInverse(position, point);
}
if (this.parent) {
point = this.parent.worldTransform.applyInverse(position, point);
@@ -75479,7 +75505,7 @@ var pixi_projection;
return out;
};
Matrix3d.prototype.apply = function (pos, newPos) {
newPos = newPos || new PIXI.Point();
newPos = newPos || new pixi_projection.Point3d();
var mat4 = this.mat4;
var x = pos.x;
var y = pos.y;
@@ -76056,7 +76082,7 @@ var pixi_projection;
return Point3d;
}(PIXI.Point));
pixi_projection.Point3d = Point3d;
PIXI.Point = Point3d;
PIXI.Point3d = Point3d;
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
@@ -76212,6 +76238,65 @@ var pixi_projection;
pixi_projection.Mesh3d = Mesh3d;
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var containerProps = {
worldTransform: {
get: pixi_projection.container3dWorldTransform,
enumerable: true,
configurable: true
},
position3d: {
get: function () { return this.proj.position; },
set: function (value) { this.proj.position.copy(value); }
},
scale3d: {
get: function () { return this.proj.scale; },
set: function (value) { this.proj.scale.copy(value); }
},
pivot3d: {
get: function () { return this.proj.pivot; },
set: function (value) { this.proj.pivot.copy(value); }
},
euler: {
get: function () { return this.proj.euler; },
set: function (value) { this.proj.euler.copy(value); }
}
};
function convertTo3d() {
if (this.proj)
return;
this.proj = new pixi_projection.Projection3d(this.transform);
this.toLocal = pixi_projection.Container3d.prototype.toLocal;
this.isFrontFace = pixi_projection.Container3d.prototype.isFrontFace;
this.getDepth = pixi_projection.Container3d.prototype.getDepth;
Object.defineProperties(this, containerProps);
}
PIXI.Container.prototype.convertTo3d = convertTo3d;
PIXI.Sprite.prototype.convertTo3d = function () {
if (this.proj)
return;
this.calculateVertices = pixi_projection.Sprite3d.prototype.calculateVertices;
this.calculateTrimmedVertices = pixi_projection.Sprite3d.prototype.calculateTrimmedVertices;
this._calculateBounds = pixi_projection.Sprite3d.prototype._calculateBounds;
this.containsPoint = pixi_projection.Sprite3d.prototype.containsPoint;
this.pluginName = 'sprite2d';
this.vertexData = new Float32Array(12);
convertTo3d.call(this);
};
PIXI.mesh.Mesh.prototype.convertTo3d = function () {
if (this.proj)
return;
this.pluginName = 'mesh2d';
convertTo3d.call(this);
};
PIXI.Container.prototype.convertSubtreeTo3d = function () {
this.convertTo3d();
for (var i = 0; i < this.children.length; i++) {
this.children[i].convertSubtreeTo3d();
}
};
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var Sprite3d = (function (_super) {
__extends(Sprite3d, _super);
@@ -76497,65 +76582,6 @@ var pixi_projection;
Text3d.prototype.containsPoint = pixi_projection.Sprite3d.prototype.containsPoint;
Text3d.prototype._renderWebGL = pixi_projection.Sprite3d.prototype._renderWebGL;
})(pixi_projection || (pixi_projection = {}));
var pixi_projection;
(function (pixi_projection) {
var containerProps = {
worldTransform: {
get: pixi_projection.container3dWorldTransform,
enumerable: true,
configurable: true
},
position3d: {
get: function () { return this.proj.position; },
set: function (value) { this.proj.position.copy(value); }
},
scale3d: {
get: function () { return this.proj.scale; },
set: function (value) { this.proj.scale.copy(value); }
},
pivot3d: {
get: function () { return this.proj.pivot; },
set: function (value) { this.proj.pivot.copy(value); }
},
euler: {
get: function () { return this.proj.euler; },
set: function (value) { this.proj.euler.copy(value); }
}
};
function convertTo3d() {
if (this.proj)
return;
this.proj = new pixi_projection.Projection3d(this.transform);
this.toLocal = pixi_projection.Container3d.prototype.toLocal;
this.isFrontFace = pixi_projection.Container3d.prototype.isFrontFace;
this.getDepth = pixi_projection.Container3d.prototype.getDepth;
Object.defineProperties(this, containerProps);
}
PIXI.Container.prototype.convertTo3d = convertTo3d;
PIXI.Sprite.prototype.convertTo3d = function () {
if (this.proj)
return;
this.calculateVertices = pixi_projection.Sprite3d.prototype.calculateVertices;
this.calculateTrimmedVertices = pixi_projection.Sprite3d.prototype.calculateTrimmedVertices;
this._calculateBounds = pixi_projection.Sprite3d.prototype._calculateBounds;
this.containsPoint = pixi_projection.Sprite3d.prototype.containsPoint;
this.pluginName = 'sprite2d';
this.vertexData = new Float32Array(12);
convertTo3d.call(this);
};
PIXI.mesh.Mesh.prototype.convertTo3d = function () {
if (this.proj)
return;
this.pluginName = 'mesh2d';
convertTo3d.call(this);
};
PIXI.Container.prototype.convertSubtreeTo3d = function () {
this.convertTo3d();
for (var i = 0; i < this.children.length; i++) {
this.children[i].convertSubtreeTo3d();
}
};
})(pixi_projection || (pixi_projection = {}));
/*!
* VERSION: 2.1.2
dist/iwmlib.3rdparty.min.js
Vendored
+1 -1
View File
File diff suppressed because one or more lines are too long