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 spine; (function (spine) { var Animation = (function () { function Animation(name, timelines, duration) { if (name == null) throw new Error("name cannot be null."); if (timelines == null) throw new Error("timelines cannot be null."); this.name = name; this.timelines = timelines; this.duration = duration; } Animation.prototype.apply = function (skeleton, lastTime, time, loop, events, alpha, blend, direction) { if (skeleton == null) throw new Error("skeleton cannot be null."); if (loop && this.duration != 0) { time %= this.duration; if (lastTime > 0) lastTime %= this.duration; } var timelines = this.timelines; for (var i = 0, n = timelines.length; i < n; i++) timelines[i].apply(skeleton, lastTime, time, events, alpha, blend, direction); }; Animation.binarySearch = function (values, target, step) { if (step === void 0) { step = 1; } var low = 0; var high = values.length / step - 2; if (high == 0) return step; var current = high >>> 1; while (true) { if (values[(current + 1) * step] <= target) low = current + 1; else high = current; if (low == high) return (low + 1) * step; current = (low + high) >>> 1; } }; Animation.linearSearch = function (values, target, step) { for (var i = 0, last = values.length - step; i <= last; i += step) if (values[i] > target) return i; return -1; }; return Animation; }()); spine.Animation = Animation; var MixBlend; (function (MixBlend) { MixBlend[MixBlend["setup"] = 0] = "setup"; MixBlend[MixBlend["first"] = 1] = "first"; MixBlend[MixBlend["replace"] = 2] = "replace"; MixBlend[MixBlend["add"] = 3] = "add"; })(MixBlend = spine.MixBlend || (spine.MixBlend = {})); var MixDirection; (function (MixDirection) { MixDirection[MixDirection["in"] = 0] = "in"; MixDirection[MixDirection["out"] = 1] = "out"; })(MixDirection = spine.MixDirection || (spine.MixDirection = {})); var TimelineType; (function (TimelineType) { TimelineType[TimelineType["rotate"] = 0] = "rotate"; TimelineType[TimelineType["translate"] = 1] = "translate"; TimelineType[TimelineType["scale"] = 2] = "scale"; TimelineType[TimelineType["shear"] = 3] = "shear"; TimelineType[TimelineType["attachment"] = 4] = "attachment"; TimelineType[TimelineType["color"] = 5] = "color"; TimelineType[TimelineType["deform"] = 6] = "deform"; TimelineType[TimelineType["event"] = 7] = "event"; TimelineType[TimelineType["drawOrder"] = 8] = "drawOrder"; TimelineType[TimelineType["ikConstraint"] = 9] = "ikConstraint"; TimelineType[TimelineType["transformConstraint"] = 10] = "transformConstraint"; TimelineType[TimelineType["pathConstraintPosition"] = 11] = "pathConstraintPosition"; TimelineType[TimelineType["pathConstraintSpacing"] = 12] = "pathConstraintSpacing"; TimelineType[TimelineType["pathConstraintMix"] = 13] = "pathConstraintMix"; TimelineType[TimelineType["twoColor"] = 14] = "twoColor"; })(TimelineType = spine.TimelineType || (spine.TimelineType = {})); var CurveTimeline = (function () { function CurveTimeline(frameCount) { if (frameCount <= 0) throw new Error("frameCount must be > 0: " + frameCount); this.curves = spine.Utils.newFloatArray((frameCount - 1) * CurveTimeline.BEZIER_SIZE); } CurveTimeline.prototype.getFrameCount = function () { return this.curves.length / CurveTimeline.BEZIER_SIZE + 1; }; CurveTimeline.prototype.setLinear = function (frameIndex) { this.curves[frameIndex * CurveTimeline.BEZIER_SIZE] = CurveTimeline.LINEAR; }; CurveTimeline.prototype.setStepped = function (frameIndex) { this.curves[frameIndex * CurveTimeline.BEZIER_SIZE] = CurveTimeline.STEPPED; }; CurveTimeline.prototype.getCurveType = function (frameIndex) { var index = frameIndex * CurveTimeline.BEZIER_SIZE; if (index == this.curves.length) return CurveTimeline.LINEAR; var type = this.curves[index]; if (type == CurveTimeline.LINEAR) return CurveTimeline.LINEAR; if (type == CurveTimeline.STEPPED) return CurveTimeline.STEPPED; return CurveTimeline.BEZIER; }; CurveTimeline.prototype.setCurve = function (frameIndex, cx1, cy1, cx2, cy2) { var tmpx = (-cx1 * 2 + cx2) * 0.03, tmpy = (-cy1 * 2 + cy2) * 0.03; var dddfx = ((cx1 - cx2) * 3 + 1) * 0.006, dddfy = ((cy1 - cy2) * 3 + 1) * 0.006; var ddfx = tmpx * 2 + dddfx, ddfy = tmpy * 2 + dddfy; var dfx = cx1 * 0.3 + tmpx + dddfx * 0.16666667, dfy = cy1 * 0.3 + tmpy + dddfy * 0.16666667; var i = frameIndex * CurveTimeline.BEZIER_SIZE; var curves = this.curves; curves[i++] = CurveTimeline.BEZIER; var x = dfx, y = dfy; for (var n = i + CurveTimeline.BEZIER_SIZE - 1; i < n; i += 2) { curves[i] = x; curves[i + 1] = y; dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; x += dfx; y += dfy; } }; CurveTimeline.prototype.getCurvePercent = function (frameIndex, percent) { percent = spine.MathUtils.clamp(percent, 0, 1); var curves = this.curves; var i = frameIndex * CurveTimeline.BEZIER_SIZE; var type = curves[i]; if (type == CurveTimeline.LINEAR) return percent; if (type == CurveTimeline.STEPPED) return 0; i++; var x = 0; for (var start = i, n = i + CurveTimeline.BEZIER_SIZE - 1; i < n; i += 2) { x = curves[i]; if (x >= percent) { var prevX = void 0, prevY = void 0; if (i == start) { prevX = 0; prevY = 0; } else { prevX = curves[i - 2]; prevY = curves[i - 1]; } return prevY + (curves[i + 1] - prevY) * (percent - prevX) / (x - prevX); } } var y = curves[i - 1]; return y + (1 - y) * (percent - x) / (1 - x); }; CurveTimeline.LINEAR = 0; CurveTimeline.STEPPED = 1; CurveTimeline.BEZIER = 2; CurveTimeline.BEZIER_SIZE = 10 * 2 - 1; return CurveTimeline; }()); spine.CurveTimeline = CurveTimeline; var RotateTimeline = (function (_super) { __extends(RotateTimeline, _super); function RotateTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount << 1); return _this; } RotateTimeline.prototype.getPropertyId = function () { return (TimelineType.rotate << 24) + this.boneIndex; }; RotateTimeline.prototype.setFrame = function (frameIndex, time, degrees) { frameIndex <<= 1; this.frames[frameIndex] = time; this.frames[frameIndex + RotateTimeline.ROTATION] = degrees; }; RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) { var frames = this.frames; var bone = skeleton.bones[this.boneIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: bone.rotation = bone.data.rotation; return; case MixBlend.first: var r_1 = bone.data.rotation - bone.rotation; bone.rotation += (r_1 - (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360) * alpha; } return; } if (time >= frames[frames.length - RotateTimeline.ENTRIES]) { var r_2 = frames[frames.length + RotateTimeline.PREV_ROTATION]; switch (blend) { case MixBlend.setup: bone.rotation = bone.data.rotation + r_2 * alpha; break; case MixBlend.first: case MixBlend.replace: r_2 += bone.data.rotation - bone.rotation; r_2 -= (16384 - ((16384.499999999996 - r_2 / 360) | 0)) * 360; case MixBlend.add: bone.rotation += r_2 * alpha; } return; } var frame = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES); var prevRotation = frames[frame + RotateTimeline.PREV_ROTATION]; var frameTime = frames[frame]; var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); var r = frames[frame + RotateTimeline.ROTATION] - prevRotation; r = prevRotation + (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * percent; switch (blend) { case MixBlend.setup: bone.rotation = bone.data.rotation + (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * alpha; break; case MixBlend.first: case MixBlend.replace: r += bone.data.rotation - bone.rotation; case MixBlend.add: bone.rotation += (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * alpha; } }; RotateTimeline.ENTRIES = 2; RotateTimeline.PREV_TIME = -2; RotateTimeline.PREV_ROTATION = -1; RotateTimeline.ROTATION = 1; return RotateTimeline; }(CurveTimeline)); spine.RotateTimeline = RotateTimeline; var TranslateTimeline = (function (_super) { __extends(TranslateTimeline, _super); function TranslateTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount * TranslateTimeline.ENTRIES); return _this; } TranslateTimeline.prototype.getPropertyId = function () { return (TimelineType.translate << 24) + this.boneIndex; }; TranslateTimeline.prototype.setFrame = function (frameIndex, time, x, y) { frameIndex *= TranslateTimeline.ENTRIES; this.frames[frameIndex] = time; this.frames[frameIndex + TranslateTimeline.X] = x; this.frames[frameIndex + TranslateTimeline.Y] = y; }; TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) { var frames = this.frames; var bone = skeleton.bones[this.boneIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: bone.x = bone.data.x; bone.y = bone.data.y; return; case MixBlend.first: bone.x += (bone.data.x - bone.x) * alpha; bone.y += (bone.data.y - bone.y) * alpha; } return; } var x = 0, y = 0; if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) { x = frames[frames.length + TranslateTimeline.PREV_X]; y = frames[frames.length + TranslateTimeline.PREV_Y]; } else { var frame = Animation.binarySearch(frames, time, TranslateTimeline.ENTRIES); x = frames[frame + TranslateTimeline.PREV_X]; y = frames[frame + TranslateTimeline.PREV_Y]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / TranslateTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + TranslateTimeline.PREV_TIME] - frameTime)); x += (frames[frame + TranslateTimeline.X] - x) * percent; y += (frames[frame + TranslateTimeline.Y] - y) * percent; } switch (blend) { case MixBlend.setup: bone.x = bone.data.x + x * alpha; bone.y = bone.data.y + y * alpha; break; case MixBlend.first: case MixBlend.replace: bone.x += (bone.data.x + x - bone.x) * alpha; bone.y += (bone.data.y + y - bone.y) * alpha; break; case MixBlend.add: bone.x += x * alpha; bone.y += y * alpha; } }; TranslateTimeline.ENTRIES = 3; TranslateTimeline.PREV_TIME = -3; TranslateTimeline.PREV_X = -2; TranslateTimeline.PREV_Y = -1; TranslateTimeline.X = 1; TranslateTimeline.Y = 2; return TranslateTimeline; }(CurveTimeline)); spine.TranslateTimeline = TranslateTimeline; var ScaleTimeline = (function (_super) { __extends(ScaleTimeline, _super); function ScaleTimeline(frameCount) { return _super.call(this, frameCount) || this; } ScaleTimeline.prototype.getPropertyId = function () { return (TimelineType.scale << 24) + this.boneIndex; }; ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) { var frames = this.frames; var bone = skeleton.bones[this.boneIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: bone.scaleX = bone.data.scaleX; bone.scaleY = bone.data.scaleY; return; case MixBlend.first: bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha; bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha; } return; } var x = 0, y = 0; if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) { x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX; y = frames[frames.length + ScaleTimeline.PREV_Y] * bone.data.scaleY; } else { var frame = Animation.binarySearch(frames, time, ScaleTimeline.ENTRIES); x = frames[frame + ScaleTimeline.PREV_X]; y = frames[frame + ScaleTimeline.PREV_Y]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / ScaleTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + ScaleTimeline.PREV_TIME] - frameTime)); x = (x + (frames[frame + ScaleTimeline.X] - x) * percent) * bone.data.scaleX; y = (y + (frames[frame + ScaleTimeline.Y] - y) * percent) * bone.data.scaleY; } if (alpha == 1) { if (blend == MixBlend.add) { bone.scaleX += x - bone.data.scaleX; bone.scaleY += y - bone.data.scaleY; } else { bone.scaleX = x; bone.scaleY = y; } } else { var bx = 0, by = 0; if (direction == MixDirection.out) { switch (blend) { case MixBlend.setup: bx = bone.data.scaleX; by = bone.data.scaleY; bone.scaleX = bx + (Math.abs(x) * spine.MathUtils.signum(bx) - bx) * alpha; bone.scaleY = by + (Math.abs(y) * spine.MathUtils.signum(by) - by) * alpha; break; case MixBlend.first: case MixBlend.replace: bx = bone.scaleX; by = bone.scaleY; bone.scaleX = bx + (Math.abs(x) * spine.MathUtils.signum(bx) - bx) * alpha; bone.scaleY = by + (Math.abs(y) * spine.MathUtils.signum(by) - by) * alpha; break; case MixBlend.add: bx = bone.scaleX; by = bone.scaleY; bone.scaleX = bx + (Math.abs(x) * spine.MathUtils.signum(bx) - bone.data.scaleX) * alpha; bone.scaleY = by + (Math.abs(y) * spine.MathUtils.signum(by) - bone.data.scaleY) * alpha; } } else { switch (blend) { case MixBlend.setup: bx = Math.abs(bone.data.scaleX) * spine.MathUtils.signum(x); by = Math.abs(bone.data.scaleY) * spine.MathUtils.signum(y); bone.scaleX = bx + (x - bx) * alpha; bone.scaleY = by + (y - by) * alpha; break; case MixBlend.first: case MixBlend.replace: bx = Math.abs(bone.scaleX) * spine.MathUtils.signum(x); by = Math.abs(bone.scaleY) * spine.MathUtils.signum(y); bone.scaleX = bx + (x - bx) * alpha; bone.scaleY = by + (y - by) * alpha; break; case MixBlend.add: bx = spine.MathUtils.signum(x); by = spine.MathUtils.signum(y); bone.scaleX = Math.abs(bone.scaleX) * bx + (x - Math.abs(bone.data.scaleX) * bx) * alpha; bone.scaleY = Math.abs(bone.scaleY) * by + (y - Math.abs(bone.data.scaleY) * by) * alpha; } } } }; return ScaleTimeline; }(TranslateTimeline)); spine.ScaleTimeline = ScaleTimeline; var ShearTimeline = (function (_super) { __extends(ShearTimeline, _super); function ShearTimeline(frameCount) { return _super.call(this, frameCount) || this; } ShearTimeline.prototype.getPropertyId = function () { return (TimelineType.shear << 24) + this.boneIndex; }; ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) { var frames = this.frames; var bone = skeleton.bones[this.boneIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: bone.shearX = bone.data.shearX; bone.shearY = bone.data.shearY; return; case MixBlend.first: bone.shearX += (bone.data.shearX - bone.shearX) * alpha; bone.shearY += (bone.data.shearY - bone.shearY) * alpha; } return; } var x = 0, y = 0; if (time >= frames[frames.length - ShearTimeline.ENTRIES]) { x = frames[frames.length + ShearTimeline.PREV_X]; y = frames[frames.length + ShearTimeline.PREV_Y]; } else { var frame = Animation.binarySearch(frames, time, ShearTimeline.ENTRIES); x = frames[frame + ShearTimeline.PREV_X]; y = frames[frame + ShearTimeline.PREV_Y]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / ShearTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + ShearTimeline.PREV_TIME] - frameTime)); x = x + (frames[frame + ShearTimeline.X] - x) * percent; y = y + (frames[frame + ShearTimeline.Y] - y) * percent; } switch (blend) { case MixBlend.setup: bone.shearX = bone.data.shearX + x * alpha; bone.shearY = bone.data.shearY + y * alpha; break; case MixBlend.first: case MixBlend.replace: bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha; bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha; break; case MixBlend.add: bone.shearX += x * alpha; bone.shearY += y * alpha; } }; return ShearTimeline; }(TranslateTimeline)); spine.ShearTimeline = ShearTimeline; var ColorTimeline = (function (_super) { __extends(ColorTimeline, _super); function ColorTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount * ColorTimeline.ENTRIES); return _this; } ColorTimeline.prototype.getPropertyId = function () { return (TimelineType.color << 24) + this.slotIndex; }; ColorTimeline.prototype.setFrame = function (frameIndex, time, r, g, b, a) { frameIndex *= ColorTimeline.ENTRIES; this.frames[frameIndex] = time; this.frames[frameIndex + ColorTimeline.R] = r; this.frames[frameIndex + ColorTimeline.G] = g; this.frames[frameIndex + ColorTimeline.B] = b; this.frames[frameIndex + ColorTimeline.A] = a; }; ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) { var slot = skeleton.slots[this.slotIndex]; var frames = this.frames; if (time < frames[0]) { switch (blend) { case MixBlend.setup: slot.color.setFromColor(slot.data.color); return; case MixBlend.first: var color = slot.color, setup = slot.data.color; color.add((setup.r - color.r) * alpha, (setup.g - color.g) * alpha, (setup.b - color.b) * alpha, (setup.a - color.a) * alpha); } return; } var r = 0, g = 0, b = 0, a = 0; if (time >= frames[frames.length - ColorTimeline.ENTRIES]) { var i = frames.length; r = frames[i + ColorTimeline.PREV_R]; g = frames[i + ColorTimeline.PREV_G]; b = frames[i + ColorTimeline.PREV_B]; a = frames[i + ColorTimeline.PREV_A]; } else { var frame = Animation.binarySearch(frames, time, ColorTimeline.ENTRIES); r = frames[frame + ColorTimeline.PREV_R]; g = frames[frame + ColorTimeline.PREV_G]; b = frames[frame + ColorTimeline.PREV_B]; a = frames[frame + ColorTimeline.PREV_A]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / ColorTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + ColorTimeline.PREV_TIME] - frameTime)); r += (frames[frame + ColorTimeline.R] - r) * percent; g += (frames[frame + ColorTimeline.G] - g) * percent; b += (frames[frame + ColorTimeline.B] - b) * percent; a += (frames[frame + ColorTimeline.A] - a) * percent; } if (alpha == 1) slot.color.set(r, g, b, a); else { var color = slot.color; if (blend == MixBlend.setup) color.setFromColor(slot.data.color); color.add((r - color.r) * alpha, (g - color.g) * alpha, (b - color.b) * alpha, (a - color.a) * alpha); } }; ColorTimeline.ENTRIES = 5; ColorTimeline.PREV_TIME = -5; ColorTimeline.PREV_R = -4; ColorTimeline.PREV_G = -3; ColorTimeline.PREV_B = -2; ColorTimeline.PREV_A = -1; ColorTimeline.R = 1; ColorTimeline.G = 2; ColorTimeline.B = 3; ColorTimeline.A = 4; return ColorTimeline; }(CurveTimeline)); spine.ColorTimeline = ColorTimeline; var TwoColorTimeline = (function (_super) { __extends(TwoColorTimeline, _super); function TwoColorTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount * TwoColorTimeline.ENTRIES); return _this; } TwoColorTimeline.prototype.getPropertyId = function () { return (TimelineType.twoColor << 24) + this.slotIndex; }; TwoColorTimeline.prototype.setFrame = function (frameIndex, time, r, g, b, a, r2, g2, b2) { frameIndex *= TwoColorTimeline.ENTRIES; this.frames[frameIndex] = time; this.frames[frameIndex + TwoColorTimeline.R] = r; this.frames[frameIndex + TwoColorTimeline.G] = g; this.frames[frameIndex + TwoColorTimeline.B] = b; this.frames[frameIndex + TwoColorTimeline.A] = a; this.frames[frameIndex + TwoColorTimeline.R2] = r2; this.frames[frameIndex + TwoColorTimeline.G2] = g2; this.frames[frameIndex + TwoColorTimeline.B2] = b2; }; TwoColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) { var slot = skeleton.slots[this.slotIndex]; var frames = this.frames; if (time < frames[0]) { switch (blend) { case MixBlend.setup: slot.color.setFromColor(slot.data.color); slot.darkColor.setFromColor(slot.data.darkColor); return; case MixBlend.first: var light = slot.color, dark = slot.darkColor, setupLight = slot.data.color, setupDark = slot.data.darkColor; light.add((setupLight.r - light.r) * alpha, (setupLight.g - light.g) * alpha, (setupLight.b - light.b) * alpha, (setupLight.a - light.a) * alpha); dark.add((setupDark.r - dark.r) * alpha, (setupDark.g - dark.g) * alpha, (setupDark.b - dark.b) * alpha, 0); } return; } var r = 0, g = 0, b = 0, a = 0, r2 = 0, g2 = 0, b2 = 0; if (time >= frames[frames.length - TwoColorTimeline.ENTRIES]) { var i = frames.length; r = frames[i + TwoColorTimeline.PREV_R]; g = frames[i + TwoColorTimeline.PREV_G]; b = frames[i + TwoColorTimeline.PREV_B]; a = frames[i + TwoColorTimeline.PREV_A]; r2 = frames[i + TwoColorTimeline.PREV_R2]; g2 = frames[i + TwoColorTimeline.PREV_G2]; b2 = frames[i + TwoColorTimeline.PREV_B2]; } else { var frame = Animation.binarySearch(frames, time, TwoColorTimeline.ENTRIES); r = frames[frame + TwoColorTimeline.PREV_R]; g = frames[frame + TwoColorTimeline.PREV_G]; b = frames[frame + TwoColorTimeline.PREV_B]; a = frames[frame + TwoColorTimeline.PREV_A]; r2 = frames[frame + TwoColorTimeline.PREV_R2]; g2 = frames[frame + TwoColorTimeline.PREV_G2]; b2 = frames[frame + TwoColorTimeline.PREV_B2]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / TwoColorTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + TwoColorTimeline.PREV_TIME] - frameTime)); r += (frames[frame + TwoColorTimeline.R] - r) * percent; g += (frames[frame + TwoColorTimeline.G] - g) * percent; b += (frames[frame + TwoColorTimeline.B] - b) * percent; a += (frames[frame + TwoColorTimeline.A] - a) * percent; r2 += (frames[frame + TwoColorTimeline.R2] - r2) * percent; g2 += (frames[frame + TwoColorTimeline.G2] - g2) * percent; b2 += (frames[frame + TwoColorTimeline.B2] - b2) * percent; } if (alpha == 1) { slot.color.set(r, g, b, a); slot.darkColor.set(r2, g2, b2, 1); } else { var light = slot.color, dark = slot.darkColor; if (blend == MixBlend.setup) { light.setFromColor(slot.data.color); dark.setFromColor(slot.data.darkColor); } light.add((r - light.r) * alpha, (g - light.g) * alpha, (b - light.b) * alpha, (a - light.a) * alpha); dark.add((r2 - dark.r) * alpha, (g2 - dark.g) * alpha, (b2 - dark.b) * alpha, 0); } }; TwoColorTimeline.ENTRIES = 8; TwoColorTimeline.PREV_TIME = -8; TwoColorTimeline.PREV_R = -7; TwoColorTimeline.PREV_G = -6; TwoColorTimeline.PREV_B = -5; TwoColorTimeline.PREV_A = -4; TwoColorTimeline.PREV_R2 = -3; TwoColorTimeline.PREV_G2 = -2; TwoColorTimeline.PREV_B2 = -1; TwoColorTimeline.R = 1; TwoColorTimeline.G = 2; TwoColorTimeline.B = 3; TwoColorTimeline.A = 4; TwoColorTimeline.R2 = 5; TwoColorTimeline.G2 = 6; TwoColorTimeline.B2 = 7; return TwoColorTimeline; }(CurveTimeline)); spine.TwoColorTimeline = TwoColorTimeline; var AttachmentTimeline = (function () { function AttachmentTimeline(frameCount) { this.frames = spine.Utils.newFloatArray(frameCount); this.attachmentNames = new Array(frameCount); } AttachmentTimeline.prototype.getPropertyId = function () { return (TimelineType.attachment << 24) + this.slotIndex; }; AttachmentTimeline.prototype.getFrameCount = function () { return this.frames.length; }; AttachmentTimeline.prototype.setFrame = function (frameIndex, time, attachmentName) { this.frames[frameIndex] = time; this.attachmentNames[frameIndex] = attachmentName; }; AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) { var slot = skeleton.slots[this.slotIndex]; if (direction == MixDirection.out && blend == MixBlend.setup) { var attachmentName_1 = slot.data.attachmentName; slot.setAttachment(attachmentName_1 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_1)); return; } var frames = this.frames; if (time < frames[0]) { if (blend == MixBlend.setup || blend == MixBlend.first) { var attachmentName_2 = slot.data.attachmentName; slot.setAttachment(attachmentName_2 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_2)); } return; } var frameIndex = 0; if (time >= frames[frames.length - 1]) frameIndex = frames.length - 1; else frameIndex = Animation.binarySearch(frames, time, 1) - 1; var attachmentName = this.attachmentNames[frameIndex]; skeleton.slots[this.slotIndex] .setAttachment(attachmentName == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName)); }; return AttachmentTimeline; }()); spine.AttachmentTimeline = AttachmentTimeline; var zeros = null; var DeformTimeline = (function (_super) { __extends(DeformTimeline, _super); function DeformTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount); _this.frameVertices = new Array(frameCount); if (zeros == null) zeros = spine.Utils.newFloatArray(64); return _this; } DeformTimeline.prototype.getPropertyId = function () { return (TimelineType.deform << 27) + +this.attachment.id + this.slotIndex; }; DeformTimeline.prototype.setFrame = function (frameIndex, time, vertices) { this.frames[frameIndex] = time; this.frameVertices[frameIndex] = vertices; }; DeformTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { var slot = skeleton.slots[this.slotIndex]; var slotAttachment = slot.getAttachment(); if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment)) return; var verticesArray = slot.attachmentVertices; if (verticesArray.length == 0) blend = MixBlend.setup; var frameVertices = this.frameVertices; var vertexCount = frameVertices[0].length; var frames = this.frames; if (time < frames[0]) { var vertexAttachment = slotAttachment; switch (blend) { case MixBlend.setup: verticesArray.length = 0; return; case MixBlend.first: if (alpha == 1) { verticesArray.length = 0; break; } var vertices_1 = spine.Utils.setArraySize(verticesArray, vertexCount); if (vertexAttachment.bones == null) { var setupVertices = vertexAttachment.vertices; for (var i = 0; i < vertexCount; i++) vertices_1[i] += (setupVertices[i] - vertices_1[i]) * alpha; } else { alpha = 1 - alpha; for (var i = 0; i < vertexCount; i++) vertices_1[i] *= alpha; } } return; } var vertices = spine.Utils.setArraySize(verticesArray, vertexCount); if (time >= frames[frames.length - 1]) { var lastVertices = frameVertices[frames.length - 1]; if (alpha == 1) { if (blend == MixBlend.add) { var vertexAttachment = slotAttachment; if (vertexAttachment.bones == null) { var setupVertices = vertexAttachment.vertices; for (var i_1 = 0; i_1 < vertexCount; i_1++) { vertices[i_1] += lastVertices[i_1] - setupVertices[i_1]; } } else { for (var i_2 = 0; i_2 < vertexCount; i_2++) vertices[i_2] += lastVertices[i_2]; } } else { spine.Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount); } } else { switch (blend) { case MixBlend.setup: { var vertexAttachment_1 = slotAttachment; if (vertexAttachment_1.bones == null) { var setupVertices = vertexAttachment_1.vertices; for (var i_3 = 0; i_3 < vertexCount; i_3++) { var setup = setupVertices[i_3]; vertices[i_3] = setup + (lastVertices[i_3] - setup) * alpha; } } else { for (var i_4 = 0; i_4 < vertexCount; i_4++) vertices[i_4] = lastVertices[i_4] * alpha; } break; } case MixBlend.first: case MixBlend.replace: for (var i_5 = 0; i_5 < vertexCount; i_5++) vertices[i_5] += (lastVertices[i_5] - vertices[i_5]) * alpha; case MixBlend.add: var vertexAttachment = slotAttachment; if (vertexAttachment.bones == null) { var setupVertices = vertexAttachment.vertices; for (var i_6 = 0; i_6 < vertexCount; i_6++) { vertices[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha; } } else { for (var i_7 = 0; i_7 < vertexCount; i_7++) vertices[i_7] += lastVertices[i_7] * alpha; } } } return; } var frame = Animation.binarySearch(frames, time); var prevVertices = frameVertices[frame - 1]; var nextVertices = frameVertices[frame]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime)); if (alpha == 1) { if (blend == MixBlend.add) { var vertexAttachment = slotAttachment; if (vertexAttachment.bones == null) { var setupVertices = vertexAttachment.vertices; for (var i_8 = 0; i_8 < vertexCount; i_8++) { var prev = prevVertices[i_8]; vertices[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8]; } } else { for (var i_9 = 0; i_9 < vertexCount; i_9++) { var prev = prevVertices[i_9]; vertices[i_9] += prev + (nextVertices[i_9] - prev) * percent; } } } else { for (var i_10 = 0; i_10 < vertexCount; i_10++) { var prev = prevVertices[i_10]; vertices[i_10] = prev + (nextVertices[i_10] - prev) * percent; } } } else { switch (blend) { case MixBlend.setup: { var vertexAttachment_2 = slotAttachment; if (vertexAttachment_2.bones == null) { var setupVertices = vertexAttachment_2.vertices; for (var i_11 = 0; i_11 < vertexCount; i_11++) { var prev = prevVertices[i_11], setup = setupVertices[i_11]; vertices[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha; } } else { for (var i_12 = 0; i_12 < vertexCount; i_12++) { var prev = prevVertices[i_12]; vertices[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha; } } break; } case MixBlend.first: case MixBlend.replace: for (var i_13 = 0; i_13 < vertexCount; i_13++) { var prev = prevVertices[i_13]; vertices[i_13] += (prev + (nextVertices[i_13] - prev) * percent - vertices[i_13]) * alpha; } break; case MixBlend.add: var vertexAttachment = slotAttachment; if (vertexAttachment.bones == null) { var setupVertices = vertexAttachment.vertices; for (var i_14 = 0; i_14 < vertexCount; i_14++) { var prev = prevVertices[i_14]; vertices[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha; } } else { for (var i_15 = 0; i_15 < vertexCount; i_15++) { var prev = prevVertices[i_15]; vertices[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha; } } } } }; return DeformTimeline; }(CurveTimeline)); spine.DeformTimeline = DeformTimeline; var EventTimeline = (function () { function EventTimeline(frameCount) { this.frames = spine.Utils.newFloatArray(frameCount); this.events = new Array(frameCount); } EventTimeline.prototype.getPropertyId = function () { return TimelineType.event << 24; }; EventTimeline.prototype.getFrameCount = function () { return this.frames.length; }; EventTimeline.prototype.setFrame = function (frameIndex, event) { this.frames[frameIndex] = event.time; this.events[frameIndex] = event; }; EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { if (firedEvents == null) return; var frames = this.frames; var frameCount = this.frames.length; if (lastTime > time) { this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, blend, direction); lastTime = -1; } else if (lastTime >= frames[frameCount - 1]) return; if (time < frames[0]) return; var frame = 0; if (lastTime < frames[0]) frame = 0; else { frame = Animation.binarySearch(frames, lastTime); var frameTime = frames[frame]; while (frame > 0) { if (frames[frame - 1] != frameTime) break; frame--; } } for (; frame < frameCount && time >= frames[frame]; frame++) firedEvents.push(this.events[frame]); }; return EventTimeline; }()); spine.EventTimeline = EventTimeline; var DrawOrderTimeline = (function () { function DrawOrderTimeline(frameCount) { this.frames = spine.Utils.newFloatArray(frameCount); this.drawOrders = new Array(frameCount); } DrawOrderTimeline.prototype.getPropertyId = function () { return TimelineType.drawOrder << 24; }; DrawOrderTimeline.prototype.getFrameCount = function () { return this.frames.length; }; DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) { this.frames[frameIndex] = time; this.drawOrders[frameIndex] = drawOrder; }; DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { var drawOrder = skeleton.drawOrder; var slots = skeleton.slots; if (direction == MixDirection.out && blend == MixBlend.setup) { spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length); return; } var frames = this.frames; if (time < frames[0]) { if (blend == MixBlend.setup || blend == MixBlend.first) spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length); return; } var frame = 0; if (time >= frames[frames.length - 1]) frame = frames.length - 1; else frame = Animation.binarySearch(frames, time) - 1; var drawOrderToSetupIndex = this.drawOrders[frame]; if (drawOrderToSetupIndex == null) spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length); else { for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++) drawOrder[i] = slots[drawOrderToSetupIndex[i]]; } }; return DrawOrderTimeline; }()); spine.DrawOrderTimeline = DrawOrderTimeline; var IkConstraintTimeline = (function (_super) { __extends(IkConstraintTimeline, _super); function IkConstraintTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount * IkConstraintTimeline.ENTRIES); return _this; } IkConstraintTimeline.prototype.getPropertyId = function () { return (TimelineType.ikConstraint << 24) + this.ikConstraintIndex; }; IkConstraintTimeline.prototype.setFrame = function (frameIndex, time, mix, bendDirection, compress, stretch) { frameIndex *= IkConstraintTimeline.ENTRIES; this.frames[frameIndex] = time; this.frames[frameIndex + IkConstraintTimeline.MIX] = mix; this.frames[frameIndex + IkConstraintTimeline.BEND_DIRECTION] = bendDirection; this.frames[frameIndex + IkConstraintTimeline.COMPRESS] = compress ? 1 : 0; this.frames[frameIndex + IkConstraintTimeline.STRETCH] = stretch ? 1 : 0; }; IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { var frames = this.frames; var constraint = skeleton.ikConstraints[this.ikConstraintIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: constraint.mix = constraint.data.mix; constraint.bendDirection = constraint.data.bendDirection; constraint.compress = constraint.data.compress; constraint.stretch = constraint.data.stretch; return; case MixBlend.first: constraint.mix += (constraint.data.mix - constraint.mix) * alpha; constraint.bendDirection = constraint.data.bendDirection; constraint.compress = constraint.data.compress; constraint.stretch = constraint.data.stretch; } return; } if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) { if (blend == MixBlend.setup) { constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha; if (direction == MixDirection.out) { constraint.bendDirection = constraint.data.bendDirection; constraint.compress = constraint.data.compress; constraint.stretch = constraint.data.stretch; } else { constraint.bendDirection = frames[frames.length + IkConstraintTimeline.PREV_BEND_DIRECTION]; constraint.compress = frames[frames.length + IkConstraintTimeline.PREV_COMPRESS] != 0; constraint.stretch = frames[frames.length + IkConstraintTimeline.PREV_STRETCH] != 0; } } else { constraint.mix += (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.mix) * alpha; if (direction == MixDirection["in"]) { constraint.bendDirection = frames[frames.length + IkConstraintTimeline.PREV_BEND_DIRECTION]; constraint.compress = frames[frames.length + IkConstraintTimeline.PREV_COMPRESS] != 0; constraint.stretch = frames[frames.length + IkConstraintTimeline.PREV_STRETCH] != 0; } } return; } var frame = Animation.binarySearch(frames, time, IkConstraintTimeline.ENTRIES); var mix = frames[frame + IkConstraintTimeline.PREV_MIX]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / IkConstraintTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + IkConstraintTimeline.PREV_TIME] - frameTime)); if (blend == MixBlend.setup) { constraint.mix = constraint.data.mix + (mix + (frames[frame + IkConstraintTimeline.MIX] - mix) * percent - constraint.data.mix) * alpha; if (direction == MixDirection.out) { constraint.bendDirection = constraint.data.bendDirection; constraint.compress = constraint.data.compress; constraint.stretch = constraint.data.stretch; } else { constraint.bendDirection = frames[frame + IkConstraintTimeline.PREV_BEND_DIRECTION]; constraint.compress = frames[frame + IkConstraintTimeline.PREV_COMPRESS] != 0; constraint.stretch = frames[frame + IkConstraintTimeline.PREV_STRETCH] != 0; } } else { constraint.mix += (mix + (frames[frame + IkConstraintTimeline.MIX] - mix) * percent - constraint.mix) * alpha; if (direction == MixDirection["in"]) { constraint.bendDirection = frames[frame + IkConstraintTimeline.PREV_BEND_DIRECTION]; constraint.compress = frames[frame + IkConstraintTimeline.PREV_COMPRESS] != 0; constraint.stretch = frames[frame + IkConstraintTimeline.PREV_STRETCH] != 0; } } }; IkConstraintTimeline.ENTRIES = 5; IkConstraintTimeline.PREV_TIME = -5; IkConstraintTimeline.PREV_MIX = -4; IkConstraintTimeline.PREV_BEND_DIRECTION = -3; IkConstraintTimeline.PREV_COMPRESS = -2; IkConstraintTimeline.PREV_STRETCH = -1; IkConstraintTimeline.MIX = 1; IkConstraintTimeline.BEND_DIRECTION = 2; IkConstraintTimeline.COMPRESS = 3; IkConstraintTimeline.STRETCH = 4; return IkConstraintTimeline; }(CurveTimeline)); spine.IkConstraintTimeline = IkConstraintTimeline; var TransformConstraintTimeline = (function (_super) { __extends(TransformConstraintTimeline, _super); function TransformConstraintTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount * TransformConstraintTimeline.ENTRIES); return _this; } TransformConstraintTimeline.prototype.getPropertyId = function () { return (TimelineType.transformConstraint << 24) + this.transformConstraintIndex; }; TransformConstraintTimeline.prototype.setFrame = function (frameIndex, time, rotateMix, translateMix, scaleMix, shearMix) { frameIndex *= TransformConstraintTimeline.ENTRIES; this.frames[frameIndex] = time; this.frames[frameIndex + TransformConstraintTimeline.ROTATE] = rotateMix; this.frames[frameIndex + TransformConstraintTimeline.TRANSLATE] = translateMix; this.frames[frameIndex + TransformConstraintTimeline.SCALE] = scaleMix; this.frames[frameIndex + TransformConstraintTimeline.SHEAR] = shearMix; }; TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { var frames = this.frames; var constraint = skeleton.transformConstraints[this.transformConstraintIndex]; if (time < frames[0]) { var data = constraint.data; switch (blend) { case MixBlend.setup: constraint.rotateMix = data.rotateMix; constraint.translateMix = data.translateMix; constraint.scaleMix = data.scaleMix; constraint.shearMix = data.shearMix; return; case MixBlend.first: constraint.rotateMix += (data.rotateMix - constraint.rotateMix) * alpha; constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha; constraint.scaleMix += (data.scaleMix - constraint.scaleMix) * alpha; constraint.shearMix += (data.shearMix - constraint.shearMix) * alpha; } return; } var rotate = 0, translate = 0, scale = 0, shear = 0; if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) { var i = frames.length; rotate = frames[i + TransformConstraintTimeline.PREV_ROTATE]; translate = frames[i + TransformConstraintTimeline.PREV_TRANSLATE]; scale = frames[i + TransformConstraintTimeline.PREV_SCALE]; shear = frames[i + TransformConstraintTimeline.PREV_SHEAR]; } else { var frame = Animation.binarySearch(frames, time, TransformConstraintTimeline.ENTRIES); rotate = frames[frame + TransformConstraintTimeline.PREV_ROTATE]; translate = frames[frame + TransformConstraintTimeline.PREV_TRANSLATE]; scale = frames[frame + TransformConstraintTimeline.PREV_SCALE]; shear = frames[frame + TransformConstraintTimeline.PREV_SHEAR]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / TransformConstraintTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + TransformConstraintTimeline.PREV_TIME] - frameTime)); rotate += (frames[frame + TransformConstraintTimeline.ROTATE] - rotate) * percent; translate += (frames[frame + TransformConstraintTimeline.TRANSLATE] - translate) * percent; scale += (frames[frame + TransformConstraintTimeline.SCALE] - scale) * percent; shear += (frames[frame + TransformConstraintTimeline.SHEAR] - shear) * percent; } if (blend == MixBlend.setup) { var data = constraint.data; constraint.rotateMix = data.rotateMix + (rotate - data.rotateMix) * alpha; constraint.translateMix = data.translateMix + (translate - data.translateMix) * alpha; constraint.scaleMix = data.scaleMix + (scale - data.scaleMix) * alpha; constraint.shearMix = data.shearMix + (shear - data.shearMix) * alpha; } else { constraint.rotateMix += (rotate - constraint.rotateMix) * alpha; constraint.translateMix += (translate - constraint.translateMix) * alpha; constraint.scaleMix += (scale - constraint.scaleMix) * alpha; constraint.shearMix += (shear - constraint.shearMix) * alpha; } }; TransformConstraintTimeline.ENTRIES = 5; TransformConstraintTimeline.PREV_TIME = -5; TransformConstraintTimeline.PREV_ROTATE = -4; TransformConstraintTimeline.PREV_TRANSLATE = -3; TransformConstraintTimeline.PREV_SCALE = -2; TransformConstraintTimeline.PREV_SHEAR = -1; TransformConstraintTimeline.ROTATE = 1; TransformConstraintTimeline.TRANSLATE = 2; TransformConstraintTimeline.SCALE = 3; TransformConstraintTimeline.SHEAR = 4; return TransformConstraintTimeline; }(CurveTimeline)); spine.TransformConstraintTimeline = TransformConstraintTimeline; var PathConstraintPositionTimeline = (function (_super) { __extends(PathConstraintPositionTimeline, _super); function PathConstraintPositionTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount * PathConstraintPositionTimeline.ENTRIES); return _this; } PathConstraintPositionTimeline.prototype.getPropertyId = function () { return (TimelineType.pathConstraintPosition << 24) + this.pathConstraintIndex; }; PathConstraintPositionTimeline.prototype.setFrame = function (frameIndex, time, value) { frameIndex *= PathConstraintPositionTimeline.ENTRIES; this.frames[frameIndex] = time; this.frames[frameIndex + PathConstraintPositionTimeline.VALUE] = value; }; PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { var frames = this.frames; var constraint = skeleton.pathConstraints[this.pathConstraintIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: constraint.position = constraint.data.position; return; case MixBlend.first: constraint.position += (constraint.data.position - constraint.position) * alpha; } return; } var position = 0; if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES]) position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE]; else { var frame = Animation.binarySearch(frames, time, PathConstraintPositionTimeline.ENTRIES); position = frames[frame + PathConstraintPositionTimeline.PREV_VALUE]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / PathConstraintPositionTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PathConstraintPositionTimeline.PREV_TIME] - frameTime)); position += (frames[frame + PathConstraintPositionTimeline.VALUE] - position) * percent; } if (blend == MixBlend.setup) constraint.position = constraint.data.position + (position - constraint.data.position) * alpha; else constraint.position += (position - constraint.position) * alpha; }; PathConstraintPositionTimeline.ENTRIES = 2; PathConstraintPositionTimeline.PREV_TIME = -2; PathConstraintPositionTimeline.PREV_VALUE = -1; PathConstraintPositionTimeline.VALUE = 1; return PathConstraintPositionTimeline; }(CurveTimeline)); spine.PathConstraintPositionTimeline = PathConstraintPositionTimeline; var PathConstraintSpacingTimeline = (function (_super) { __extends(PathConstraintSpacingTimeline, _super); function PathConstraintSpacingTimeline(frameCount) { return _super.call(this, frameCount) || this; } PathConstraintSpacingTimeline.prototype.getPropertyId = function () { return (TimelineType.pathConstraintSpacing << 24) + this.pathConstraintIndex; }; PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { var frames = this.frames; var constraint = skeleton.pathConstraints[this.pathConstraintIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: constraint.spacing = constraint.data.spacing; return; case MixBlend.first: constraint.spacing += (constraint.data.spacing - constraint.spacing) * alpha; } return; } var spacing = 0; if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES]) spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE]; else { var frame = Animation.binarySearch(frames, time, PathConstraintSpacingTimeline.ENTRIES); spacing = frames[frame + PathConstraintSpacingTimeline.PREV_VALUE]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / PathConstraintSpacingTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PathConstraintSpacingTimeline.PREV_TIME] - frameTime)); spacing += (frames[frame + PathConstraintSpacingTimeline.VALUE] - spacing) * percent; } if (blend == MixBlend.setup) constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha; else constraint.spacing += (spacing - constraint.spacing) * alpha; }; return PathConstraintSpacingTimeline; }(PathConstraintPositionTimeline)); spine.PathConstraintSpacingTimeline = PathConstraintSpacingTimeline; var PathConstraintMixTimeline = (function (_super) { __extends(PathConstraintMixTimeline, _super); function PathConstraintMixTimeline(frameCount) { var _this = _super.call(this, frameCount) || this; _this.frames = spine.Utils.newFloatArray(frameCount * PathConstraintMixTimeline.ENTRIES); return _this; } PathConstraintMixTimeline.prototype.getPropertyId = function () { return (TimelineType.pathConstraintMix << 24) + this.pathConstraintIndex; }; PathConstraintMixTimeline.prototype.setFrame = function (frameIndex, time, rotateMix, translateMix) { frameIndex *= PathConstraintMixTimeline.ENTRIES; this.frames[frameIndex] = time; this.frames[frameIndex + PathConstraintMixTimeline.ROTATE] = rotateMix; this.frames[frameIndex + PathConstraintMixTimeline.TRANSLATE] = translateMix; }; PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) { var frames = this.frames; var constraint = skeleton.pathConstraints[this.pathConstraintIndex]; if (time < frames[0]) { switch (blend) { case MixBlend.setup: constraint.rotateMix = constraint.data.rotateMix; constraint.translateMix = constraint.data.translateMix; return; case MixBlend.first: constraint.rotateMix += (constraint.data.rotateMix - constraint.rotateMix) * alpha; constraint.translateMix += (constraint.data.translateMix - constraint.translateMix) * alpha; } return; } var rotate = 0, translate = 0; if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) { rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE]; translate = frames[frames.length + PathConstraintMixTimeline.PREV_TRANSLATE]; } else { var frame = Animation.binarySearch(frames, time, PathConstraintMixTimeline.ENTRIES); rotate = frames[frame + PathConstraintMixTimeline.PREV_ROTATE]; translate = frames[frame + PathConstraintMixTimeline.PREV_TRANSLATE]; var frameTime = frames[frame]; var percent = this.getCurvePercent(frame / PathConstraintMixTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PathConstraintMixTimeline.PREV_TIME] - frameTime)); rotate += (frames[frame + PathConstraintMixTimeline.ROTATE] - rotate) * percent; translate += (frames[frame + PathConstraintMixTimeline.TRANSLATE] - translate) * percent; } if (blend == MixBlend.setup) { constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha; constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha; } else { constraint.rotateMix += (rotate - constraint.rotateMix) * alpha; constraint.translateMix += (translate - constraint.translateMix) * alpha; } }; PathConstraintMixTimeline.ENTRIES = 3; PathConstraintMixTimeline.PREV_TIME = -3; PathConstraintMixTimeline.PREV_ROTATE = -2; PathConstraintMixTimeline.PREV_TRANSLATE = -1; PathConstraintMixTimeline.ROTATE = 1; PathConstraintMixTimeline.TRANSLATE = 2; return PathConstraintMixTimeline; }(CurveTimeline)); spine.PathConstraintMixTimeline = PathConstraintMixTimeline; })(spine || (spine = {})); var spine; (function (spine) { var AnimationState = (function () { function AnimationState(data) { this.tracks = new Array(); this.events = new Array(); this.listeners = new Array(); this.queue = new EventQueue(this); this.propertyIDs = new spine.IntSet(); this.animationsChanged = false; this.timeScale = 1; this.trackEntryPool = new spine.Pool(function () { return new TrackEntry(); }); this.data = data; } AnimationState.prototype.update = function (delta) { delta *= this.timeScale; var tracks = this.tracks; for (var i = 0, n = tracks.length; i < n; i++) { var current = tracks[i]; if (current == null) continue; current.animationLast = current.nextAnimationLast; current.trackLast = current.nextTrackLast; var currentDelta = delta * current.timeScale; if (current.delay > 0) { current.delay -= currentDelta; if (current.delay > 0) continue; currentDelta = -current.delay; current.delay = 0; } var next = current.next; if (next != null) { var nextTime = current.trackLast - next.delay; if (nextTime >= 0) { next.delay = 0; next.trackTime = current.timeScale == 0 ? 0 : (nextTime / current.timeScale + delta) * next.timeScale; current.trackTime += currentDelta; this.setCurrent(i, next, true); while (next.mixingFrom != null) { next.mixTime += delta; next = next.mixingFrom; } continue; } } else if (current.trackLast >= current.trackEnd && current.mixingFrom == null) { tracks[i] = null; this.queue.end(current); this.disposeNext(current); continue; } if (current.mixingFrom != null && this.updateMixingFrom(current, delta)) { var from = current.mixingFrom; current.mixingFrom = null; if (from != null) from.mixingTo = null; while (from != null) { this.queue.end(from); from = from.mixingFrom; } } current.trackTime += currentDelta; } this.queue.drain(); }; AnimationState.prototype.updateMixingFrom = function (to, delta) { var from = to.mixingFrom; if (from == null) return true; var finished = this.updateMixingFrom(from, delta); from.animationLast = from.nextAnimationLast; from.trackLast = from.nextTrackLast; if (to.mixTime > 0 && to.mixTime >= to.mixDuration) { if (from.totalAlpha == 0 || to.mixDuration == 0) { to.mixingFrom = from.mixingFrom; if (from.mixingFrom != null) from.mixingFrom.mixingTo = to; to.interruptAlpha = from.interruptAlpha; this.queue.end(from); } return finished; } from.trackTime += delta * from.timeScale; to.mixTime += delta; return false; }; AnimationState.prototype.apply = function (skeleton) { if (skeleton == null) throw new Error("skeleton cannot be null."); if (this.animationsChanged) this._animationsChanged(); var events = this.events; var tracks = this.tracks; var applied = false; for (var i = 0, n = tracks.length; i < n; i++) { var current = tracks[i]; if (current == null || current.delay > 0) continue; applied = true; var blend = i == 0 ? spine.MixBlend.first : current.mixBlend; var mix = current.alpha; if (current.mixingFrom != null) mix *= this.applyMixingFrom(current, skeleton, blend); else if (current.trackTime >= current.trackEnd && current.next == null) mix = 0; var animationLast = current.animationLast, animationTime = current.getAnimationTime(); var timelineCount = current.animation.timelines.length; var timelines = current.animation.timelines; if ((i == 0 && mix == 1) || blend == spine.MixBlend.add) { for (var ii = 0; ii < timelineCount; ii++) timelines[ii].apply(skeleton, animationLast, animationTime, events, mix, blend, spine.MixDirection["in"]); } else { var timelineMode = current.timelineMode; var firstFrame = current.timelinesRotation.length == 0; if (firstFrame) spine.Utils.setArraySize(current.timelinesRotation, timelineCount << 1, null); var timelinesRotation = current.timelinesRotation; for (var ii = 0; ii < timelineCount; ii++) { var timeline = timelines[ii]; var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup; if (timeline instanceof spine.RotateTimeline) { this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame); } else { spine.Utils.webkit602BugfixHelper(mix, blend); timeline.apply(skeleton, animationLast, animationTime, events, mix, timelineBlend, spine.MixDirection["in"]); } } } this.queueEvents(current, animationTime); events.length = 0; current.nextAnimationLast = animationTime; current.nextTrackLast = current.trackTime; } this.queue.drain(); return applied; }; AnimationState.prototype.applyMixingFrom = function (to, skeleton, blend) { var from = to.mixingFrom; if (from.mixingFrom != null) this.applyMixingFrom(from, skeleton, blend); var mix = 0; if (to.mixDuration == 0) { mix = 1; if (blend == spine.MixBlend.first) blend = spine.MixBlend.setup; } else { mix = to.mixTime / to.mixDuration; if (mix > 1) mix = 1; if (blend != spine.MixBlend.first) blend = from.mixBlend; } var events = mix < from.eventThreshold ? this.events : null; var attachments = mix < from.attachmentThreshold, drawOrder = mix < from.drawOrderThreshold; var animationLast = from.animationLast, animationTime = from.getAnimationTime(); var timelineCount = from.animation.timelines.length; var timelines = from.animation.timelines; var alphaHold = from.alpha * to.interruptAlpha, alphaMix = alphaHold * (1 - mix); if (blend == spine.MixBlend.add) { for (var i = 0; i < timelineCount; i++) timelines[i].apply(skeleton, animationLast, animationTime, events, alphaMix, blend, spine.MixDirection.out); } else { var timelineMode = from.timelineMode; var timelineHoldMix = from.timelineHoldMix; var firstFrame = from.timelinesRotation.length == 0; if (firstFrame) spine.Utils.setArraySize(from.timelinesRotation, timelineCount << 1, null); var timelinesRotation = from.timelinesRotation; from.totalAlpha = 0; for (var i = 0; i < timelineCount; i++) { var timeline = timelines[i]; var direction = spine.MixDirection.out; var timelineBlend = void 0; var alpha = 0; switch (timelineMode[i]) { case AnimationState.SUBSEQUENT: if (!attachments && timeline instanceof spine.AttachmentTimeline) continue; if (!drawOrder && timeline instanceof spine.DrawOrderTimeline) continue; timelineBlend = blend; alpha = alphaMix; break; case AnimationState.FIRST: timelineBlend = spine.MixBlend.setup; alpha = alphaMix; break; case AnimationState.HOLD: timelineBlend = spine.MixBlend.setup; alpha = alphaHold; break; default: timelineBlend = spine.MixBlend.setup; var holdMix = timelineHoldMix[i]; alpha = alphaHold * Math.max(0, 1 - holdMix.mixTime / holdMix.mixDuration); break; } from.totalAlpha += alpha; if (timeline instanceof spine.RotateTimeline) this.applyRotateTimeline(timeline, skeleton, animationTime, alpha, timelineBlend, timelinesRotation, i << 1, firstFrame); else { spine.Utils.webkit602BugfixHelper(alpha, blend); if (timelineBlend == spine.MixBlend.setup) { if (timeline instanceof spine.AttachmentTimeline) { if (attachments) direction = spine.MixDirection.out; } else if (timeline instanceof spine.DrawOrderTimeline) { if (drawOrder) direction = spine.MixDirection.out; } } timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction); } } } if (to.mixDuration > 0) this.queueEvents(from, animationTime); this.events.length = 0; from.nextAnimationLast = animationTime; from.nextTrackLast = from.trackTime; return mix; }; AnimationState.prototype.applyRotateTimeline = function (timeline, skeleton, time, alpha, blend, timelinesRotation, i, firstFrame) { if (firstFrame) timelinesRotation[i] = 0; if (alpha == 1) { timeline.apply(skeleton, 0, time, null, 1, blend, spine.MixDirection["in"]); return; } var rotateTimeline = timeline; var frames = rotateTimeline.frames; var bone = skeleton.bones[rotateTimeline.boneIndex]; var r1 = 0, r2 = 0; if (time < frames[0]) { switch (blend) { case spine.MixBlend.setup: bone.rotation = bone.data.rotation; default: return; case spine.MixBlend.first: r1 = bone.rotation; r2 = bone.data.rotation; } } else { r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation; if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES]) r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION]; else { var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES); var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION]; var frameTime = frames[frame]; var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; r2 = prevRotation + r2 * percent + bone.data.rotation; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; } } var total = 0, diff = r2 - r1; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; if (diff == 0) { total = timelinesRotation[i]; } else { var lastTotal = 0, lastDiff = 0; if (firstFrame) { lastTotal = 0; lastDiff = diff; } else { lastTotal = timelinesRotation[i]; lastDiff = timelinesRotation[i + 1]; } var current = diff > 0, dir = lastTotal >= 0; if (spine.MathUtils.signum(lastDiff) != spine.MathUtils.signum(diff) && Math.abs(lastDiff) <= 90) { if (Math.abs(lastTotal) > 180) lastTotal += 360 * spine.MathUtils.signum(lastTotal); dir = current; } total = diff + lastTotal - lastTotal % 360; if (dir != current) total += 360 * spine.MathUtils.signum(lastTotal); timelinesRotation[i] = total; } timelinesRotation[i + 1] = diff; r1 += total * alpha; bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360; }; AnimationState.prototype.queueEvents = function (entry, animationTime) { var animationStart = entry.animationStart, animationEnd = entry.animationEnd; var duration = animationEnd - animationStart; var trackLastWrapped = entry.trackLast % duration; var events = this.events; var i = 0, n = events.length; for (; i < n; i++) { var event_1 = events[i]; if (event_1.time < trackLastWrapped) break; if (event_1.time > animationEnd) continue; this.queue.event(entry, event_1); } var complete = false; if (entry.loop) complete = duration == 0 || trackLastWrapped > entry.trackTime % duration; else complete = animationTime >= animationEnd && entry.animationLast < animationEnd; if (complete) this.queue.complete(entry); for (; i < n; i++) { var event_2 = events[i]; if (event_2.time < animationStart) continue; this.queue.event(entry, events[i]); } }; AnimationState.prototype.clearTracks = function () { var oldDrainDisabled = this.queue.drainDisabled; this.queue.drainDisabled = true; for (var i = 0, n = this.tracks.length; i < n; i++) this.clearTrack(i); this.tracks.length = 0; this.queue.drainDisabled = oldDrainDisabled; this.queue.drain(); }; AnimationState.prototype.clearTrack = function (trackIndex) { if (trackIndex >= this.tracks.length) return; var current = this.tracks[trackIndex]; if (current == null) return; this.queue.end(current); this.disposeNext(current); var entry = current; while (true) { var from = entry.mixingFrom; if (from == null) break; this.queue.end(from); entry.mixingFrom = null; entry.mixingTo = null; entry = from; } this.tracks[current.trackIndex] = null; this.queue.drain(); }; AnimationState.prototype.setCurrent = function (index, current, interrupt) { var from = this.expandToIndex(index); this.tracks[index] = current; if (from != null) { if (interrupt) this.queue.interrupt(from); current.mixingFrom = from; from.mixingTo = current; current.mixTime = 0; if (from.mixingFrom != null && from.mixDuration > 0) current.interruptAlpha *= Math.min(1, from.mixTime / from.mixDuration); from.timelinesRotation.length = 0; } this.queue.start(current); }; AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) { var animation = this.data.skeletonData.findAnimation(animationName); if (animation == null) throw new Error("Animation not found: " + animationName); return this.setAnimationWith(trackIndex, animation, loop); }; AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) { if (animation == null) throw new Error("animation cannot be null."); var interrupt = true; var current = this.expandToIndex(trackIndex); if (current != null) { if (current.nextTrackLast == -1) { this.tracks[trackIndex] = current.mixingFrom; this.queue.interrupt(current); this.queue.end(current); this.disposeNext(current); current = current.mixingFrom; interrupt = false; } else this.disposeNext(current); } var entry = this.trackEntry(trackIndex, animation, loop, current); this.setCurrent(trackIndex, entry, interrupt); this.queue.drain(); return entry; }; AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) { var animation = this.data.skeletonData.findAnimation(animationName); if (animation == null) throw new Error("Animation not found: " + animationName); return this.addAnimationWith(trackIndex, animation, loop, delay); }; AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) { if (animation == null) throw new Error("animation cannot be null."); var last = this.expandToIndex(trackIndex); if (last != null) { while (last.next != null) last = last.next; } var entry = this.trackEntry(trackIndex, animation, loop, last); if (last == null) { this.setCurrent(trackIndex, entry, true); this.queue.drain(); } else { last.next = entry; if (delay <= 0) { var duration = last.animationEnd - last.animationStart; if (duration != 0) { if (last.loop) delay += duration * (1 + ((last.trackTime / duration) | 0)); else delay += Math.max(duration, last.trackTime); delay -= this.data.getMix(last.animation, animation); } else delay = last.trackTime; } } entry.delay = delay; return entry; }; AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) { var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false); entry.mixDuration = mixDuration; entry.trackEnd = mixDuration; return entry; }; AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) { if (delay <= 0) delay -= mixDuration; var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay); entry.mixDuration = mixDuration; entry.trackEnd = mixDuration; return entry; }; AnimationState.prototype.setEmptyAnimations = function (mixDuration) { var oldDrainDisabled = this.queue.drainDisabled; this.queue.drainDisabled = true; for (var i = 0, n = this.tracks.length; i < n; i++) { var current = this.tracks[i]; if (current != null) this.setEmptyAnimation(current.trackIndex, mixDuration); } this.queue.drainDisabled = oldDrainDisabled; this.queue.drain(); }; AnimationState.prototype.expandToIndex = function (index) { if (index < this.tracks.length) return this.tracks[index]; spine.Utils.ensureArrayCapacity(this.tracks, index + 1, null); this.tracks.length = index + 1; return null; }; AnimationState.prototype.trackEntry = function (trackIndex, animation, loop, last) { var entry = this.trackEntryPool.obtain(); entry.trackIndex = trackIndex; entry.animation = animation; entry.loop = loop; entry.holdPrevious = false; entry.eventThreshold = 0; entry.attachmentThreshold = 0; entry.drawOrderThreshold = 0; entry.animationStart = 0; entry.animationEnd = animation.duration; entry.animationLast = -1; entry.nextAnimationLast = -1; entry.delay = 0; entry.trackTime = 0; entry.trackLast = -1; entry.nextTrackLast = -1; entry.trackEnd = Number.MAX_VALUE; entry.timeScale = 1; entry.alpha = 1; entry.interruptAlpha = 1; entry.mixTime = 0; entry.mixDuration = last == null ? 0 : this.data.getMix(last.animation, animation); return entry; }; AnimationState.prototype.disposeNext = function (entry) { var next = entry.next; while (next != null) { this.queue.dispose(next); next = next.next; } entry.next = null; }; AnimationState.prototype._animationsChanged = function () { this.animationsChanged = false; this.propertyIDs.clear(); for (var i = 0, n = this.tracks.length; i < n; i++) { var entry = this.tracks[i]; if (entry == null) continue; while (entry.mixingFrom != null) entry = entry.mixingFrom; do { if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add) this.setTimelineModes(entry); entry = entry.mixingTo; } while (entry != null); } }; AnimationState.prototype.setTimelineModes = function (entry) { var to = entry.mixingTo; var timelines = entry.animation.timelines; var timelinesCount = entry.animation.timelines.length; var timelineMode = spine.Utils.setArraySize(entry.timelineMode, timelinesCount); entry.timelineHoldMix.length = 0; var timelineDipMix = spine.Utils.setArraySize(entry.timelineHoldMix, timelinesCount); var propertyIDs = this.propertyIDs; if (to != null && to.holdPrevious) { for (var i = 0; i < timelinesCount; i++) { propertyIDs.add(timelines[i].getPropertyId()); timelineMode[i] = AnimationState.HOLD; } return; } outer: for (var i = 0; i < timelinesCount; i++) { var id = timelines[i].getPropertyId(); if (!propertyIDs.add(id)) timelineMode[i] = AnimationState.SUBSEQUENT; else if (to == null || !this.hasTimeline(to, id)) timelineMode[i] = AnimationState.FIRST; else { for (var next = to.mixingTo; next != null; next = next.mixingTo) { if (this.hasTimeline(next, id)) continue; if (entry.mixDuration > 0) { timelineMode[i] = AnimationState.HOLD_MIX; timelineDipMix[i] = next; continue outer; } break; } timelineMode[i] = AnimationState.HOLD; } } }; AnimationState.prototype.hasTimeline = function (entry, id) { var timelines = entry.animation.timelines; for (var i = 0, n = timelines.length; i < n; i++) if (timelines[i].getPropertyId() == id) return true; return false; }; AnimationState.prototype.getCurrent = function (trackIndex) { if (trackIndex >= this.tracks.length) return null; return this.tracks[trackIndex]; }; AnimationState.prototype.addListener = function (listener) { if (listener == null) throw new Error("listener cannot be null."); this.listeners.push(listener); }; AnimationState.prototype.removeListener = function (listener) { var index = this.listeners.indexOf(listener); if (index >= 0) this.listeners.splice(index, 1); }; AnimationState.prototype.clearListeners = function () { this.listeners.length = 0; }; AnimationState.prototype.clearListenerNotifications = function () { this.queue.clear(); }; AnimationState.emptyAnimation = new spine.Animation("", [], 0); AnimationState.SUBSEQUENT = 0; AnimationState.FIRST = 1; AnimationState.HOLD = 2; AnimationState.HOLD_MIX = 3; return AnimationState; }()); spine.AnimationState = AnimationState; var TrackEntry = (function () { function TrackEntry() { this.mixBlend = spine.MixBlend.replace; this.timelineMode = new Array(); this.timelineHoldMix = new Array(); this.timelinesRotation = new Array(); } TrackEntry.prototype.reset = function () { this.next = null; this.mixingFrom = null; this.mixingTo = null; this.animation = null; this.listener = null; this.timelineMode.length = 0; this.timelineHoldMix.length = 0; this.timelinesRotation.length = 0; }; TrackEntry.prototype.getAnimationTime = function () { if (this.loop) { var duration = this.animationEnd - this.animationStart; if (duration == 0) return this.animationStart; return (this.trackTime % duration) + this.animationStart; } return Math.min(this.trackTime + this.animationStart, this.animationEnd); }; TrackEntry.prototype.setAnimationLast = function (animationLast) { this.animationLast = animationLast; this.nextAnimationLast = animationLast; }; TrackEntry.prototype.isComplete = function () { return this.trackTime >= this.animationEnd - this.animationStart; }; TrackEntry.prototype.resetRotationDirections = function () { this.timelinesRotation.length = 0; }; return TrackEntry; }()); spine.TrackEntry = TrackEntry; var EventQueue = (function () { function EventQueue(animState) { this.objects = []; this.drainDisabled = false; this.animState = animState; } EventQueue.prototype.start = function (entry) { this.objects.push(EventType.start); this.objects.push(entry); this.animState.animationsChanged = true; }; EventQueue.prototype.interrupt = function (entry) { this.objects.push(EventType.interrupt); this.objects.push(entry); }; EventQueue.prototype.end = function (entry) { this.objects.push(EventType.end); this.objects.push(entry); this.animState.animationsChanged = true; }; EventQueue.prototype.dispose = function (entry) { this.objects.push(EventType.dispose); this.objects.push(entry); }; EventQueue.prototype.complete = function (entry) { this.objects.push(EventType.complete); this.objects.push(entry); }; EventQueue.prototype.event = function (entry, event) { this.objects.push(EventType.event); this.objects.push(entry); this.objects.push(event); }; EventQueue.prototype.drain = function () { if (this.drainDisabled) return; this.drainDisabled = true; var objects = this.objects; var listeners = this.animState.listeners; for (var i = 0; i < objects.length; i += 2) { var type = objects[i]; var entry = objects[i + 1]; switch (type) { case EventType.start: if (entry.listener != null && entry.listener.start) entry.listener.start(entry); for (var ii = 0; ii < listeners.length; ii++) if (listeners[ii].start) listeners[ii].start(entry); break; case EventType.interrupt: if (entry.listener != null && entry.listener.interrupt) entry.listener.interrupt(entry); for (var ii = 0; ii < listeners.length; ii++) if (listeners[ii].interrupt) listeners[ii].interrupt(entry); break; case EventType.end: if (entry.listener != null && entry.listener.end) entry.listener.end(entry); for (var ii = 0; ii < listeners.length; ii++) if (listeners[ii].end) listeners[ii].end(entry); case EventType.dispose: if (entry.listener != null && entry.listener.dispose) entry.listener.dispose(entry); for (var ii = 0; ii < listeners.length; ii++) if (listeners[ii].dispose) listeners[ii].dispose(entry); this.animState.trackEntryPool.free(entry); break; case EventType.complete: if (entry.listener != null && entry.listener.complete) entry.listener.complete(entry); for (var ii = 0; ii < listeners.length; ii++) if (listeners[ii].complete) listeners[ii].complete(entry); break; case EventType.event: var event_3 = objects[i++ + 2]; if (entry.listener != null && entry.listener.event) entry.listener.event(entry, event_3); for (var ii = 0; ii < listeners.length; ii++) if (listeners[ii].event) listeners[ii].event(entry, event_3); break; } } this.clear(); this.drainDisabled = false; }; EventQueue.prototype.clear = function () { this.objects.length = 0; }; return EventQueue; }()); spine.EventQueue = EventQueue; var EventType; (function (EventType) { EventType[EventType["start"] = 0] = "start"; EventType[EventType["interrupt"] = 1] = "interrupt"; EventType[EventType["end"] = 2] = "end"; EventType[EventType["dispose"] = 3] = "dispose"; EventType[EventType["complete"] = 4] = "complete"; EventType[EventType["event"] = 5] = "event"; })(EventType = spine.EventType || (spine.EventType = {})); var AnimationStateAdapter2 = (function () { function AnimationStateAdapter2() { } AnimationStateAdapter2.prototype.start = function (entry) { }; AnimationStateAdapter2.prototype.interrupt = function (entry) { }; AnimationStateAdapter2.prototype.end = function (entry) { }; AnimationStateAdapter2.prototype.dispose = function (entry) { }; AnimationStateAdapter2.prototype.complete = function (entry) { }; AnimationStateAdapter2.prototype.event = function (entry, event) { }; return AnimationStateAdapter2; }()); spine.AnimationStateAdapter2 = AnimationStateAdapter2; })(spine || (spine = {})); var spine; (function (spine) { var AnimationStateData = (function () { function AnimationStateData(skeletonData) { this.animationToMixTime = {}; this.defaultMix = 0; if (skeletonData == null) throw new Error("skeletonData cannot be null."); this.skeletonData = skeletonData; } AnimationStateData.prototype.setMix = function (fromName, toName, duration) { var from = this.skeletonData.findAnimation(fromName); if (from == null) throw new Error("Animation not found: " + fromName); var to = this.skeletonData.findAnimation(toName); if (to == null) throw new Error("Animation not found: " + toName); this.setMixWith(from, to, duration); }; AnimationStateData.prototype.setMixWith = function (from, to, duration) { if (from == null) throw new Error("from cannot be null."); if (to == null) throw new Error("to cannot be null."); var key = from.name + "." + to.name; this.animationToMixTime[key] = duration; }; AnimationStateData.prototype.getMix = function (from, to) { var key = from.name + "." + to.name; var value = this.animationToMixTime[key]; return value === undefined ? this.defaultMix : value; }; return AnimationStateData; }()); spine.AnimationStateData = AnimationStateData; })(spine || (spine = {})); var spine; (function (spine) { var AssetManager = (function () { function AssetManager(textureLoader, pathPrefix) { if (pathPrefix === void 0) { pathPrefix = ""; } this.assets = {}; this.errors = {}; this.toLoad = 0; this.loaded = 0; this.textureLoader = textureLoader; this.pathPrefix = pathPrefix; } AssetManager.downloadText = function (url, success, error) { var request = new XMLHttpRequest(); request.open("GET", url, true); request.onload = function () { if (request.status == 200) { success(request.responseText); } else { error(request.status, request.responseText); } }; request.onerror = function () { error(request.status, request.responseText); }; request.send(); }; AssetManager.downloadBinary = function (url, success, error) { var request = new XMLHttpRequest(); request.open("GET", url, true); request.responseType = "arraybuffer"; request.onload = function () { if (request.status == 200) { success(new Uint8Array(request.response)); } else { error(request.status, request.responseText); } }; request.onerror = function () { error(request.status, request.responseText); }; request.send(); }; AssetManager.prototype.loadText = function (path, success, error) { var _this = this; if (success === void 0) { success = null; } if (error === void 0) { error = null; } path = this.pathPrefix + path; this.toLoad++; AssetManager.downloadText(path, function (data) { _this.assets[path] = data; if (success) success(path, data); _this.toLoad--; _this.loaded++; }, function (state, responseText) { _this.errors[path] = "Couldn't load text " + path + ": status " + status + ", " + responseText; if (error) error(path, "Couldn't load text " + path + ": status " + status + ", " + responseText); _this.toLoad--; _this.loaded++; }); }; AssetManager.prototype.loadTexture = function (path, success, error) { var _this = this; if (success === void 0) { success = null; } if (error === void 0) { error = null; } path = this.pathPrefix + path; this.toLoad++; var img = new Image(); img.crossOrigin = "anonymous"; img.onload = function (ev) { var texture = _this.textureLoader(img); _this.assets[path] = texture; _this.toLoad--; _this.loaded++; if (success) success(path, img); }; img.onerror = function (ev) { _this.errors[path] = "Couldn't load image " + path; _this.toLoad--; _this.loaded++; if (error) error(path, "Couldn't load image " + path); }; img.src = path; }; AssetManager.prototype.loadTextureData = function (path, data, success, error) { var _this = this; if (success === void 0) { success = null; } if (error === void 0) { error = null; } path = this.pathPrefix + path; this.toLoad++; var img = new Image(); img.onload = function (ev) { var texture = _this.textureLoader(img); _this.assets[path] = texture; _this.toLoad--; _this.loaded++; if (success) success(path, img); }; img.onerror = function (ev) { _this.errors[path] = "Couldn't load image " + path; _this.toLoad--; _this.loaded++; if (error) error(path, "Couldn't load image " + path); }; img.src = data; }; AssetManager.prototype.loadTextureAtlas = function (path, success, error) { var _this = this; if (success === void 0) { success = null; } if (error === void 0) { error = null; } var parent = path.lastIndexOf("/") >= 0 ? path.substring(0, path.lastIndexOf("/")) : ""; path = this.pathPrefix + path; this.toLoad++; AssetManager.downloadText(path, function (atlasData) { var pagesLoaded = { count: 0 }; var atlasPages = new Array(); try { var atlas = new spine.TextureAtlas(atlasData, function (path) { atlasPages.push(parent + "/" + path); var image = document.createElement("img"); image.width = 16; image.height = 16; return new spine.FakeTexture(image); }); } catch (e) { var ex = e; _this.errors[path] = "Couldn't load texture atlas " + path + ": " + ex.message; if (error) error(path, "Couldn't load texture atlas " + path + ": " + ex.message); _this.toLoad--; _this.loaded++; return; } var _loop_1 = function (atlasPage) { var pageLoadError = false; _this.loadTexture(atlasPage, function (imagePath, image) { pagesLoaded.count++; if (pagesLoaded.count == atlasPages.length) { if (!pageLoadError) { try { var atlas = new spine.TextureAtlas(atlasData, function (path) { return _this.get(parent + "/" + path); }); _this.assets[path] = atlas; if (success) success(path, atlas); _this.toLoad--; _this.loaded++; } catch (e) { var ex = e; _this.errors[path] = "Couldn't load texture atlas " + path + ": " + ex.message; if (error) error(path, "Couldn't load texture atlas " + path + ": " + ex.message); _this.toLoad--; _this.loaded++; } } else { _this.errors[path] = "Couldn't load texture atlas page " + imagePath + "} of atlas " + path; if (error) error(path, "Couldn't load texture atlas page " + imagePath + " of atlas " + path); _this.toLoad--; _this.loaded++; } } }, function (imagePath, errorMessage) { pageLoadError = true; pagesLoaded.count++; if (pagesLoaded.count == atlasPages.length) { _this.errors[path] = "Couldn't load texture atlas page " + imagePath + "} of atlas " + path; if (error) error(path, "Couldn't load texture atlas page " + imagePath + " of atlas " + path); _this.toLoad--; _this.loaded++; } }); }; for (var _i = 0, atlasPages_1 = atlasPages; _i < atlasPages_1.length; _i++) { var atlasPage = atlasPages_1[_i]; _loop_1(atlasPage); } }, function (state, responseText) { _this.errors[path] = "Couldn't load texture atlas " + path + ": status " + status + ", " + responseText; if (error) error(path, "Couldn't load texture atlas " + path + ": status " + status + ", " + responseText); _this.toLoad--; _this.loaded++; }); }; AssetManager.prototype.get = function (path) { path = this.pathPrefix + path; return this.assets[path]; }; AssetManager.prototype.remove = function (path) { path = this.pathPrefix + path; var asset = this.assets[path]; if (asset.dispose) asset.dispose(); this.assets[path] = null; }; AssetManager.prototype.removeAll = function () { for (var key in this.assets) { var asset = this.assets[key]; if (asset.dispose) asset.dispose(); } this.assets = {}; }; AssetManager.prototype.isLoadingComplete = function () { return this.toLoad == 0; }; AssetManager.prototype.getToLoad = function () { return this.toLoad; }; AssetManager.prototype.getLoaded = function () { return this.loaded; }; AssetManager.prototype.dispose = function () { this.removeAll(); }; AssetManager.prototype.hasErrors = function () { return Object.keys(this.errors).length > 0; }; AssetManager.prototype.getErrors = function () { return this.errors; }; return AssetManager; }()); spine.AssetManager = AssetManager; })(spine || (spine = {})); var spine; (function (spine) { var AtlasAttachmentLoader = (function () { function AtlasAttachmentLoader(atlas) { this.atlas = atlas; } AtlasAttachmentLoader.prototype.newRegionAttachment = function (skin, name, path) { var region = this.atlas.findRegion(path); if (region == null) // throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")"); return null; region.renderObject = region; var attachment = new spine.RegionAttachment(name); attachment.setRegion(region); return attachment; }; AtlasAttachmentLoader.prototype.newMeshAttachment = function (skin, name, path) { var region = this.atlas.findRegion(path); if (region == null) // throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")"); return null; region.renderObject = region; var attachment = new spine.MeshAttachment(name); attachment.region = region; return attachment; }; AtlasAttachmentLoader.prototype.newBoundingBoxAttachment = function (skin, name) { return new spine.BoundingBoxAttachment(name); }; AtlasAttachmentLoader.prototype.newPathAttachment = function (skin, name) { return new spine.PathAttachment(name); }; AtlasAttachmentLoader.prototype.newPointAttachment = function (skin, name) { return new spine.PointAttachment(name); }; AtlasAttachmentLoader.prototype.newClippingAttachment = function (skin, name) { return new spine.ClippingAttachment(name); }; return AtlasAttachmentLoader; }()); spine.AtlasAttachmentLoader = AtlasAttachmentLoader; })(spine || (spine = {})); var spine; (function (spine) { var BlendMode; (function (BlendMode) { BlendMode[BlendMode["Normal"] = 0] = "Normal"; BlendMode[BlendMode["Additive"] = 1] = "Additive"; BlendMode[BlendMode["Multiply"] = 2] = "Multiply"; BlendMode[BlendMode["Screen"] = 3] = "Screen"; })(BlendMode = spine.BlendMode || (spine.BlendMode = {})); })(spine || (spine = {})); var spine; (function (spine) { var Bone = (function () { function Bone(data, skeleton, parent) { this.children = new Array(); this.x = 0; this.y = 0; this.rotation = 0; this.scaleX = 0; this.scaleY = 0; this.shearX = 0; this.shearY = 0; this.ax = 0; this.ay = 0; this.arotation = 0; this.ascaleX = 0; this.ascaleY = 0; this.ashearX = 0; this.ashearY = 0; this.appliedValid = false; this.a = 0; this.b = 0; this.worldX = 0; this.c = 0; this.d = 0; this.worldY = 0; this.sorted = false; if (data == null) throw new Error("data cannot be null."); if (skeleton == null) throw new Error("skeleton cannot be null."); this.data = data; this.skeleton = skeleton; this.parent = parent; this.setToSetupPose(); } Bone.prototype.update = function () { this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY); }; Bone.prototype.updateWorldTransform = function () { this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY); }; Bone.prototype.updateWorldTransformWith = function (x, y, rotation, scaleX, scaleY, shearX, shearY) { this.ax = x; this.ay = y; this.arotation = rotation; this.ascaleX = scaleX; this.ascaleY = scaleY; this.ashearX = shearX; this.ashearY = shearY; this.appliedValid = true; var parent = this.parent; if (parent == null) { var skeleton = this.skeleton; var rotationY = rotation + 90 + shearY; var sx = skeleton.scaleX; var sy = skeleton.scaleY; this.a = spine.MathUtils.cosDeg(rotation + shearX) * scaleX * sx; this.b = spine.MathUtils.cosDeg(rotationY) * scaleY * sx; this.c = spine.MathUtils.sinDeg(rotation + shearX) * scaleX * sy; this.d = spine.MathUtils.sinDeg(rotationY) * scaleY * sy; this.worldX = x * sx + skeleton.x; this.worldY = y * sy + skeleton.y; return; } var pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d; this.worldX = pa * x + pb * y + parent.worldX; this.worldY = pc * x + pd * y + parent.worldY; switch (this.data.transformMode) { case spine.TransformMode.Normal: { var rotationY = rotation + 90 + shearY; var la = spine.MathUtils.cosDeg(rotation + shearX) * scaleX; var lb = spine.MathUtils.cosDeg(rotationY) * scaleY; var lc = spine.MathUtils.sinDeg(rotation + shearX) * scaleX; var ld = spine.MathUtils.sinDeg(rotationY) * scaleY; this.a = pa * la + pb * lc; this.b = pa * lb + pb * ld; this.c = pc * la + pd * lc; this.d = pc * lb + pd * ld; return; } case spine.TransformMode.OnlyTranslation: { var rotationY = rotation + 90 + shearY; this.a = spine.MathUtils.cosDeg(rotation + shearX) * scaleX; this.b = spine.MathUtils.cosDeg(rotationY) * scaleY; this.c = spine.MathUtils.sinDeg(rotation + shearX) * scaleX; this.d = spine.MathUtils.sinDeg(rotationY) * scaleY; break; } case spine.TransformMode.NoRotationOrReflection: { var s = pa * pa + pc * pc; var prx = 0; if (s > 0.0001) { s = Math.abs(pa * pd - pb * pc) / s; pb = pc * s; pd = pa * s; prx = Math.atan2(pc, pa) * spine.MathUtils.radDeg; } else { pa = 0; pc = 0; prx = 90 - Math.atan2(pd, pb) * spine.MathUtils.radDeg; } var rx = rotation + shearX - prx; var ry = rotation + shearY - prx + 90; var la = spine.MathUtils.cosDeg(rx) * scaleX; var lb = spine.MathUtils.cosDeg(ry) * scaleY; var lc = spine.MathUtils.sinDeg(rx) * scaleX; var ld = spine.MathUtils.sinDeg(ry) * scaleY; this.a = pa * la - pb * lc; this.b = pa * lb - pb * ld; this.c = pc * la + pd * lc; this.d = pc * lb + pd * ld; break; } case spine.TransformMode.NoScale: case spine.TransformMode.NoScaleOrReflection: { var cos = spine.MathUtils.cosDeg(rotation); var sin = spine.MathUtils.sinDeg(rotation); var za = (pa * cos + pb * sin) / this.skeleton.scaleX; var zc = (pc * cos + pd * sin) / this.skeleton.scaleY; var s = Math.sqrt(za * za + zc * zc); if (s > 0.00001) s = 1 / s; za *= s; zc *= s; s = Math.sqrt(za * za + zc * zc); if (this.data.transformMode == spine.TransformMode.NoScale && (pa * pd - pb * pc < 0) != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0)) s = -s; var r = Math.PI / 2 + Math.atan2(zc, za); var zb = Math.cos(r) * s; var zd = Math.sin(r) * s; var la = spine.MathUtils.cosDeg(shearX) * scaleX; var lb = spine.MathUtils.cosDeg(90 + shearY) * scaleY; var lc = spine.MathUtils.sinDeg(shearX) * scaleX; var ld = spine.MathUtils.sinDeg(90 + shearY) * scaleY; this.a = za * la + zb * lc; this.b = za * lb + zb * ld; this.c = zc * la + zd * lc; this.d = zc * lb + zd * ld; break; } } this.a *= this.skeleton.scaleX; this.b *= this.skeleton.scaleX; this.c *= this.skeleton.scaleY; this.d *= this.skeleton.scaleY; }; Bone.prototype.setToSetupPose = function () { var data = this.data; this.x = data.x; this.y = data.y; this.rotation = data.rotation; this.scaleX = data.scaleX; this.scaleY = data.scaleY; this.shearX = data.shearX; this.shearY = data.shearY; }; Bone.prototype.getWorldRotationX = function () { return Math.atan2(this.c, this.a) * spine.MathUtils.radDeg; }; Bone.prototype.getWorldRotationY = function () { return Math.atan2(this.d, this.b) * spine.MathUtils.radDeg; }; Bone.prototype.getWorldScaleX = function () { return Math.sqrt(this.a * this.a + this.c * this.c); }; Bone.prototype.getWorldScaleY = function () { return Math.sqrt(this.b * this.b + this.d * this.d); }; Bone.prototype.updateAppliedTransform = function () { this.appliedValid = true; var parent = this.parent; if (parent == null) { this.ax = this.worldX; this.ay = this.worldY; this.arotation = Math.atan2(this.c, this.a) * spine.MathUtils.radDeg; this.ascaleX = Math.sqrt(this.a * this.a + this.c * this.c); this.ascaleY = Math.sqrt(this.b * this.b + this.d * this.d); this.ashearX = 0; this.ashearY = Math.atan2(this.a * this.b + this.c * this.d, this.a * this.d - this.b * this.c) * spine.MathUtils.radDeg; return; } var pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d; var pid = 1 / (pa * pd - pb * pc); var dx = this.worldX - parent.worldX, dy = this.worldY - parent.worldY; this.ax = (dx * pd * pid - dy * pb * pid); this.ay = (dy * pa * pid - dx * pc * pid); var ia = pid * pd; var id = pid * pa; var ib = pid * pb; var ic = pid * pc; var ra = ia * this.a - ib * this.c; var rb = ia * this.b - ib * this.d; var rc = id * this.c - ic * this.a; var rd = id * this.d - ic * this.b; this.ashearX = 0; this.ascaleX = Math.sqrt(ra * ra + rc * rc); if (this.ascaleX > 0.0001) { var det = ra * rd - rb * rc; this.ascaleY = det / this.ascaleX; this.ashearY = Math.atan2(ra * rb + rc * rd, det) * spine.MathUtils.radDeg; this.arotation = Math.atan2(rc, ra) * spine.MathUtils.radDeg; } else { this.ascaleX = 0; this.ascaleY = Math.sqrt(rb * rb + rd * rd); this.ashearY = 0; this.arotation = 90 - Math.atan2(rd, rb) * spine.MathUtils.radDeg; } }; Bone.prototype.worldToLocal = function (world) { var a = this.a, b = this.b, c = this.c, d = this.d; var invDet = 1 / (a * d - b * c); var x = world.x - this.worldX, y = world.y - this.worldY; world.x = (x * d * invDet - y * b * invDet); world.y = (y * a * invDet - x * c * invDet); return world; }; Bone.prototype.localToWorld = function (local) { var x = local.x, y = local.y; local.x = x * this.a + y * this.b + this.worldX; local.y = x * this.c + y * this.d + this.worldY; return local; }; Bone.prototype.worldToLocalRotation = function (worldRotation) { var sin = spine.MathUtils.sinDeg(worldRotation), cos = spine.MathUtils.cosDeg(worldRotation); return Math.atan2(this.a * sin - this.c * cos, this.d * cos - this.b * sin) * spine.MathUtils.radDeg + this.rotation - this.shearX; }; Bone.prototype.localToWorldRotation = function (localRotation) { localRotation -= this.rotation - this.shearX; var sin = spine.MathUtils.sinDeg(localRotation), cos = spine.MathUtils.cosDeg(localRotation); return Math.atan2(cos * this.c + sin * this.d, cos * this.a + sin * this.b) * spine.MathUtils.radDeg; }; Bone.prototype.rotateWorld = function (degrees) { var a = this.a, b = this.b, c = this.c, d = this.d; var cos = spine.MathUtils.cosDeg(degrees), sin = spine.MathUtils.sinDeg(degrees); this.a = cos * a - sin * c; this.b = cos * b - sin * d; this.c = sin * a + cos * c; this.d = sin * b + cos * d; this.appliedValid = false; }; return Bone; }()); spine.Bone = Bone; })(spine || (spine = {})); var spine; (function (spine) { var BoneData = (function () { function BoneData(index, name, parent) { this.x = 0; this.y = 0; this.rotation = 0; this.scaleX = 1; this.scaleY = 1; this.shearX = 0; this.shearY = 0; this.transformMode = TransformMode.Normal; if (index < 0) throw new Error("index must be >= 0."); if (name == null) throw new Error("name cannot be null."); this.index = index; this.name = name; this.parent = parent; } return BoneData; }()); spine.BoneData = BoneData; var TransformMode; (function (TransformMode) { TransformMode[TransformMode["Normal"] = 0] = "Normal"; TransformMode[TransformMode["OnlyTranslation"] = 1] = "OnlyTranslation"; TransformMode[TransformMode["NoRotationOrReflection"] = 2] = "NoRotationOrReflection"; TransformMode[TransformMode["NoScale"] = 3] = "NoScale"; TransformMode[TransformMode["NoScaleOrReflection"] = 4] = "NoScaleOrReflection"; })(TransformMode = spine.TransformMode || (spine.TransformMode = {})); })(spine || (spine = {})); var spine; (function (spine) { var Event = (function () { function Event(time, data) { if (data == null) throw new Error("data cannot be null."); this.time = time; this.data = data; } return Event; }()); spine.Event = Event; })(spine || (spine = {})); var spine; (function (spine) { var EventData = (function () { function EventData(name) { this.name = name; } return EventData; }()); spine.EventData = EventData; })(spine || (spine = {})); var spine; (function (spine) { var IkConstraint = (function () { function IkConstraint(data, skeleton) { this.bendDirection = 0; this.compress = false; this.stretch = false; this.mix = 1; if (data == null) throw new Error("data cannot be null."); if (skeleton == null) throw new Error("skeleton cannot be null."); this.data = data; this.mix = data.mix; this.bendDirection = data.bendDirection; this.compress = data.compress; this.stretch = data.stretch; this.bones = new Array(); for (var i = 0; i < data.bones.length; i++) this.bones.push(skeleton.findBone(data.bones[i].name)); this.target = skeleton.findBone(data.target.name); } IkConstraint.prototype.getOrder = function () { return this.data.order; }; IkConstraint.prototype.apply = function () { this.update(); }; IkConstraint.prototype.update = function () { var target = this.target; var bones = this.bones; switch (bones.length) { case 1: this.apply1(bones[0], target.worldX, target.worldY, this.compress, this.stretch, this.data.uniform, this.mix); break; case 2: this.apply2(bones[0], bones[1], target.worldX, target.worldY, this.bendDirection, this.stretch, this.mix); break; } }; IkConstraint.prototype.apply1 = function (bone, targetX, targetY, compress, stretch, uniform, alpha) { if (!bone.appliedValid) bone.updateAppliedTransform(); var p = bone.parent; var id = 1 / (p.a * p.d - p.b * p.c); var x = targetX - p.worldX, y = targetY - p.worldY; var tx = (x * p.d - y * p.b) * id - bone.ax, ty = (y * p.a - x * p.c) * id - bone.ay; var rotationIK = Math.atan2(ty, tx) * spine.MathUtils.radDeg - bone.ashearX - bone.arotation; if (bone.ascaleX < 0) rotationIK += 180; if (rotationIK > 180) rotationIK -= 360; else if (rotationIK < -180) rotationIK += 360; var sx = bone.ascaleX, sy = bone.ascaleY; if (compress || stretch) { var b = bone.data.length * sx, dd = Math.sqrt(tx * tx + ty * ty); if ((compress && dd < b) || (stretch && dd > b) && b > 0.0001) { var s = (dd / b - 1) * alpha + 1; sx *= s; if (uniform) sy *= s; } } bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, sx, sy, bone.ashearX, bone.ashearY); }; IkConstraint.prototype.apply2 = function (parent, child, targetX, targetY, bendDir, stretch, alpha) { if (alpha == 0) { child.updateWorldTransform(); return; } if (!parent.appliedValid) parent.updateAppliedTransform(); if (!child.appliedValid) child.updateAppliedTransform(); var px = parent.ax, py = parent.ay, psx = parent.ascaleX, sx = psx, psy = parent.ascaleY, csx = child.ascaleX; var os1 = 0, os2 = 0, s2 = 0; if (psx < 0) { psx = -psx; os1 = 180; s2 = -1; } else { os1 = 0; s2 = 1; } if (psy < 0) { psy = -psy; s2 = -s2; } if (csx < 0) { csx = -csx; os2 = 180; } else os2 = 0; var cx = child.ax, cy = 0, cwx = 0, cwy = 0, a = parent.a, b = parent.b, c = parent.c, d = parent.d; var u = Math.abs(psx - psy) <= 0.0001; if (!u) { cy = 0; cwx = a * cx + parent.worldX; cwy = c * cx + parent.worldY; } else { cy = child.ay; cwx = a * cx + b * cy + parent.worldX; cwy = c * cx + d * cy + parent.worldY; } var pp = parent.parent; a = pp.a; b = pp.b; c = pp.c; d = pp.d; var id = 1 / (a * d - b * c), x = targetX - pp.worldX, y = targetY - pp.worldY; var tx = (x * d - y * b) * id - px, ty = (y * a - x * c) * id - py, dd = tx * tx + ty * ty; x = cwx - pp.worldX; y = cwy - pp.worldY; var dx = (x * d - y * b) * id - px, dy = (y * a - x * c) * id - py; var l1 = Math.sqrt(dx * dx + dy * dy), l2 = child.data.length * csx, a1 = 0, a2 = 0; outer: if (u) { l2 *= psx; var cos = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2); if (cos < -1) cos = -1; else if (cos > 1) { cos = 1; if (stretch && l1 + l2 > 0.0001) sx *= (Math.sqrt(dd) / (l1 + l2) - 1) * alpha + 1; } a2 = Math.acos(cos) * bendDir; a = l1 + l2 * cos; b = l2 * Math.sin(a2); a1 = Math.atan2(ty * a - tx * b, tx * a + ty * b); } else { a = psx * l2; b = psy * l2; var aa = a * a, bb = b * b, ta = Math.atan2(ty, tx); c = bb * l1 * l1 + aa * dd - aa * bb; var c1 = -2 * bb * l1, c2 = bb - aa; d = c1 * c1 - 4 * c2 * c; if (d >= 0) { var q = Math.sqrt(d); if (c1 < 0) q = -q; q = -(c1 + q) / 2; var r0 = q / c2, r1 = c / q; var r = Math.abs(r0) < Math.abs(r1) ? r0 : r1; if (r * r <= dd) { y = Math.sqrt(dd - r * r) * bendDir; a1 = ta - Math.atan2(y, r); a2 = Math.atan2(y / psy, (r - l1) / psx); break outer; } } var minAngle = spine.MathUtils.PI, minX = l1 - a, minDist = minX * minX, minY = 0; var maxAngle = 0, maxX = l1 + a, maxDist = maxX * maxX, maxY = 0; c = -a * l1 / (aa - bb); if (c >= -1 && c <= 1) { c = Math.acos(c); x = a * Math.cos(c) + l1; y = b * Math.sin(c); d = x * x + y * y; if (d < minDist) { minAngle = c; minDist = d; minX = x; minY = y; } if (d > maxDist) { maxAngle = c; maxDist = d; maxX = x; maxY = y; } } if (dd <= (minDist + maxDist) / 2) { a1 = ta - Math.atan2(minY * bendDir, minX); a2 = minAngle * bendDir; } else { a1 = ta - Math.atan2(maxY * bendDir, maxX); a2 = maxAngle * bendDir; } } var os = Math.atan2(cy, cx) * s2; var rotation = parent.arotation; a1 = (a1 - os) * spine.MathUtils.radDeg + os1 - rotation; if (a1 > 180) a1 -= 360; else if (a1 < -180) a1 += 360; parent.updateWorldTransformWith(px, py, rotation + a1 * alpha, sx, parent.ascaleY, 0, 0); rotation = child.arotation; a2 = ((a2 + os) * spine.MathUtils.radDeg - child.ashearX) * s2 + os2 - rotation; if (a2 > 180) a2 -= 360; else if (a2 < -180) a2 += 360; child.updateWorldTransformWith(cx, cy, rotation + a2 * alpha, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY); }; return IkConstraint; }()); spine.IkConstraint = IkConstraint; })(spine || (spine = {})); var spine; (function (spine) { var IkConstraintData = (function () { function IkConstraintData(name) { this.order = 0; this.bones = new Array(); this.bendDirection = 1; this.compress = false; this.stretch = false; this.uniform = false; this.mix = 1; this.name = name; } return IkConstraintData; }()); spine.IkConstraintData = IkConstraintData; })(spine || (spine = {})); var spine; (function (spine) { var PathConstraint = (function () { function PathConstraint(data, skeleton) { this.position = 0; this.spacing = 0; this.rotateMix = 0; this.translateMix = 0; this.spaces = new Array(); this.positions = new Array(); this.world = new Array(); this.curves = new Array(); this.lengths = new Array(); this.segments = new Array(); if (data == null) throw new Error("data cannot be null."); if (skeleton == null) throw new Error("skeleton cannot be null."); this.data = data; this.bones = new Array(); for (var i = 0, n = data.bones.length; i < n; i++) this.bones.push(skeleton.findBone(data.bones[i].name)); this.target = skeleton.findSlot(data.target.name); this.position = data.position; this.spacing = data.spacing; this.rotateMix = data.rotateMix; this.translateMix = data.translateMix; } PathConstraint.prototype.apply = function () { this.update(); }; PathConstraint.prototype.update = function () { var attachment = this.target.getAttachment(); if (!(attachment instanceof spine.PathAttachment)) return; var rotateMix = this.rotateMix, translateMix = this.translateMix; var translate = translateMix > 0, rotate = rotateMix > 0; if (!translate && !rotate) return; var data = this.data; var percentSpacing = data.spacingMode == spine.SpacingMode.Percent; var rotateMode = data.rotateMode; var tangents = rotateMode == spine.RotateMode.Tangent, scale = rotateMode == spine.RotateMode.ChainScale; var boneCount = this.bones.length, spacesCount = tangents ? boneCount : boneCount + 1; var bones = this.bones; var spaces = spine.Utils.setArraySize(this.spaces, spacesCount), lengths = null; var spacing = this.spacing; if (scale || !percentSpacing) { if (scale) lengths = spine.Utils.setArraySize(this.lengths, boneCount); var lengthSpacing = data.spacingMode == spine.SpacingMode.Length; for (var i = 0, n = spacesCount - 1; i < n;) { var bone = bones[i]; var setupLength = bone.data.length; if (setupLength < PathConstraint.epsilon) { if (scale) lengths[i] = 0; spaces[++i] = 0; } else if (percentSpacing) { if (scale) { var x = setupLength * bone.a, y = setupLength * bone.c; var length_1 = Math.sqrt(x * x + y * y); lengths[i] = length_1; } spaces[++i] = spacing; } else { var x = setupLength * bone.a, y = setupLength * bone.c; var length_2 = Math.sqrt(x * x + y * y); if (scale) lengths[i] = length_2; spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length_2 / setupLength; } } } else { for (var i = 1; i < spacesCount; i++) spaces[i] = spacing; } var positions = this.computeWorldPositions(attachment, spacesCount, tangents, data.positionMode == spine.PositionMode.Percent, percentSpacing); var boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation; var tip = false; if (offsetRotation == 0) tip = rotateMode == spine.RotateMode.Chain; else { tip = false; var p = this.target.bone; offsetRotation *= p.a * p.d - p.b * p.c > 0 ? spine.MathUtils.degRad : -spine.MathUtils.degRad; } for (var i = 0, p = 3; i < boneCount; i++, p += 3) { var bone = bones[i]; bone.worldX += (boneX - bone.worldX) * translateMix; bone.worldY += (boneY - bone.worldY) * translateMix; var x = positions[p], y = positions[p + 1], dx = x - boneX, dy = y - boneY; if (scale) { var length_3 = lengths[i]; if (length_3 != 0) { var s = (Math.sqrt(dx * dx + dy * dy) / length_3 - 1) * rotateMix + 1; bone.a *= s; bone.c *= s; } } boneX = x; boneY = y; if (rotate) { var a = bone.a, b = bone.b, c = bone.c, d = bone.d, r = 0, cos = 0, sin = 0; if (tangents) r = positions[p - 1]; else if (spaces[i + 1] == 0) r = positions[p + 2]; else r = Math.atan2(dy, dx); r -= Math.atan2(c, a); if (tip) { cos = Math.cos(r); sin = Math.sin(r); var length_4 = bone.data.length; boneX += (length_4 * (cos * a - sin * c) - dx) * rotateMix; boneY += (length_4 * (sin * a + cos * c) - dy) * rotateMix; } else { r += offsetRotation; } if (r > spine.MathUtils.PI) r -= spine.MathUtils.PI2; else if (r < -spine.MathUtils.PI) r += spine.MathUtils.PI2; r *= rotateMix; cos = Math.cos(r); sin = Math.sin(r); bone.a = cos * a - sin * c; bone.b = cos * b - sin * d; bone.c = sin * a + cos * c; bone.d = sin * b + cos * d; } bone.appliedValid = false; } }; PathConstraint.prototype.computeWorldPositions = function (path, spacesCount, tangents, percentPosition, percentSpacing) { var target = this.target; var position = this.position; var spaces = this.spaces, out = spine.Utils.setArraySize(this.positions, spacesCount * 3 + 2), world = null; var closed = path.closed; var verticesLength = path.worldVerticesLength, curveCount = verticesLength / 6, prevCurve = PathConstraint.NONE; if (!path.constantSpeed) { var lengths = path.lengths; curveCount -= closed ? 1 : 2; var pathLength_1 = lengths[curveCount]; if (percentPosition) position *= pathLength_1; if (percentSpacing) { for (var i = 1; i < spacesCount; i++) spaces[i] *= pathLength_1; } world = spine.Utils.setArraySize(this.world, 8); for (var i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) { var space = spaces[i]; position += space; var p = position; if (closed) { p %= pathLength_1; if (p < 0) p += pathLength_1; curve = 0; } else if (p < 0) { if (prevCurve != PathConstraint.BEFORE) { prevCurve = PathConstraint.BEFORE; path.computeWorldVertices(target, 2, 4, world, 0, 2); } this.addBeforePosition(p, world, 0, out, o); continue; } else if (p > pathLength_1) { if (prevCurve != PathConstraint.AFTER) { prevCurve = PathConstraint.AFTER; path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2); } this.addAfterPosition(p - pathLength_1, world, 0, out, o); continue; } for (;; curve++) { var length_5 = lengths[curve]; if (p > length_5) continue; if (curve == 0) p /= length_5; else { var prev = lengths[curve - 1]; p = (p - prev) / (length_5 - prev); } break; } if (curve != prevCurve) { prevCurve = curve; if (closed && curve == curveCount) { path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2); path.computeWorldVertices(target, 0, 4, world, 4, 2); } else path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2); } this.addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o, tangents || (i > 0 && space == 0)); } return out; } if (closed) { verticesLength += 2; world = spine.Utils.setArraySize(this.world, verticesLength); path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2); path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2); world[verticesLength - 2] = world[0]; world[verticesLength - 1] = world[1]; } else { curveCount--; verticesLength -= 4; world = spine.Utils.setArraySize(this.world, verticesLength); path.computeWorldVertices(target, 2, verticesLength, world, 0, 2); } var curves = spine.Utils.setArraySize(this.curves, curveCount); var pathLength = 0; var x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0; var tmpx = 0, tmpy = 0, dddfx = 0, dddfy = 0, ddfx = 0, ddfy = 0, dfx = 0, dfy = 0; for (var i = 0, w = 2; i < curveCount; i++, w += 6) { cx1 = world[w]; cy1 = world[w + 1]; cx2 = world[w + 2]; cy2 = world[w + 3]; x2 = world[w + 4]; y2 = world[w + 5]; tmpx = (x1 - cx1 * 2 + cx2) * 0.1875; tmpy = (y1 - cy1 * 2 + cy2) * 0.1875; dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375; dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375; ddfx = tmpx * 2 + dddfx; ddfy = tmpy * 2 + dddfy; dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667; dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667; pathLength += Math.sqrt(dfx * dfx + dfy * dfy); dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; pathLength += Math.sqrt(dfx * dfx + dfy * dfy); dfx += ddfx; dfy += ddfy; pathLength += Math.sqrt(dfx * dfx + dfy * dfy); dfx += ddfx + dddfx; dfy += ddfy + dddfy; pathLength += Math.sqrt(dfx * dfx + dfy * dfy); curves[i] = pathLength; x1 = x2; y1 = y2; } if (percentPosition) position *= pathLength; else position *= pathLength / path.lengths[curveCount - 1]; if (percentSpacing) { for (var i = 1; i < spacesCount; i++) spaces[i] *= pathLength; } var segments = this.segments; var curveLength = 0; for (var i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) { var space = spaces[i]; position += space; var p = position; if (closed) { p %= pathLength; if (p < 0) p += pathLength; curve = 0; } else if (p < 0) { this.addBeforePosition(p, world, 0, out, o); continue; } else if (p > pathLength) { this.addAfterPosition(p - pathLength, world, verticesLength - 4, out, o); continue; } for (;; curve++) { var length_6 = curves[curve]; if (p > length_6) continue; if (curve == 0) p /= length_6; else { var prev = curves[curve - 1]; p = (p - prev) / (length_6 - prev); } break; } if (curve != prevCurve) { prevCurve = curve; var ii = curve * 6; x1 = world[ii]; y1 = world[ii + 1]; cx1 = world[ii + 2]; cy1 = world[ii + 3]; cx2 = world[ii + 4]; cy2 = world[ii + 5]; x2 = world[ii + 6]; y2 = world[ii + 7]; tmpx = (x1 - cx1 * 2 + cx2) * 0.03; tmpy = (y1 - cy1 * 2 + cy2) * 0.03; dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006; dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006; ddfx = tmpx * 2 + dddfx; ddfy = tmpy * 2 + dddfy; dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667; dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667; curveLength = Math.sqrt(dfx * dfx + dfy * dfy); segments[0] = curveLength; for (ii = 1; ii < 8; ii++) { dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; curveLength += Math.sqrt(dfx * dfx + dfy * dfy); segments[ii] = curveLength; } dfx += ddfx; dfy += ddfy; curveLength += Math.sqrt(dfx * dfx + dfy * dfy); segments[8] = curveLength; dfx += ddfx + dddfx; dfy += ddfy + dddfy; curveLength += Math.sqrt(dfx * dfx + dfy * dfy); segments[9] = curveLength; segment = 0; } p *= curveLength; for (;; segment++) { var length_7 = segments[segment]; if (p > length_7) continue; if (segment == 0) p /= length_7; else { var prev = segments[segment - 1]; p = segment + (p - prev) / (length_7 - prev); } break; } this.addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0)); } return out; }; PathConstraint.prototype.addBeforePosition = function (p, temp, i, out, o) { var x1 = temp[i], y1 = temp[i + 1], dx = temp[i + 2] - x1, dy = temp[i + 3] - y1, r = Math.atan2(dy, dx); out[o] = x1 + p * Math.cos(r); out[o + 1] = y1 + p * Math.sin(r); out[o + 2] = r; }; PathConstraint.prototype.addAfterPosition = function (p, temp, i, out, o) { var x1 = temp[i + 2], y1 = temp[i + 3], dx = x1 - temp[i], dy = y1 - temp[i + 1], r = Math.atan2(dy, dx); out[o] = x1 + p * Math.cos(r); out[o + 1] = y1 + p * Math.sin(r); out[o + 2] = r; }; PathConstraint.prototype.addCurvePosition = function (p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents) { if (p == 0 || isNaN(p)) { out[o] = x1; out[o + 1] = y1; out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1); return; } var tt = p * p, ttt = tt * p, u = 1 - p, uu = u * u, uuu = uu * u; var ut = u * p, ut3 = ut * 3, uut3 = u * ut3, utt3 = ut3 * p; var x = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt; out[o] = x; out[o + 1] = y; if (tangents) { if (p < 0.001) out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1); else out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt)); } }; PathConstraint.prototype.getOrder = function () { return this.data.order; }; PathConstraint.NONE = -1; PathConstraint.BEFORE = -2; PathConstraint.AFTER = -3; PathConstraint.epsilon = 0.00001; return PathConstraint; }()); spine.PathConstraint = PathConstraint; })(spine || (spine = {})); var spine; (function (spine) { var PathConstraintData = (function () { function PathConstraintData(name) { this.order = 0; this.bones = new Array(); this.name = name; } return PathConstraintData; }()); spine.PathConstraintData = PathConstraintData; var PositionMode; (function (PositionMode) { PositionMode[PositionMode["Fixed"] = 0] = "Fixed"; PositionMode[PositionMode["Percent"] = 1] = "Percent"; })(PositionMode = spine.PositionMode || (spine.PositionMode = {})); var SpacingMode; (function (SpacingMode) { SpacingMode[SpacingMode["Length"] = 0] = "Length"; SpacingMode[SpacingMode["Fixed"] = 1] = "Fixed"; SpacingMode[SpacingMode["Percent"] = 2] = "Percent"; })(SpacingMode = spine.SpacingMode || (spine.SpacingMode = {})); var RotateMode; (function (RotateMode) { RotateMode[RotateMode["Tangent"] = 0] = "Tangent"; RotateMode[RotateMode["Chain"] = 1] = "Chain"; RotateMode[RotateMode["ChainScale"] = 2] = "ChainScale"; })(RotateMode = spine.RotateMode || (spine.RotateMode = {})); })(spine || (spine = {})); var spine; (function (spine) { var Assets = (function () { function Assets(clientId) { this.toLoad = new Array(); this.assets = {}; this.clientId = clientId; } Assets.prototype.loaded = function () { var i = 0; for (var v in this.assets) i++; return i; }; return Assets; }()); var SharedAssetManager = (function () { function SharedAssetManager(pathPrefix) { if (pathPrefix === void 0) { pathPrefix = ""; } this.clientAssets = {}; this.queuedAssets = {}; this.rawAssets = {}; this.errors = {}; this.pathPrefix = pathPrefix; } SharedAssetManager.prototype.queueAsset = function (clientId, textureLoader, path) { var clientAssets = this.clientAssets[clientId]; if (clientAssets === null || clientAssets === undefined) { clientAssets = new Assets(clientId); this.clientAssets[clientId] = clientAssets; } if (textureLoader !== null) clientAssets.textureLoader = textureLoader; clientAssets.toLoad.push(path); if (this.queuedAssets[path] === path) { return false; } else { this.queuedAssets[path] = path; return true; } }; SharedAssetManager.prototype.loadText = function (clientId, path) { var _this = this; path = this.pathPrefix + path; if (!this.queueAsset(clientId, null, path)) return; var request = new XMLHttpRequest(); request.onreadystatechange = function () { if (request.readyState == XMLHttpRequest.DONE) { if (request.status >= 200 && request.status < 300) { _this.rawAssets[path] = request.responseText; } else { _this.errors[path] = "Couldn't load text " + path + ": status " + request.status + ", " + request.responseText; } } }; request.open("GET", path, true); request.send(); }; SharedAssetManager.prototype.loadJson = function (clientId, path) { var _this = this; path = this.pathPrefix + path; if (!this.queueAsset(clientId, null, path)) return; var request = new XMLHttpRequest(); request.onreadystatechange = function () { if (request.readyState == XMLHttpRequest.DONE) { if (request.status >= 200 && request.status < 300) { _this.rawAssets[path] = JSON.parse(request.responseText); } else { _this.errors[path] = "Couldn't load text " + path + ": status " + request.status + ", " + request.responseText; } } }; request.open("GET", path, true); request.send(); }; SharedAssetManager.prototype.loadTexture = function (clientId, textureLoader, path) { var _this = this; path = this.pathPrefix + path; if (!this.queueAsset(clientId, textureLoader, path)) return; var img = new Image(); img.src = path; img.crossOrigin = "anonymous"; img.onload = function (ev) { _this.rawAssets[path] = img; }; img.onerror = function (ev) { _this.errors[path] = "Couldn't load image " + path; }; }; SharedAssetManager.prototype.get = function (clientId, path) { path = this.pathPrefix + path; var clientAssets = this.clientAssets[clientId]; if (clientAssets === null || clientAssets === undefined) return true; return clientAssets.assets[path]; }; SharedAssetManager.prototype.updateClientAssets = function (clientAssets) { for (var i = 0; i < clientAssets.toLoad.length; i++) { var path = clientAssets.toLoad[i]; var asset = clientAssets.assets[path]; if (asset === null || asset === undefined) { var rawAsset = this.rawAssets[path]; if (rawAsset === null || rawAsset === undefined) continue; if (rawAsset instanceof HTMLImageElement) { clientAssets.assets[path] = clientAssets.textureLoader(rawAsset); } else { clientAssets.assets[path] = rawAsset; } } } }; SharedAssetManager.prototype.isLoadingComplete = function (clientId) { var clientAssets = this.clientAssets[clientId]; if (clientAssets === null || clientAssets === undefined) return true; this.updateClientAssets(clientAssets); return clientAssets.toLoad.length == clientAssets.loaded(); }; SharedAssetManager.prototype.dispose = function () { }; SharedAssetManager.prototype.hasErrors = function () { return Object.keys(this.errors).length > 0; }; SharedAssetManager.prototype.getErrors = function () { return this.errors; }; return SharedAssetManager; }()); spine.SharedAssetManager = SharedAssetManager; })(spine || (spine = {})); var spine; (function (spine) { var Skeleton = (function () { function Skeleton(data) { this._updateCache = new Array(); this.updateCacheReset = new Array(); this.time = 0; this.scaleX = 1; this.scaleY = 1; this.x = 0; this.y = 0; if (data == null) throw new Error("data cannot be null."); this.data = data; this.bones = new Array(); for (var i = 0; i < data.bones.length; i++) { var boneData = data.bones[i]; var bone = void 0; if (boneData.parent == null) bone = new spine.Bone(boneData, this, null); else { var parent_1 = this.bones[boneData.parent.index]; bone = new spine.Bone(boneData, this, parent_1); parent_1.children.push(bone); } this.bones.push(bone); } this.slots = new Array(); this.drawOrder = new Array(); for (var i = 0; i < data.slots.length; i++) { var slotData = data.slots[i]; var bone = this.bones[slotData.boneData.index]; var slot = new spine.Slot(slotData, bone); this.slots.push(slot); this.drawOrder.push(slot); } this.ikConstraints = new Array(); for (var i = 0; i < data.ikConstraints.length; i++) { var ikConstraintData = data.ikConstraints[i]; this.ikConstraints.push(new spine.IkConstraint(ikConstraintData, this)); } this.transformConstraints = new Array(); for (var i = 0; i < data.transformConstraints.length; i++) { var transformConstraintData = data.transformConstraints[i]; this.transformConstraints.push(new spine.TransformConstraint(transformConstraintData, this)); } this.pathConstraints = new Array(); for (var i = 0; i < data.pathConstraints.length; i++) { var pathConstraintData = data.pathConstraints[i]; this.pathConstraints.push(new spine.PathConstraint(pathConstraintData, this)); } this.color = new spine.Color(1, 1, 1, 1); this.updateCache(); } Skeleton.prototype.updateCache = function () { var updateCache = this._updateCache; updateCache.length = 0; this.updateCacheReset.length = 0; var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) bones[i].sorted = false; var ikConstraints = this.ikConstraints; var transformConstraints = this.transformConstraints; var pathConstraints = this.pathConstraints; var ikCount = ikConstraints.length, transformCount = transformConstraints.length, pathCount = pathConstraints.length; var constraintCount = ikCount + transformCount + pathCount; outer: for (var i = 0; i < constraintCount; i++) { for (var ii = 0; ii < ikCount; ii++) { var constraint = ikConstraints[ii]; if (constraint.data.order == i) { this.sortIkConstraint(constraint); continue outer; } } for (var ii = 0; ii < transformCount; ii++) { var constraint = transformConstraints[ii]; if (constraint.data.order == i) { this.sortTransformConstraint(constraint); continue outer; } } for (var ii = 0; ii < pathCount; ii++) { var constraint = pathConstraints[ii]; if (constraint.data.order == i) { this.sortPathConstraint(constraint); continue outer; } } } for (var i = 0, n = bones.length; i < n; i++) this.sortBone(bones[i]); }; Skeleton.prototype.sortIkConstraint = function (constraint) { var target = constraint.target; this.sortBone(target); var constrained = constraint.bones; var parent = constrained[0]; this.sortBone(parent); if (constrained.length > 1) { var child = constrained[constrained.length - 1]; if (!(this._updateCache.indexOf(child) > -1)) this.updateCacheReset.push(child); } this._updateCache.push(constraint); this.sortReset(parent.children); constrained[constrained.length - 1].sorted = true; }; Skeleton.prototype.sortPathConstraint = function (constraint) { var slot = constraint.target; var slotIndex = slot.data.index; var slotBone = slot.bone; if (this.skin != null) this.sortPathConstraintAttachment(this.skin, slotIndex, slotBone); if (this.data.defaultSkin != null && this.data.defaultSkin != this.skin) this.sortPathConstraintAttachment(this.data.defaultSkin, slotIndex, slotBone); for (var i = 0, n = this.data.skins.length; i < n; i++) this.sortPathConstraintAttachment(this.data.skins[i], slotIndex, slotBone); var attachment = slot.getAttachment(); if (attachment instanceof spine.PathAttachment) this.sortPathConstraintAttachmentWith(attachment, slotBone); var constrained = constraint.bones; var boneCount = constrained.length; for (var i = 0; i < boneCount; i++) this.sortBone(constrained[i]); this._updateCache.push(constraint); for (var i = 0; i < boneCount; i++) this.sortReset(constrained[i].children); for (var i = 0; i < boneCount; i++) constrained[i].sorted = true; }; Skeleton.prototype.sortTransformConstraint = function (constraint) { this.sortBone(constraint.target); var constrained = constraint.bones; var boneCount = constrained.length; if (constraint.data.local) { for (var i = 0; i < boneCount; i++) { var child = constrained[i]; this.sortBone(child.parent); if (!(this._updateCache.indexOf(child) > -1)) this.updateCacheReset.push(child); } } else { for (var i = 0; i < boneCount; i++) { this.sortBone(constrained[i]); } } this._updateCache.push(constraint); for (var ii = 0; ii < boneCount; ii++) this.sortReset(constrained[ii].children); for (var ii = 0; ii < boneCount; ii++) constrained[ii].sorted = true; }; Skeleton.prototype.sortPathConstraintAttachment = function (skin, slotIndex, slotBone) { var attachments = skin.attachments[slotIndex]; if (!attachments) return; for (var key in attachments) { this.sortPathConstraintAttachmentWith(attachments[key], slotBone); } }; Skeleton.prototype.sortPathConstraintAttachmentWith = function (attachment, slotBone) { if (!(attachment instanceof spine.PathAttachment)) return; var pathBones = attachment.bones; if (pathBones == null) this.sortBone(slotBone); else { var bones = this.bones; var i = 0; while (i < pathBones.length) { var boneCount = pathBones[i++]; for (var n = i + boneCount; i < n; i++) { var boneIndex = pathBones[i]; this.sortBone(bones[boneIndex]); } } } }; Skeleton.prototype.sortBone = function (bone) { if (bone.sorted) return; var parent = bone.parent; if (parent != null) this.sortBone(parent); bone.sorted = true; this._updateCache.push(bone); }; Skeleton.prototype.sortReset = function (bones) { for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; if (bone.sorted) this.sortReset(bone.children); bone.sorted = false; } }; Skeleton.prototype.updateWorldTransform = function () { var updateCacheReset = this.updateCacheReset; for (var i = 0, n = updateCacheReset.length; i < n; i++) { var bone = updateCacheReset[i]; bone.ax = bone.x; bone.ay = bone.y; bone.arotation = bone.rotation; bone.ascaleX = bone.scaleX; bone.ascaleY = bone.scaleY; bone.ashearX = bone.shearX; bone.ashearY = bone.shearY; bone.appliedValid = true; } var updateCache = this._updateCache; for (var i = 0, n = updateCache.length; i < n; i++) updateCache[i].update(); }; Skeleton.prototype.setToSetupPose = function () { this.setBonesToSetupPose(); this.setSlotsToSetupPose(); }; Skeleton.prototype.setBonesToSetupPose = function () { var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) bones[i].setToSetupPose(); var ikConstraints = this.ikConstraints; for (var i = 0, n = ikConstraints.length; i < n; i++) { var constraint = ikConstraints[i]; constraint.mix = constraint.data.mix; constraint.bendDirection = constraint.data.bendDirection; constraint.compress = constraint.data.compress; constraint.stretch = constraint.data.stretch; } var transformConstraints = this.transformConstraints; for (var i = 0, n = transformConstraints.length; i < n; i++) { var constraint = transformConstraints[i]; var data = constraint.data; constraint.rotateMix = data.rotateMix; constraint.translateMix = data.translateMix; constraint.scaleMix = data.scaleMix; constraint.shearMix = data.shearMix; } var pathConstraints = this.pathConstraints; for (var i = 0, n = pathConstraints.length; i < n; i++) { var constraint = pathConstraints[i]; var data = constraint.data; constraint.position = data.position; constraint.spacing = data.spacing; constraint.rotateMix = data.rotateMix; constraint.translateMix = data.translateMix; } }; Skeleton.prototype.setSlotsToSetupPose = function () { var slots = this.slots; spine.Utils.arrayCopy(slots, 0, this.drawOrder, 0, slots.length); for (var i = 0, n = slots.length; i < n; i++) slots[i].setToSetupPose(); }; Skeleton.prototype.getRootBone = function () { if (this.bones.length == 0) return null; return this.bones[0]; }; Skeleton.prototype.findBone = function (boneName) { if (boneName == null) throw new Error("boneName cannot be null."); var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; if (bone.data.name == boneName) return bone; } return null; }; Skeleton.prototype.findBoneIndex = function (boneName) { if (boneName == null) throw new Error("boneName cannot be null."); var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) if (bones[i].data.name == boneName) return i; return -1; }; Skeleton.prototype.findSlot = function (slotName) { if (slotName == null) throw new Error("slotName cannot be null."); var slots = this.slots; for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; if (slot.data.name == slotName) return slot; } return null; }; Skeleton.prototype.findSlotIndex = function (slotName) { if (slotName == null) throw new Error("slotName cannot be null."); var slots = this.slots; for (var i = 0, n = slots.length; i < n; i++) if (slots[i].data.name == slotName) return i; return -1; }; Skeleton.prototype.setSkinByName = function (skinName) { var skin = this.data.findSkin(skinName); if (skin == null) throw new Error("Skin not found: " + skinName); this.setSkin(skin); }; Skeleton.prototype.setSkin = function (newSkin) { if (newSkin != null) { if (this.skin != null) newSkin.attachAll(this, this.skin); else { var slots = this.slots; for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; var name_1 = slot.data.attachmentName; if (name_1 != null) { var attachment = newSkin.getAttachment(i, name_1); if (attachment != null) slot.setAttachment(attachment); } } } } this.skin = newSkin; }; Skeleton.prototype.getAttachmentByName = function (slotName, attachmentName) { return this.getAttachment(this.data.findSlotIndex(slotName), attachmentName); }; Skeleton.prototype.getAttachment = function (slotIndex, attachmentName) { if (attachmentName == null) throw new Error("attachmentName cannot be null."); if (this.skin != null) { var attachment = this.skin.getAttachment(slotIndex, attachmentName); if (attachment != null) return attachment; } if (this.data.defaultSkin != null) return this.data.defaultSkin.getAttachment(slotIndex, attachmentName); return null; }; Skeleton.prototype.setAttachment = function (slotName, attachmentName) { if (slotName == null) throw new Error("slotName cannot be null."); var slots = this.slots; for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; if (slot.data.name == slotName) { var attachment = null; if (attachmentName != null) { attachment = this.getAttachment(i, attachmentName); if (attachment == null) throw new Error("Attachment not found: " + attachmentName + ", for slot: " + slotName); } slot.setAttachment(attachment); return; } } throw new Error("Slot not found: " + slotName); }; Skeleton.prototype.findIkConstraint = function (constraintName) { if (constraintName == null) throw new Error("constraintName cannot be null."); var ikConstraints = this.ikConstraints; for (var i = 0, n = ikConstraints.length; i < n; i++) { var ikConstraint = ikConstraints[i]; if (ikConstraint.data.name == constraintName) return ikConstraint; } return null; }; Skeleton.prototype.findTransformConstraint = function (constraintName) { if (constraintName == null) throw new Error("constraintName cannot be null."); var transformConstraints = this.transformConstraints; for (var i = 0, n = transformConstraints.length; i < n; i++) { var constraint = transformConstraints[i]; if (constraint.data.name == constraintName) return constraint; } return null; }; Skeleton.prototype.findPathConstraint = function (constraintName) { if (constraintName == null) throw new Error("constraintName cannot be null."); var pathConstraints = this.pathConstraints; for (var i = 0, n = pathConstraints.length; i < n; i++) { var constraint = pathConstraints[i]; if (constraint.data.name == constraintName) return constraint; } return null; }; Skeleton.prototype.getBounds = function (offset, size, temp) { if (temp === void 0) { temp = new Array(2); } if (offset == null) throw new Error("offset cannot be null."); if (size == null) throw new Error("size cannot be null."); var drawOrder = this.drawOrder; var minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY; for (var i = 0, n = drawOrder.length; i < n; i++) { var slot = drawOrder[i]; var verticesLength = 0; var vertices = null; var attachment = slot.getAttachment(); if (attachment instanceof spine.RegionAttachment) { verticesLength = 8; vertices = spine.Utils.setArraySize(temp, verticesLength, 0); attachment.computeWorldVertices(slot.bone, vertices, 0, 2); } else if (attachment instanceof spine.MeshAttachment) { var mesh = attachment; verticesLength = mesh.worldVerticesLength; vertices = spine.Utils.setArraySize(temp, verticesLength, 0); mesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2); } if (vertices != null) { for (var ii = 0, nn = vertices.length; ii < nn; ii += 2) { var x = vertices[ii], y = vertices[ii + 1]; minX = Math.min(minX, x); minY = Math.min(minY, y); maxX = Math.max(maxX, x); maxY = Math.max(maxY, y); } } } offset.set(minX, minY); size.set(maxX - minX, maxY - minY); }; Skeleton.prototype.update = function (delta) { this.time += delta; }; return Skeleton; }()); spine.Skeleton = Skeleton; })(spine || (spine = {})); var spine; (function (spine) { var SkeletonBounds = (function () { function SkeletonBounds() { this.minX = 0; this.minY = 0; this.maxX = 0; this.maxY = 0; this.boundingBoxes = new Array(); this.polygons = new Array(); this.polygonPool = new spine.Pool(function () { return spine.Utils.newFloatArray(16); }); } SkeletonBounds.prototype.update = function (skeleton, updateAabb) { if (skeleton == null) throw new Error("skeleton cannot be null."); var boundingBoxes = this.boundingBoxes; var polygons = this.polygons; var polygonPool = this.polygonPool; var slots = skeleton.slots; var slotCount = slots.length; boundingBoxes.length = 0; polygonPool.freeAll(polygons); polygons.length = 0; for (var i = 0; i < slotCount; i++) { var slot = slots[i]; var attachment = slot.getAttachment(); if (attachment instanceof spine.BoundingBoxAttachment) { var boundingBox = attachment; boundingBoxes.push(boundingBox); var polygon = polygonPool.obtain(); if (polygon.length != boundingBox.worldVerticesLength) { polygon = spine.Utils.newFloatArray(boundingBox.worldVerticesLength); } polygons.push(polygon); boundingBox.computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon, 0, 2); } } if (updateAabb) { this.aabbCompute(); } else { this.minX = Number.POSITIVE_INFINITY; this.minY = Number.POSITIVE_INFINITY; this.maxX = Number.NEGATIVE_INFINITY; this.maxY = Number.NEGATIVE_INFINITY; } }; SkeletonBounds.prototype.aabbCompute = function () { var minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY; var polygons = this.polygons; for (var i = 0, n = polygons.length; i < n; i++) { var polygon = polygons[i]; var vertices = polygon; for (var ii = 0, nn = polygon.length; ii < nn; ii += 2) { var x = vertices[ii]; var y = vertices[ii + 1]; minX = Math.min(minX, x); minY = Math.min(minY, y); maxX = Math.max(maxX, x); maxY = Math.max(maxY, y); } } this.minX = minX; this.minY = minY; this.maxX = maxX; this.maxY = maxY; }; SkeletonBounds.prototype.aabbContainsPoint = function (x, y) { return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY; }; SkeletonBounds.prototype.aabbIntersectsSegment = function (x1, y1, x2, y2) { var minX = this.minX; var minY = this.minY; var maxX = this.maxX; var maxY = this.maxY; if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY)) return false; var m = (y2 - y1) / (x2 - x1); var y = m * (minX - x1) + y1; if (y > minY && y < maxY) return true; y = m * (maxX - x1) + y1; if (y > minY && y < maxY) return true; var x = (minY - y1) / m + x1; if (x > minX && x < maxX) return true; x = (maxY - y1) / m + x1; if (x > minX && x < maxX) return true; return false; }; SkeletonBounds.prototype.aabbIntersectsSkeleton = function (bounds) { return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY > bounds.minY; }; SkeletonBounds.prototype.containsPoint = function (x, y) { var polygons = this.polygons; for (var i = 0, n = polygons.length; i < n; i++) if (this.containsPointPolygon(polygons[i], x, y)) return this.boundingBoxes[i]; return null; }; SkeletonBounds.prototype.containsPointPolygon = function (polygon, x, y) { var vertices = polygon; var nn = polygon.length; var prevIndex = nn - 2; var inside = false; for (var ii = 0; ii < nn; ii += 2) { var vertexY = vertices[ii + 1]; var prevY = vertices[prevIndex + 1]; if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) { var vertexX = vertices[ii]; if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside; } prevIndex = ii; } return inside; }; SkeletonBounds.prototype.intersectsSegment = function (x1, y1, x2, y2) { var polygons = this.polygons; for (var i = 0, n = polygons.length; i < n; i++) if (this.intersectsSegmentPolygon(polygons[i], x1, y1, x2, y2)) return this.boundingBoxes[i]; return null; }; SkeletonBounds.prototype.intersectsSegmentPolygon = function (polygon, x1, y1, x2, y2) { var vertices = polygon; var nn = polygon.length; var width12 = x1 - x2, height12 = y1 - y2; var det1 = x1 * y2 - y1 * x2; var x3 = vertices[nn - 2], y3 = vertices[nn - 1]; for (var ii = 0; ii < nn; ii += 2) { var x4 = vertices[ii], y4 = vertices[ii + 1]; var det2 = x3 * y4 - y3 * x4; var width34 = x3 - x4, height34 = y3 - y4; var det3 = width12 * height34 - height12 * width34; var x = (det1 * width34 - width12 * det2) / det3; if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) { var y = (det1 * height34 - height12 * det2) / det3; if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true; } x3 = x4; y3 = y4; } return false; }; SkeletonBounds.prototype.getPolygon = function (boundingBox) { if (boundingBox == null) throw new Error("boundingBox cannot be null."); var index = this.boundingBoxes.indexOf(boundingBox); return index == -1 ? null : this.polygons[index]; }; SkeletonBounds.prototype.getWidth = function () { return this.maxX - this.minX; }; SkeletonBounds.prototype.getHeight = function () { return this.maxY - this.minY; }; return SkeletonBounds; }()); spine.SkeletonBounds = SkeletonBounds; })(spine || (spine = {})); var spine; (function (spine) { var SkeletonClipping = (function () { function SkeletonClipping() { this.triangulator = new spine.Triangulator(); this.clippingPolygon = new Array(); this.clipOutput = new Array(); this.clippedVertices = new Array(); this.clippedTriangles = new Array(); this.scratch = new Array(); } SkeletonClipping.prototype.clipStart = function (slot, clip) { if (this.clipAttachment != null) return 0; this.clipAttachment = clip; var n = clip.worldVerticesLength; var vertices = spine.Utils.setArraySize(this.clippingPolygon, n); clip.computeWorldVertices(slot, 0, n, vertices, 0, 2); var clippingPolygon = this.clippingPolygon; SkeletonClipping.makeClockwise(clippingPolygon); var clippingPolygons = this.clippingPolygons = this.triangulator.decompose(clippingPolygon, this.triangulator.triangulate(clippingPolygon)); for (var i = 0, n_1 = clippingPolygons.length; i < n_1; i++) { var polygon = clippingPolygons[i]; SkeletonClipping.makeClockwise(polygon); polygon.push(polygon[0]); polygon.push(polygon[1]); } return clippingPolygons.length; }; SkeletonClipping.prototype.clipEndWithSlot = function (slot) { if (this.clipAttachment != null && this.clipAttachment.endSlot == slot.data) this.clipEnd(); }; SkeletonClipping.prototype.clipEnd = function () { if (this.clipAttachment == null) return; this.clipAttachment = null; this.clippingPolygons = null; this.clippedVertices.length = 0; this.clippedTriangles.length = 0; this.clippingPolygon.length = 0; }; SkeletonClipping.prototype.isClipping = function () { return this.clipAttachment != null; }; SkeletonClipping.prototype.clipTriangles = function (vertices, verticesLength, triangles, trianglesLength, uvs, light, dark, twoColor) { var clipOutput = this.clipOutput, clippedVertices = this.clippedVertices; var clippedTriangles = this.clippedTriangles; var polygons = this.clippingPolygons; var polygonsCount = this.clippingPolygons.length; var vertexSize = twoColor ? 12 : 8; var index = 0; clippedVertices.length = 0; clippedTriangles.length = 0; outer: for (var i = 0; i < trianglesLength; i += 3) { var vertexOffset = triangles[i] << 1; var x1 = vertices[vertexOffset], y1 = vertices[vertexOffset + 1]; var u1 = uvs[vertexOffset], v1 = uvs[vertexOffset + 1]; vertexOffset = triangles[i + 1] << 1; var x2 = vertices[vertexOffset], y2 = vertices[vertexOffset + 1]; var u2 = uvs[vertexOffset], v2 = uvs[vertexOffset + 1]; vertexOffset = triangles[i + 2] << 1; var x3 = vertices[vertexOffset], y3 = vertices[vertexOffset + 1]; var u3 = uvs[vertexOffset], v3 = uvs[vertexOffset + 1]; for (var p = 0; p < polygonsCount; p++) { var s = clippedVertices.length; if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p], clipOutput)) { var clipOutputLength = clipOutput.length; if (clipOutputLength == 0) continue; var d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1; var d = 1 / (d0 * d2 + d1 * (y1 - y3)); var clipOutputCount = clipOutputLength >> 1; var clipOutputItems = this.clipOutput; var clippedVerticesItems = spine.Utils.setArraySize(clippedVertices, s + clipOutputCount * vertexSize); for (var ii = 0; ii < clipOutputLength; ii += 2) { var x = clipOutputItems[ii], y = clipOutputItems[ii + 1]; clippedVerticesItems[s] = x; clippedVerticesItems[s + 1] = y; clippedVerticesItems[s + 2] = light.r; clippedVerticesItems[s + 3] = light.g; clippedVerticesItems[s + 4] = light.b; clippedVerticesItems[s + 5] = light.a; var c0 = x - x3, c1 = y - y3; var a = (d0 * c0 + d1 * c1) * d; var b = (d4 * c0 + d2 * c1) * d; var c = 1 - a - b; clippedVerticesItems[s + 6] = u1 * a + u2 * b + u3 * c; clippedVerticesItems[s + 7] = v1 * a + v2 * b + v3 * c; if (twoColor) { clippedVerticesItems[s + 8] = dark.r; clippedVerticesItems[s + 9] = dark.g; clippedVerticesItems[s + 10] = dark.b; clippedVerticesItems[s + 11] = dark.a; } s += vertexSize; } s = clippedTriangles.length; var clippedTrianglesItems = spine.Utils.setArraySize(clippedTriangles, s + 3 * (clipOutputCount - 2)); clipOutputCount--; for (var ii = 1; ii < clipOutputCount; ii++) { clippedTrianglesItems[s] = index; clippedTrianglesItems[s + 1] = (index + ii); clippedTrianglesItems[s + 2] = (index + ii + 1); s += 3; } index += clipOutputCount + 1; } else { var clippedVerticesItems = spine.Utils.setArraySize(clippedVertices, s + 3 * vertexSize); clippedVerticesItems[s] = x1; clippedVerticesItems[s + 1] = y1; clippedVerticesItems[s + 2] = light.r; clippedVerticesItems[s + 3] = light.g; clippedVerticesItems[s + 4] = light.b; clippedVerticesItems[s + 5] = light.a; if (!twoColor) { clippedVerticesItems[s + 6] = u1; clippedVerticesItems[s + 7] = v1; clippedVerticesItems[s + 8] = x2; clippedVerticesItems[s + 9] = y2; clippedVerticesItems[s + 10] = light.r; clippedVerticesItems[s + 11] = light.g; clippedVerticesItems[s + 12] = light.b; clippedVerticesItems[s + 13] = light.a; clippedVerticesItems[s + 14] = u2; clippedVerticesItems[s + 15] = v2; clippedVerticesItems[s + 16] = x3; clippedVerticesItems[s + 17] = y3; clippedVerticesItems[s + 18] = light.r; clippedVerticesItems[s + 19] = light.g; clippedVerticesItems[s + 20] = light.b; clippedVerticesItems[s + 21] = light.a; clippedVerticesItems[s + 22] = u3; clippedVerticesItems[s + 23] = v3; } else { clippedVerticesItems[s + 6] = u1; clippedVerticesItems[s + 7] = v1; clippedVerticesItems[s + 8] = dark.r; clippedVerticesItems[s + 9] = dark.g; clippedVerticesItems[s + 10] = dark.b; clippedVerticesItems[s + 11] = dark.a; clippedVerticesItems[s + 12] = x2; clippedVerticesItems[s + 13] = y2; clippedVerticesItems[s + 14] = light.r; clippedVerticesItems[s + 15] = light.g; clippedVerticesItems[s + 16] = light.b; clippedVerticesItems[s + 17] = light.a; clippedVerticesItems[s + 18] = u2; clippedVerticesItems[s + 19] = v2; clippedVerticesItems[s + 20] = dark.r; clippedVerticesItems[s + 21] = dark.g; clippedVerticesItems[s + 22] = dark.b; clippedVerticesItems[s + 23] = dark.a; clippedVerticesItems[s + 24] = x3; clippedVerticesItems[s + 25] = y3; clippedVerticesItems[s + 26] = light.r; clippedVerticesItems[s + 27] = light.g; clippedVerticesItems[s + 28] = light.b; clippedVerticesItems[s + 29] = light.a; clippedVerticesItems[s + 30] = u3; clippedVerticesItems[s + 31] = v3; clippedVerticesItems[s + 32] = dark.r; clippedVerticesItems[s + 33] = dark.g; clippedVerticesItems[s + 34] = dark.b; clippedVerticesItems[s + 35] = dark.a; } s = clippedTriangles.length; var clippedTrianglesItems = spine.Utils.setArraySize(clippedTriangles, s + 3); clippedTrianglesItems[s] = index; clippedTrianglesItems[s + 1] = (index + 1); clippedTrianglesItems[s + 2] = (index + 2); index += 3; continue outer; } } } }; SkeletonClipping.prototype.clip = function (x1, y1, x2, y2, x3, y3, clippingArea, output) { var originalOutput = output; var clipped = false; var input = null; if (clippingArea.length % 4 >= 2) { input = output; output = this.scratch; } else input = this.scratch; input.length = 0; input.push(x1); input.push(y1); input.push(x2); input.push(y2); input.push(x3); input.push(y3); input.push(x1); input.push(y1); output.length = 0; var clippingVertices = clippingArea; var clippingVerticesLast = clippingArea.length - 4; for (var i = 0;; i += 2) { var edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1]; var edgeX2 = clippingVertices[i + 2], edgeY2 = clippingVertices[i + 3]; var deltaX = edgeX - edgeX2, deltaY = edgeY - edgeY2; var inputVertices = input; var inputVerticesLength = input.length - 2, outputStart = output.length; for (var ii = 0; ii < inputVerticesLength; ii += 2) { var inputX = inputVertices[ii], inputY = inputVertices[ii + 1]; var inputX2 = inputVertices[ii + 2], inputY2 = inputVertices[ii + 3]; var side2 = deltaX * (inputY2 - edgeY2) - deltaY * (inputX2 - edgeX2) > 0; if (deltaX * (inputY - edgeY2) - deltaY * (inputX - edgeX2) > 0) { if (side2) { output.push(inputX2); output.push(inputY2); continue; } var c0 = inputY2 - inputY, c2 = inputX2 - inputX; var s = c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY); if (Math.abs(s) > 0.000001) { var ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / s; output.push(edgeX + (edgeX2 - edgeX) * ua); output.push(edgeY + (edgeY2 - edgeY) * ua); } else { output.push(edgeX); output.push(edgeY); } } else if (side2) { var c0 = inputY2 - inputY, c2 = inputX2 - inputX; var s = c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY); if (Math.abs(s) > 0.000001) { var ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / s; output.push(edgeX + (edgeX2 - edgeX) * ua); output.push(edgeY + (edgeY2 - edgeY) * ua); } else { output.push(edgeX); output.push(edgeY); } output.push(inputX2); output.push(inputY2); } clipped = true; } if (outputStart == output.length) { originalOutput.length = 0; return true; } output.push(output[0]); output.push(output[1]); if (i == clippingVerticesLast) break; var temp = output; output = input; output.length = 0; input = temp; } if (originalOutput != output) { originalOutput.length = 0; for (var i = 0, n = output.length - 2; i < n; i++) originalOutput[i] = output[i]; } else originalOutput.length = originalOutput.length - 2; return clipped; }; SkeletonClipping.makeClockwise = function (polygon) { var vertices = polygon; var verticeslength = polygon.length; var area = vertices[verticeslength - 2] * vertices[1] - vertices[0] * vertices[verticeslength - 1], p1x = 0, p1y = 0, p2x = 0, p2y = 0; for (var i = 0, n = verticeslength - 3; i < n; i += 2) { p1x = vertices[i]; p1y = vertices[i + 1]; p2x = vertices[i + 2]; p2y = vertices[i + 3]; area += p1x * p2y - p2x * p1y; } if (area < 0) return; for (var i = 0, lastX = verticeslength - 2, n = verticeslength >> 1; i < n; i += 2) { var x = vertices[i], y = vertices[i + 1]; var other = lastX - i; vertices[i] = vertices[other]; vertices[i + 1] = vertices[other + 1]; vertices[other] = x; vertices[other + 1] = y; } }; return SkeletonClipping; }()); spine.SkeletonClipping = SkeletonClipping; })(spine || (spine = {})); var spine; (function (spine) { var SkeletonData = (function () { function SkeletonData() { this.bones = new Array(); this.slots = new Array(); this.skins = new Array(); this.events = new Array(); this.animations = new Array(); this.ikConstraints = new Array(); this.transformConstraints = new Array(); this.pathConstraints = new Array(); this.fps = 0; } SkeletonData.prototype.findBone = function (boneName) { if (boneName == null) throw new Error("boneName cannot be null."); var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; if (bone.name == boneName) return bone; } return null; }; SkeletonData.prototype.findBoneIndex = function (boneName) { if (boneName == null) throw new Error("boneName cannot be null."); var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) if (bones[i].name == boneName) return i; return -1; }; SkeletonData.prototype.findSlot = function (slotName) { if (slotName == null) throw new Error("slotName cannot be null."); var slots = this.slots; for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; if (slot.name == slotName) return slot; } return null; }; SkeletonData.prototype.findSlotIndex = function (slotName) { if (slotName == null) throw new Error("slotName cannot be null."); var slots = this.slots; for (var i = 0, n = slots.length; i < n; i++) if (slots[i].name == slotName) return i; return -1; }; SkeletonData.prototype.findSkin = function (skinName) { if (skinName == null) throw new Error("skinName cannot be null."); var skins = this.skins; for (var i = 0, n = skins.length; i < n; i++) { var skin = skins[i]; if (skin.name == skinName) return skin; } return null; }; SkeletonData.prototype.findEvent = function (eventDataName) { if (eventDataName == null) throw new Error("eventDataName cannot be null."); var events = this.events; for (var i = 0, n = events.length; i < n; i++) { var event_4 = events[i]; if (event_4.name == eventDataName) return event_4; } return null; }; SkeletonData.prototype.findAnimation = function (animationName) { if (animationName == null) throw new Error("animationName cannot be null."); var animations = this.animations; for (var i = 0, n = animations.length; i < n; i++) { var animation = animations[i]; if (animation.name == animationName) return animation; } return null; }; SkeletonData.prototype.findIkConstraint = function (constraintName) { if (constraintName == null) throw new Error("constraintName cannot be null."); var ikConstraints = this.ikConstraints; for (var i = 0, n = ikConstraints.length; i < n; i++) { var constraint = ikConstraints[i]; if (constraint.name == constraintName) return constraint; } return null; }; SkeletonData.prototype.findTransformConstraint = function (constraintName) { if (constraintName == null) throw new Error("constraintName cannot be null."); var transformConstraints = this.transformConstraints; for (var i = 0, n = transformConstraints.length; i < n; i++) { var constraint = transformConstraints[i]; if (constraint.name == constraintName) return constraint; } return null; }; SkeletonData.prototype.findPathConstraint = function (constraintName) { if (constraintName == null) throw new Error("constraintName cannot be null."); var pathConstraints = this.pathConstraints; for (var i = 0, n = pathConstraints.length; i < n; i++) { var constraint = pathConstraints[i]; if (constraint.name == constraintName) return constraint; } return null; }; SkeletonData.prototype.findPathConstraintIndex = function (pathConstraintName) { if (pathConstraintName == null) throw new Error("pathConstraintName cannot be null."); var pathConstraints = this.pathConstraints; for (var i = 0, n = pathConstraints.length; i < n; i++) if (pathConstraints[i].name == pathConstraintName) return i; return -1; }; return SkeletonData; }()); spine.SkeletonData = SkeletonData; })(spine || (spine = {})); var spine; (function (spine) { var SkeletonJson = (function () { function SkeletonJson(attachmentLoader) { this.scale = 1; this.linkedMeshes = new Array(); this.attachmentLoader = attachmentLoader; } SkeletonJson.prototype.readSkeletonData = function (json) { var scale = this.scale; var skeletonData = new spine.SkeletonData(); var root = typeof (json) === "string" ? JSON.parse(json) : json; var skeletonMap = root.skeleton; if (skeletonMap != null) { skeletonData.hash = skeletonMap.hash; skeletonData.version = skeletonMap.spine; skeletonData.width = skeletonMap.width; skeletonData.height = skeletonMap.height; skeletonData.fps = skeletonMap.fps; skeletonData.imagesPath = skeletonMap.images; } if (root.bones) { for (var i = 0; i < root.bones.length; i++) { var boneMap = root.bones[i]; var parent_2 = null; var parentName = this.getValue(boneMap, "parent", null); if (parentName != null) { parent_2 = skeletonData.findBone(parentName); if (parent_2 == null) throw new Error("Parent bone not found: " + parentName); } var data = new spine.BoneData(skeletonData.bones.length, boneMap.name, parent_2); data.length = this.getValue(boneMap, "length", 0) * scale; data.x = this.getValue(boneMap, "x", 0) * scale; data.y = this.getValue(boneMap, "y", 0) * scale; data.rotation = this.getValue(boneMap, "rotation", 0); data.scaleX = this.getValue(boneMap, "scaleX", 1); data.scaleY = this.getValue(boneMap, "scaleY", 1); data.shearX = this.getValue(boneMap, "shearX", 0); data.shearY = this.getValue(boneMap, "shearY", 0); data.transformMode = SkeletonJson.transformModeFromString(this.getValue(boneMap, "transform", "normal")); skeletonData.bones.push(data); } } if (root.slots) { for (var i = 0; i < root.slots.length; i++) { var slotMap = root.slots[i]; var slotName = slotMap.name; var boneName = slotMap.bone; var boneData = skeletonData.findBone(boneName); if (boneData == null) throw new Error("Slot bone not found: " + boneName); var data = new spine.SlotData(skeletonData.slots.length, slotName, boneData); var color = this.getValue(slotMap, "color", null); if (color != null) data.color.setFromString(color); var dark = this.getValue(slotMap, "dark", null); if (dark != null) { data.darkColor = new spine.Color(1, 1, 1, 1); data.darkColor.setFromString(dark); } data.attachmentName = this.getValue(slotMap, "attachment", null); data.blendMode = SkeletonJson.blendModeFromString(this.getValue(slotMap, "blend", "normal")); skeletonData.slots.push(data); } } if (root.ik) { for (var i = 0; i < root.ik.length; i++) { var constraintMap = root.ik[i]; var data = new spine.IkConstraintData(constraintMap.name); data.order = this.getValue(constraintMap, "order", 0); for (var j = 0; j < constraintMap.bones.length; j++) { var boneName = constraintMap.bones[j]; var bone = skeletonData.findBone(boneName); if (bone == null) throw new Error("IK bone not found: " + boneName); data.bones.push(bone); } var targetName = constraintMap.target; data.target = skeletonData.findBone(targetName); if (data.target == null) throw new Error("IK target bone not found: " + targetName); data.mix = this.getValue(constraintMap, "mix", 1); data.bendDirection = this.getValue(constraintMap, "bendPositive", true) ? 1 : -1; data.compress = this.getValue(constraintMap, "compress", false); data.stretch = this.getValue(constraintMap, "stretch", false); data.uniform = this.getValue(constraintMap, "uniform", false); skeletonData.ikConstraints.push(data); } } if (root.transform) { for (var i = 0; i < root.transform.length; i++) { var constraintMap = root.transform[i]; var data = new spine.TransformConstraintData(constraintMap.name); data.order = this.getValue(constraintMap, "order", 0); for (var j = 0; j < constraintMap.bones.length; j++) { var boneName = constraintMap.bones[j]; var bone = skeletonData.findBone(boneName); if (bone == null) throw new Error("Transform constraint bone not found: " + boneName); data.bones.push(bone); } var targetName = constraintMap.target; data.target = skeletonData.findBone(targetName); if (data.target == null) throw new Error("Transform constraint target bone not found: " + targetName); data.local = this.getValue(constraintMap, "local", false); data.relative = this.getValue(constraintMap, "relative", false); data.offsetRotation = this.getValue(constraintMap, "rotation", 0); data.offsetX = this.getValue(constraintMap, "x", 0) * scale; data.offsetY = this.getValue(constraintMap, "y", 0) * scale; data.offsetScaleX = this.getValue(constraintMap, "scaleX", 0); data.offsetScaleY = this.getValue(constraintMap, "scaleY", 0); data.offsetShearY = this.getValue(constraintMap, "shearY", 0); data.rotateMix = this.getValue(constraintMap, "rotateMix", 1); data.translateMix = this.getValue(constraintMap, "translateMix", 1); data.scaleMix = this.getValue(constraintMap, "scaleMix", 1); data.shearMix = this.getValue(constraintMap, "shearMix", 1); skeletonData.transformConstraints.push(data); } } if (root.path) { for (var i = 0; i < root.path.length; i++) { var constraintMap = root.path[i]; var data = new spine.PathConstraintData(constraintMap.name); data.order = this.getValue(constraintMap, "order", 0); for (var j = 0; j < constraintMap.bones.length; j++) { var boneName = constraintMap.bones[j]; var bone = skeletonData.findBone(boneName); if (bone == null) throw new Error("Transform constraint bone not found: " + boneName); data.bones.push(bone); } var targetName = constraintMap.target; data.target = skeletonData.findSlot(targetName); if (data.target == null) throw new Error("Path target slot not found: " + targetName); data.positionMode = SkeletonJson.positionModeFromString(this.getValue(constraintMap, "positionMode", "percent")); data.spacingMode = SkeletonJson.spacingModeFromString(this.getValue(constraintMap, "spacingMode", "length")); data.rotateMode = SkeletonJson.rotateModeFromString(this.getValue(constraintMap, "rotateMode", "tangent")); data.offsetRotation = this.getValue(constraintMap, "rotation", 0); data.position = this.getValue(constraintMap, "position", 0); if (data.positionMode == spine.PositionMode.Fixed) data.position *= scale; data.spacing = this.getValue(constraintMap, "spacing", 0); if (data.spacingMode == spine.SpacingMode.Length || data.spacingMode == spine.SpacingMode.Fixed) data.spacing *= scale; data.rotateMix = this.getValue(constraintMap, "rotateMix", 1); data.translateMix = this.getValue(constraintMap, "translateMix", 1); skeletonData.pathConstraints.push(data); } } if (root.skins) { for (var skinName in root.skins) { var skinMap = root.skins[skinName]; var skin = new spine.Skin(skinName); for (var slotName in skinMap) { var slotIndex = skeletonData.findSlotIndex(slotName); if (slotIndex == -1) throw new Error("Slot not found: " + slotName); var slotMap = skinMap[slotName]; for (var entryName in slotMap) { var attachment = this.readAttachment(slotMap[entryName], skin, slotIndex, entryName, skeletonData); if (attachment != null) skin.addAttachment(slotIndex, entryName, attachment); } } skeletonData.skins.push(skin); if (skin.name == "default") skeletonData.defaultSkin = skin; } } for (var i = 0, n = this.linkedMeshes.length; i < n; i++) { var linkedMesh = this.linkedMeshes[i]; var skin = linkedMesh.skin == null ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin); if (skin == null) throw new Error("Skin not found: " + linkedMesh.skin); var parent_3 = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent); if (parent_3 == null) throw new Error("Parent mesh not found: " + linkedMesh.parent); linkedMesh.mesh.setParentMesh(parent_3); linkedMesh.mesh.updateUVs(); } this.linkedMeshes.length = 0; if (root.events) { for (var eventName in root.events) { var eventMap = root.events[eventName]; var data = new spine.EventData(eventName); data.intValue = this.getValue(eventMap, "int", 0); data.floatValue = this.getValue(eventMap, "float", 0); data.stringValue = this.getValue(eventMap, "string", ""); data.audioPath = this.getValue(eventMap, "audio", null); if (data.audioPath != null) { data.volume = this.getValue(eventMap, "volume", 1); data.balance = this.getValue(eventMap, "balance", 0); } skeletonData.events.push(data); } } if (root.animations) { for (var animationName in root.animations) { var animationMap = root.animations[animationName]; this.readAnimation(animationMap, animationName, skeletonData); } } return skeletonData; }; SkeletonJson.prototype.readAttachment = function (map, skin, slotIndex, name, skeletonData) { var scale = this.scale; name = this.getValue(map, "name", name); var type = this.getValue(map, "type", "region"); switch (type) { case "region": { var path = this.getValue(map, "path", name); var region = this.attachmentLoader.newRegionAttachment(skin, name, path); if (region == null) return null; region.path = path; region.x = this.getValue(map, "x", 0) * scale; region.y = this.getValue(map, "y", 0) * scale; region.scaleX = this.getValue(map, "scaleX", 1); region.scaleY = this.getValue(map, "scaleY", 1); region.rotation = this.getValue(map, "rotation", 0); region.width = map.width * scale; region.height = map.height * scale; var color = this.getValue(map, "color", null); if (color != null) region.color.setFromString(color); region.updateOffset(); return region; } case "boundingbox": { var box = this.attachmentLoader.newBoundingBoxAttachment(skin, name); if (box == null) return null; this.readVertices(map, box, map.vertexCount << 1); var color = this.getValue(map, "color", null); if (color != null) box.color.setFromString(color); return box; } case "mesh": case "linkedmesh": { var path = this.getValue(map, "path", name); var mesh = this.attachmentLoader.newMeshAttachment(skin, name, path); if (mesh == null) return null; mesh.path = path; var color = this.getValue(map, "color", null); if (color != null) mesh.color.setFromString(color); var parent_4 = this.getValue(map, "parent", null); if (parent_4 != null) { mesh.inheritDeform = this.getValue(map, "deform", true); this.linkedMeshes.push(new LinkedMesh(mesh, this.getValue(map, "skin", null), slotIndex, parent_4)); return mesh; } var uvs = map.uvs; this.readVertices(map, mesh, uvs.length); mesh.triangles = map.triangles; mesh.regionUVs = uvs; mesh.updateUVs(); mesh.hullLength = this.getValue(map, "hull", 0) * 2; return mesh; } case "path": { var path = this.attachmentLoader.newPathAttachment(skin, name); if (path == null) return null; path.closed = this.getValue(map, "closed", false); path.constantSpeed = this.getValue(map, "constantSpeed", true); var vertexCount = map.vertexCount; this.readVertices(map, path, vertexCount << 1); var lengths = spine.Utils.newArray(vertexCount / 3, 0); for (var i = 0; i < map.lengths.length; i++) lengths[i] = map.lengths[i] * scale; path.lengths = lengths; var color = this.getValue(map, "color", null); if (color != null) path.color.setFromString(color); return path; } case "point": { var point = this.attachmentLoader.newPointAttachment(skin, name); if (point == null) return null; point.x = this.getValue(map, "x", 0) * scale; point.y = this.getValue(map, "y", 0) * scale; point.rotation = this.getValue(map, "rotation", 0); var color = this.getValue(map, "color", null); if (color != null) point.color.setFromString(color); return point; } case "clipping": { var clip = this.attachmentLoader.newClippingAttachment(skin, name); if (clip == null) return null; var end = this.getValue(map, "end", null); if (end != null) { var slot = skeletonData.findSlot(end); if (slot == null) throw new Error("Clipping end slot not found: " + end); clip.endSlot = slot; } var vertexCount = map.vertexCount; this.readVertices(map, clip, vertexCount << 1); var color = this.getValue(map, "color", null); if (color != null) clip.color.setFromString(color); return clip; } } return null; }; SkeletonJson.prototype.readVertices = function (map, attachment, verticesLength) { var scale = this.scale; attachment.worldVerticesLength = verticesLength; var vertices = map.vertices; if (verticesLength == vertices.length) { var scaledVertices = spine.Utils.toFloatArray(vertices); if (scale != 1) { for (var i = 0, n = vertices.length; i < n; i++) scaledVertices[i] *= scale; } attachment.vertices = scaledVertices; return; } var weights = new Array(); var bones = new Array(); for (var i = 0, n = vertices.length; i < n;) { var boneCount = vertices[i++]; bones.push(boneCount); for (var nn = i + boneCount * 4; i < nn; i += 4) { bones.push(vertices[i]); weights.push(vertices[i + 1] * scale); weights.push(vertices[i + 2] * scale); weights.push(vertices[i + 3]); } } attachment.bones = bones; attachment.vertices = spine.Utils.toFloatArray(weights); }; SkeletonJson.prototype.readAnimation = function (map, name, skeletonData) { var scale = this.scale; var timelines = new Array(); var duration = 0; if (map.slots) { for (var slotName in map.slots) { var slotMap = map.slots[slotName]; var slotIndex = skeletonData.findSlotIndex(slotName); if (slotIndex == -1) throw new Error("Slot not found: " + slotName); for (var timelineName in slotMap) { var timelineMap = slotMap[timelineName]; if (timelineName == "attachment") { var timeline = new spine.AttachmentTimeline(timelineMap.length); timeline.slotIndex = slotIndex; var frameIndex = 0; for (var i = 0; i < timelineMap.length; i++) { var valueMap = timelineMap[i]; timeline.setFrame(frameIndex++, valueMap.time, valueMap.name); } timelines.push(timeline); duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]); } else if (timelineName == "color") { var timeline = new spine.ColorTimeline(timelineMap.length); timeline.slotIndex = slotIndex; var frameIndex = 0; for (var i = 0; i < timelineMap.length; i++) { var valueMap = timelineMap[i]; var color = new spine.Color(); color.setFromString(valueMap.color); timeline.setFrame(frameIndex, valueMap.time, color.r, color.g, color.b, color.a); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.ColorTimeline.ENTRIES]); } else if (timelineName == "twoColor") { var timeline = new spine.TwoColorTimeline(timelineMap.length); timeline.slotIndex = slotIndex; var frameIndex = 0; for (var i = 0; i < timelineMap.length; i++) { var valueMap = timelineMap[i]; var light = new spine.Color(); var dark = new spine.Color(); light.setFromString(valueMap.light); dark.setFromString(valueMap.dark); timeline.setFrame(frameIndex, valueMap.time, light.r, light.g, light.b, light.a, dark.r, dark.g, dark.b); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.TwoColorTimeline.ENTRIES]); } else throw new Error("Invalid timeline type for a slot: " + timelineName + " (" + slotName + ")"); } } } if (map.bones) { for (var boneName in map.bones) { var boneMap = map.bones[boneName]; var boneIndex = skeletonData.findBoneIndex(boneName); if (boneIndex == -1) throw new Error("Bone not found: " + boneName); for (var timelineName in boneMap) { var timelineMap = boneMap[timelineName]; if (timelineName === "rotate") { var timeline = new spine.RotateTimeline(timelineMap.length); timeline.boneIndex = boneIndex; var frameIndex = 0; for (var i = 0; i < timelineMap.length; i++) { var valueMap = timelineMap[i]; timeline.setFrame(frameIndex, valueMap.time, valueMap.angle); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.RotateTimeline.ENTRIES]); } else if (timelineName === "translate" || timelineName === "scale" || timelineName === "shear") { var timeline = null; var timelineScale = 1; if (timelineName === "scale") timeline = new spine.ScaleTimeline(timelineMap.length); else if (timelineName === "shear") timeline = new spine.ShearTimeline(timelineMap.length); else { timeline = new spine.TranslateTimeline(timelineMap.length); timelineScale = scale; } timeline.boneIndex = boneIndex; var frameIndex = 0; for (var i = 0; i < timelineMap.length; i++) { var valueMap = timelineMap[i]; var x = this.getValue(valueMap, "x", 0), y = this.getValue(valueMap, "y", 0); timeline.setFrame(frameIndex, valueMap.time, x * timelineScale, y * timelineScale); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.TranslateTimeline.ENTRIES]); } else throw new Error("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")"); } } } if (map.ik) { for (var constraintName in map.ik) { var constraintMap = map.ik[constraintName]; var constraint = skeletonData.findIkConstraint(constraintName); var timeline = new spine.IkConstraintTimeline(constraintMap.length); timeline.ikConstraintIndex = skeletonData.ikConstraints.indexOf(constraint); var frameIndex = 0; for (var i = 0; i < constraintMap.length; i++) { var valueMap = constraintMap[i]; timeline.setFrame(frameIndex, valueMap.time, this.getValue(valueMap, "mix", 1), this.getValue(valueMap, "bendPositive", true) ? 1 : -1, this.getValue(valueMap, "compress", false), this.getValue(valueMap, "stretch", false)); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.IkConstraintTimeline.ENTRIES]); } } if (map.transform) { for (var constraintName in map.transform) { var constraintMap = map.transform[constraintName]; var constraint = skeletonData.findTransformConstraint(constraintName); var timeline = new spine.TransformConstraintTimeline(constraintMap.length); timeline.transformConstraintIndex = skeletonData.transformConstraints.indexOf(constraint); var frameIndex = 0; for (var i = 0; i < constraintMap.length; i++) { var valueMap = constraintMap[i]; timeline.setFrame(frameIndex, valueMap.time, this.getValue(valueMap, "rotateMix", 1), this.getValue(valueMap, "translateMix", 1), this.getValue(valueMap, "scaleMix", 1), this.getValue(valueMap, "shearMix", 1)); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.TransformConstraintTimeline.ENTRIES]); } } if (map.paths) { for (var constraintName in map.paths) { var constraintMap = map.paths[constraintName]; var index = skeletonData.findPathConstraintIndex(constraintName); if (index == -1) throw new Error("Path constraint not found: " + constraintName); var data = skeletonData.pathConstraints[index]; for (var timelineName in constraintMap) { var timelineMap = constraintMap[timelineName]; if (timelineName === "position" || timelineName === "spacing") { var timeline = null; var timelineScale = 1; if (timelineName === "spacing") { timeline = new spine.PathConstraintSpacingTimeline(timelineMap.length); if (data.spacingMode == spine.SpacingMode.Length || data.spacingMode == spine.SpacingMode.Fixed) timelineScale = scale; } else { timeline = new spine.PathConstraintPositionTimeline(timelineMap.length); if (data.positionMode == spine.PositionMode.Fixed) timelineScale = scale; } timeline.pathConstraintIndex = index; var frameIndex = 0; for (var i = 0; i < timelineMap.length; i++) { var valueMap = timelineMap[i]; timeline.setFrame(frameIndex, valueMap.time, this.getValue(valueMap, timelineName, 0) * timelineScale); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.PathConstraintPositionTimeline.ENTRIES]); } else if (timelineName === "mix") { var timeline = new spine.PathConstraintMixTimeline(timelineMap.length); timeline.pathConstraintIndex = index; var frameIndex = 0; for (var i = 0; i < timelineMap.length; i++) { var valueMap = timelineMap[i]; timeline.setFrame(frameIndex, valueMap.time, this.getValue(valueMap, "rotateMix", 1), this.getValue(valueMap, "translateMix", 1)); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.PathConstraintMixTimeline.ENTRIES]); } } } } if (map.deform) { for (var deformName in map.deform) { var deformMap = map.deform[deformName]; var skin = skeletonData.findSkin(deformName); if (skin == null) throw new Error("Skin not found: " + deformName); for (var slotName in deformMap) { var slotMap = deformMap[slotName]; var slotIndex = skeletonData.findSlotIndex(slotName); if (slotIndex == -1) throw new Error("Slot not found: " + slotMap.name); for (var timelineName in slotMap) { var timelineMap = slotMap[timelineName]; var attachment = skin.getAttachment(slotIndex, timelineName); if (attachment == null) // throw new Error("Deform attachment not found: " + timelineMap.name); continue; var weighted = attachment.bones != null; var vertices = attachment.vertices; var deformLength = weighted ? vertices.length / 3 * 2 : vertices.length; var timeline = new spine.DeformTimeline(timelineMap.length); timeline.slotIndex = slotIndex; timeline.attachment = attachment; var frameIndex = 0; for (var j = 0; j < timelineMap.length; j++) { var valueMap = timelineMap[j]; var deform = void 0; var verticesValue = this.getValue(valueMap, "vertices", null); if (verticesValue == null) deform = weighted ? spine.Utils.newFloatArray(deformLength) : vertices; else { deform = spine.Utils.newFloatArray(deformLength); var start = this.getValue(valueMap, "offset", 0); spine.Utils.arrayCopy(verticesValue, 0, deform, start, verticesValue.length); if (scale != 1) { for (var i = start, n = i + verticesValue.length; i < n; i++) deform[i] *= scale; } if (!weighted) { for (var i = 0; i < deformLength; i++) deform[i] += vertices[i]; } } timeline.setFrame(frameIndex, valueMap.time, deform); this.readCurve(valueMap, timeline, frameIndex); frameIndex++; } timelines.push(timeline); duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]); } } } } var drawOrderNode = map.drawOrder; if (drawOrderNode == null) drawOrderNode = map.draworder; if (drawOrderNode != null) { var timeline = new spine.DrawOrderTimeline(drawOrderNode.length); var slotCount = skeletonData.slots.length; var frameIndex = 0; for (var j = 0; j < drawOrderNode.length; j++) { var drawOrderMap = drawOrderNode[j]; var drawOrder = null; var offsets = this.getValue(drawOrderMap, "offsets", null); if (offsets != null) { drawOrder = spine.Utils.newArray(slotCount, -1); var unchanged = spine.Utils.newArray(slotCount - offsets.length, 0); var originalIndex = 0, unchangedIndex = 0; for (var i = 0; i < offsets.length; i++) { var offsetMap = offsets[i]; var slotIndex = skeletonData.findSlotIndex(offsetMap.slot); if (slotIndex == -1) throw new Error("Slot not found: " + offsetMap.slot); while (originalIndex != slotIndex) unchanged[unchangedIndex++] = originalIndex++; drawOrder[originalIndex + offsetMap.offset] = originalIndex++; } while (originalIndex < slotCount) unchanged[unchangedIndex++] = originalIndex++; for (var i = slotCount - 1; i >= 0; i--) if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex]; } timeline.setFrame(frameIndex++, drawOrderMap.time, drawOrder); } timelines.push(timeline); duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]); } if (map.events) { var timeline = new spine.EventTimeline(map.events.length); var frameIndex = 0; for (var i = 0; i < map.events.length; i++) { var eventMap = map.events[i]; var eventData = skeletonData.findEvent(eventMap.name); if (eventData == null) throw new Error("Event not found: " + eventMap.name); var event_5 = new spine.Event(spine.Utils.toSinglePrecision(eventMap.time), eventData); event_5.intValue = this.getValue(eventMap, "int", eventData.intValue); event_5.floatValue = this.getValue(eventMap, "float", eventData.floatValue); event_5.stringValue = this.getValue(eventMap, "string", eventData.stringValue); if (event_5.data.audioPath != null) { event_5.volume = this.getValue(eventMap, "volume", 1); event_5.balance = this.getValue(eventMap, "balance", 0); } timeline.setFrame(frameIndex++, event_5); } timelines.push(timeline); duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]); } if (isNaN(duration)) { throw new Error("Error while parsing animation, duration is NaN"); } skeletonData.animations.push(new spine.Animation(name, timelines, duration)); }; SkeletonJson.prototype.readCurve = function (map, timeline, frameIndex) { if (!map.curve) return; if (map.curve === "stepped") timeline.setStepped(frameIndex); else if (Object.prototype.toString.call(map.curve) === '[object Array]') { var curve = map.curve; timeline.setCurve(frameIndex, curve[0], curve[1], curve[2], curve[3]); } }; SkeletonJson.prototype.getValue = function (map, prop, defaultValue) { return map[prop] !== undefined ? map[prop] : defaultValue; }; SkeletonJson.blendModeFromString = function (str) { str = str.toLowerCase(); if (str == "normal") return spine.BlendMode.Normal; if (str == "additive") return spine.BlendMode.Additive; if (str == "multiply") return spine.BlendMode.Multiply; if (str == "screen") return spine.BlendMode.Screen; throw new Error("Unknown blend mode: " + str); }; SkeletonJson.positionModeFromString = function (str) { str = str.toLowerCase(); if (str == "fixed") return spine.PositionMode.Fixed; if (str == "percent") return spine.PositionMode.Percent; throw new Error("Unknown position mode: " + str); }; SkeletonJson.spacingModeFromString = function (str) { str = str.toLowerCase(); if (str == "length") return spine.SpacingMode.Length; if (str == "fixed") return spine.SpacingMode.Fixed; if (str == "percent") return spine.SpacingMode.Percent; throw new Error("Unknown position mode: " + str); }; SkeletonJson.rotateModeFromString = function (str) { str = str.toLowerCase(); if (str == "tangent") return spine.RotateMode.Tangent; if (str == "chain") return spine.RotateMode.Chain; if (str == "chainscale") return spine.RotateMode.ChainScale; throw new Error("Unknown rotate mode: " + str); }; SkeletonJson.transformModeFromString = function (str) { str = str.toLowerCase(); if (str == "normal") return spine.TransformMode.Normal; if (str == "onlytranslation") return spine.TransformMode.OnlyTranslation; if (str == "norotationorreflection") return spine.TransformMode.NoRotationOrReflection; if (str == "noscale") return spine.TransformMode.NoScale; if (str == "noscaleorreflection") return spine.TransformMode.NoScaleOrReflection; throw new Error("Unknown transform mode: " + str); }; return SkeletonJson; }()); spine.SkeletonJson = SkeletonJson; var LinkedMesh = (function () { function LinkedMesh(mesh, skin, slotIndex, parent) { this.mesh = mesh; this.skin = skin; this.slotIndex = slotIndex; this.parent = parent; } return LinkedMesh; }()); })(spine || (spine = {})); var spine; (function (spine) { var Skin = (function () { function Skin(name) { this.attachments = new Array(); if (name == null) throw new Error("name cannot be null."); this.name = name; } Skin.prototype.addAttachment = function (slotIndex, name, attachment) { if (attachment == null) throw new Error("attachment cannot be null."); var attachments = this.attachments; if (slotIndex >= attachments.length) attachments.length = slotIndex + 1; if (!attachments[slotIndex]) attachments[slotIndex] = {}; attachments[slotIndex][name] = attachment; }; Skin.prototype.getAttachment = function (slotIndex, name) { var dictionary = this.attachments[slotIndex]; return dictionary ? dictionary[name] : null; }; Skin.prototype.attachAll = function (skeleton, oldSkin) { var slotIndex = 0; for (var i = 0; i < skeleton.slots.length; i++) { var slot = skeleton.slots[i]; var slotAttachment = slot.getAttachment(); if (slotAttachment && slotIndex < oldSkin.attachments.length) { var dictionary = oldSkin.attachments[slotIndex]; for (var key in dictionary) { var skinAttachment = dictionary[key]; if (slotAttachment == skinAttachment) { var attachment = this.getAttachment(slotIndex, key); if (attachment != null) slot.setAttachment(attachment); break; } } } slotIndex++; } }; return Skin; }()); spine.Skin = Skin; })(spine || (spine = {})); var spine; (function (spine) { var Slot = (function () { function Slot(data, bone) { this.attachmentVertices = new Array(); if (data == null) throw new Error("data cannot be null."); if (bone == null) throw new Error("bone cannot be null."); this.data = data; this.bone = bone; this.color = new spine.Color(); this.darkColor = data.darkColor == null ? null : new spine.Color(); this.setToSetupPose(); } Slot.prototype.getAttachment = function () { return this.attachment; }; Slot.prototype.setAttachment = function (attachment) { if (this.attachment == attachment) return; this.attachment = attachment; this.attachmentTime = this.bone.skeleton.time; this.attachmentVertices.length = 0; }; Slot.prototype.setAttachmentTime = function (time) { this.attachmentTime = this.bone.skeleton.time - time; }; Slot.prototype.getAttachmentTime = function () { return this.bone.skeleton.time - this.attachmentTime; }; Slot.prototype.setToSetupPose = function () { this.color.setFromColor(this.data.color); if (this.darkColor != null) this.darkColor.setFromColor(this.data.darkColor); if (this.data.attachmentName == null) this.attachment = null; else { this.attachment = null; this.setAttachment(this.bone.skeleton.getAttachment(this.data.index, this.data.attachmentName)); } }; return Slot; }()); spine.Slot = Slot; })(spine || (spine = {})); var spine; (function (spine) { var SlotData = (function () { function SlotData(index, name, boneData) { this.color = new spine.Color(1, 1, 1, 1); if (index < 0) throw new Error("index must be >= 0."); if (name == null) throw new Error("name cannot be null."); if (boneData == null) throw new Error("boneData cannot be null."); this.index = index; this.name = name; this.boneData = boneData; } return SlotData; }()); spine.SlotData = SlotData; })(spine || (spine = {})); var spine; (function (spine) { var Texture = (function () { function Texture(image) { this._image = image; } Texture.prototype.getImage = function () { return this._image; }; Texture.filterFromString = function (text) { switch (text.toLowerCase()) { case "nearest": return TextureFilter.Nearest; case "linear": return TextureFilter.Linear; case "mipmap": return TextureFilter.MipMap; case "mipmapnearestnearest": return TextureFilter.MipMapNearestNearest; case "mipmaplinearnearest": return TextureFilter.MipMapLinearNearest; case "mipmapnearestlinear": return TextureFilter.MipMapNearestLinear; case "mipmaplinearlinear": return TextureFilter.MipMapLinearLinear; default: throw new Error("Unknown texture filter " + text); } }; Texture.wrapFromString = function (text) { switch (text.toLowerCase()) { case "mirroredtepeat": return TextureWrap.MirroredRepeat; case "clamptoedge": return TextureWrap.ClampToEdge; case "repeat": return TextureWrap.Repeat; default: throw new Error("Unknown texture wrap " + text); } }; return Texture; }()); spine.Texture = Texture; var TextureFilter; (function (TextureFilter) { TextureFilter[TextureFilter["Nearest"] = 9728] = "Nearest"; TextureFilter[TextureFilter["Linear"] = 9729] = "Linear"; TextureFilter[TextureFilter["MipMap"] = 9987] = "MipMap"; TextureFilter[TextureFilter["MipMapNearestNearest"] = 9984] = "MipMapNearestNearest"; TextureFilter[TextureFilter["MipMapLinearNearest"] = 9985] = "MipMapLinearNearest"; TextureFilter[TextureFilter["MipMapNearestLinear"] = 9986] = "MipMapNearestLinear"; TextureFilter[TextureFilter["MipMapLinearLinear"] = 9987] = "MipMapLinearLinear"; })(TextureFilter = spine.TextureFilter || (spine.TextureFilter = {})); var TextureWrap; (function (TextureWrap) { TextureWrap[TextureWrap["MirroredRepeat"] = 33648] = "MirroredRepeat"; TextureWrap[TextureWrap["ClampToEdge"] = 33071] = "ClampToEdge"; TextureWrap[TextureWrap["Repeat"] = 10497] = "Repeat"; })(TextureWrap = spine.TextureWrap || (spine.TextureWrap = {})); var TextureRegion = (function () { function TextureRegion() { this.u = 0; this.v = 0; this.u2 = 0; this.v2 = 0; this.width = 0; this.height = 0; this.rotate = false; this.offsetX = 0; this.offsetY = 0; this.originalWidth = 0; this.originalHeight = 0; } return TextureRegion; }()); spine.TextureRegion = TextureRegion; var FakeTexture = (function (_super) { __extends(FakeTexture, _super); function FakeTexture() { return _super !== null && _super.apply(this, arguments) || this; } FakeTexture.prototype.setFilters = function (minFilter, magFilter) { }; FakeTexture.prototype.setWraps = function (uWrap, vWrap) { }; FakeTexture.prototype.dispose = function () { }; return FakeTexture; }(Texture)); spine.FakeTexture = FakeTexture; })(spine || (spine = {})); var spine; (function (spine) { var TextureAtlas = (function () { function TextureAtlas(atlasText, textureLoader) { this.pages = new Array(); this.regions = new Array(); this.load(atlasText, textureLoader); } TextureAtlas.prototype.load = function (atlasText, textureLoader) { if (textureLoader == null) throw new Error("textureLoader cannot be null."); var reader = new TextureAtlasReader(atlasText); var tuple = new Array(4); var page = null; while (true) { var line = reader.readLine(); if (line == null) break; line = line.trim(); if (line.length == 0) page = null; else if (!page) { page = new TextureAtlasPage(); page.name = line; if (reader.readTuple(tuple) == 2) { page.width = parseInt(tuple[0]); page.height = parseInt(tuple[1]); reader.readTuple(tuple); } reader.readTuple(tuple); page.minFilter = spine.Texture.filterFromString(tuple[0]); page.magFilter = spine.Texture.filterFromString(tuple[1]); var direction = reader.readValue(); page.uWrap = spine.TextureWrap.ClampToEdge; page.vWrap = spine.TextureWrap.ClampToEdge; if (direction == "x") page.uWrap = spine.TextureWrap.Repeat; else if (direction == "y") page.vWrap = spine.TextureWrap.Repeat; else if (direction == "xy") page.uWrap = page.vWrap = spine.TextureWrap.Repeat; page.texture = textureLoader(line); page.texture.setFilters(page.minFilter, page.magFilter); page.texture.setWraps(page.uWrap, page.vWrap); page.width = page.texture.getImage().width; page.height = page.texture.getImage().height; this.pages.push(page); } else { var region = new TextureAtlasRegion(); region.name = line; region.page = page; region.rotate = reader.readValue() == "true"; reader.readTuple(tuple); var x = parseInt(tuple[0]); var y = parseInt(tuple[1]); reader.readTuple(tuple); var width = parseInt(tuple[0]); var height = parseInt(tuple[1]); region.u = x / page.width; region.v = y / page.height; if (region.rotate) { region.u2 = (x + height) / page.width; region.v2 = (y + width) / page.height; } else { region.u2 = (x + width) / page.width; region.v2 = (y + height) / page.height; } region.x = x; region.y = y; region.width = Math.abs(width); region.height = Math.abs(height); if (reader.readTuple(tuple) == 4) { if (reader.readTuple(tuple) == 4) { reader.readTuple(tuple); } } region.originalWidth = parseInt(tuple[0]); region.originalHeight = parseInt(tuple[1]); reader.readTuple(tuple); region.offsetX = parseInt(tuple[0]); region.offsetY = parseInt(tuple[1]); region.index = parseInt(reader.readValue()); region.texture = page.texture; this.regions.push(region); } } }; TextureAtlas.prototype.findRegion = function (name) { for (var i = 0; i < this.regions.length; i++) { if (this.regions[i].name == name) { return this.regions[i]; } } return null; }; TextureAtlas.prototype.dispose = function () { for (var i = 0; i < this.pages.length; i++) { this.pages[i].texture.dispose(); } }; return TextureAtlas; }()); spine.TextureAtlas = TextureAtlas; var TextureAtlasReader = (function () { function TextureAtlasReader(text) { this.index = 0; this.lines = text.split(/\r\n|\r|\n/); } TextureAtlasReader.prototype.readLine = function () { if (this.index >= this.lines.length) return null; return this.lines[this.index++]; }; TextureAtlasReader.prototype.readValue = function () { var line = this.readLine(); var colon = line.indexOf(":"); if (colon == -1) throw new Error("Invalid line: " + line); return line.substring(colon + 1).trim(); }; TextureAtlasReader.prototype.readTuple = function (tuple) { var line = this.readLine(); var colon = line.indexOf(":"); if (colon == -1) throw new Error("Invalid line: " + line); var i = 0, lastMatch = colon + 1; for (; i < 3; i++) { var comma = line.indexOf(",", lastMatch); if (comma == -1) break; tuple[i] = line.substr(lastMatch, comma - lastMatch).trim(); lastMatch = comma + 1; } tuple[i] = line.substring(lastMatch).trim(); return i + 1; }; return TextureAtlasReader; }()); var TextureAtlasPage = (function () { function TextureAtlasPage() { } return TextureAtlasPage; }()); spine.TextureAtlasPage = TextureAtlasPage; var TextureAtlasRegion = (function (_super) { __extends(TextureAtlasRegion, _super); function TextureAtlasRegion() { return _super !== null && _super.apply(this, arguments) || this; } return TextureAtlasRegion; }(spine.TextureRegion)); spine.TextureAtlasRegion = TextureAtlasRegion; })(spine || (spine = {})); var spine; (function (spine) { var TransformConstraint = (function () { function TransformConstraint(data, skeleton) { this.rotateMix = 0; this.translateMix = 0; this.scaleMix = 0; this.shearMix = 0; this.temp = new spine.Vector2(); if (data == null) throw new Error("data cannot be null."); if (skeleton == null) throw new Error("skeleton cannot be null."); this.data = data; this.rotateMix = data.rotateMix; this.translateMix = data.translateMix; this.scaleMix = data.scaleMix; this.shearMix = data.shearMix; this.bones = new Array(); for (var i = 0; i < data.bones.length; i++) this.bones.push(skeleton.findBone(data.bones[i].name)); this.target = skeleton.findBone(data.target.name); } TransformConstraint.prototype.apply = function () { this.update(); }; TransformConstraint.prototype.update = function () { if (this.data.local) { if (this.data.relative) this.applyRelativeLocal(); else this.applyAbsoluteLocal(); } else { if (this.data.relative) this.applyRelativeWorld(); else this.applyAbsoluteWorld(); } }; TransformConstraint.prototype.applyAbsoluteWorld = function () { var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix; var target = this.target; var ta = target.a, tb = target.b, tc = target.c, td = target.d; var degRadReflect = ta * td - tb * tc > 0 ? spine.MathUtils.degRad : -spine.MathUtils.degRad; var offsetRotation = this.data.offsetRotation * degRadReflect; var offsetShearY = this.data.offsetShearY * degRadReflect; var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; var modified = false; if (rotateMix != 0) { var a = bone.a, b = bone.b, c = bone.c, d = bone.d; var r = Math.atan2(tc, ta) - Math.atan2(c, a) + offsetRotation; if (r > spine.MathUtils.PI) r -= spine.MathUtils.PI2; else if (r < -spine.MathUtils.PI) r += spine.MathUtils.PI2; r *= rotateMix; var cos = Math.cos(r), sin = Math.sin(r); bone.a = cos * a - sin * c; bone.b = cos * b - sin * d; bone.c = sin * a + cos * c; bone.d = sin * b + cos * d; modified = true; } if (translateMix != 0) { var temp = this.temp; target.localToWorld(temp.set(this.data.offsetX, this.data.offsetY)); bone.worldX += (temp.x - bone.worldX) * translateMix; bone.worldY += (temp.y - bone.worldY) * translateMix; modified = true; } if (scaleMix > 0) { var s = Math.sqrt(bone.a * bone.a + bone.c * bone.c); var ts = Math.sqrt(ta * ta + tc * tc); if (s > 0.00001) s = (s + (ts - s + this.data.offsetScaleX) * scaleMix) / s; bone.a *= s; bone.c *= s; s = Math.sqrt(bone.b * bone.b + bone.d * bone.d); ts = Math.sqrt(tb * tb + td * td); if (s > 0.00001) s = (s + (ts - s + this.data.offsetScaleY) * scaleMix) / s; bone.b *= s; bone.d *= s; modified = true; } if (shearMix > 0) { var b = bone.b, d = bone.d; var by = Math.atan2(d, b); var r = Math.atan2(td, tb) - Math.atan2(tc, ta) - (by - Math.atan2(bone.c, bone.a)); if (r > spine.MathUtils.PI) r -= spine.MathUtils.PI2; else if (r < -spine.MathUtils.PI) r += spine.MathUtils.PI2; r = by + (r + offsetShearY) * shearMix; var s = Math.sqrt(b * b + d * d); bone.b = Math.cos(r) * s; bone.d = Math.sin(r) * s; modified = true; } if (modified) bone.appliedValid = false; } }; TransformConstraint.prototype.applyRelativeWorld = function () { var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix; var target = this.target; var ta = target.a, tb = target.b, tc = target.c, td = target.d; var degRadReflect = ta * td - tb * tc > 0 ? spine.MathUtils.degRad : -spine.MathUtils.degRad; var offsetRotation = this.data.offsetRotation * degRadReflect, offsetShearY = this.data.offsetShearY * degRadReflect; var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; var modified = false; if (rotateMix != 0) { var a = bone.a, b = bone.b, c = bone.c, d = bone.d; var r = Math.atan2(tc, ta) + offsetRotation; if (r > spine.MathUtils.PI) r -= spine.MathUtils.PI2; else if (r < -spine.MathUtils.PI) r += spine.MathUtils.PI2; r *= rotateMix; var cos = Math.cos(r), sin = Math.sin(r); bone.a = cos * a - sin * c; bone.b = cos * b - sin * d; bone.c = sin * a + cos * c; bone.d = sin * b + cos * d; modified = true; } if (translateMix != 0) { var temp = this.temp; target.localToWorld(temp.set(this.data.offsetX, this.data.offsetY)); bone.worldX += temp.x * translateMix; bone.worldY += temp.y * translateMix; modified = true; } if (scaleMix > 0) { var s = (Math.sqrt(ta * ta + tc * tc) - 1 + this.data.offsetScaleX) * scaleMix + 1; bone.a *= s; bone.c *= s; s = (Math.sqrt(tb * tb + td * td) - 1 + this.data.offsetScaleY) * scaleMix + 1; bone.b *= s; bone.d *= s; modified = true; } if (shearMix > 0) { var r = Math.atan2(td, tb) - Math.atan2(tc, ta); if (r > spine.MathUtils.PI) r -= spine.MathUtils.PI2; else if (r < -spine.MathUtils.PI) r += spine.MathUtils.PI2; var b = bone.b, d = bone.d; r = Math.atan2(d, b) + (r - spine.MathUtils.PI / 2 + offsetShearY) * shearMix; var s = Math.sqrt(b * b + d * d); bone.b = Math.cos(r) * s; bone.d = Math.sin(r) * s; modified = true; } if (modified) bone.appliedValid = false; } }; TransformConstraint.prototype.applyAbsoluteLocal = function () { var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix; var target = this.target; if (!target.appliedValid) target.updateAppliedTransform(); var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; if (!bone.appliedValid) bone.updateAppliedTransform(); var rotation = bone.arotation; if (rotateMix != 0) { var r = target.arotation - rotation + this.data.offsetRotation; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360; rotation += r * rotateMix; } var x = bone.ax, y = bone.ay; if (translateMix != 0) { x += (target.ax - x + this.data.offsetX) * translateMix; y += (target.ay - y + this.data.offsetY) * translateMix; } var scaleX = bone.ascaleX, scaleY = bone.ascaleY; if (scaleMix != 0) { if (scaleX > 0.00001) scaleX = (scaleX + (target.ascaleX - scaleX + this.data.offsetScaleX) * scaleMix) / scaleX; if (scaleY > 0.00001) scaleY = (scaleY + (target.ascaleY - scaleY + this.data.offsetScaleY) * scaleMix) / scaleY; } var shearY = bone.ashearY; if (shearMix != 0) { var r = target.ashearY - shearY + this.data.offsetShearY; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360; bone.shearY += r * shearMix; } bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY); } }; TransformConstraint.prototype.applyRelativeLocal = function () { var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix; var target = this.target; if (!target.appliedValid) target.updateAppliedTransform(); var bones = this.bones; for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; if (!bone.appliedValid) bone.updateAppliedTransform(); var rotation = bone.arotation; if (rotateMix != 0) rotation += (target.arotation + this.data.offsetRotation) * rotateMix; var x = bone.ax, y = bone.ay; if (translateMix != 0) { x += (target.ax + this.data.offsetX) * translateMix; y += (target.ay + this.data.offsetY) * translateMix; } var scaleX = bone.ascaleX, scaleY = bone.ascaleY; if (scaleMix != 0) { if (scaleX > 0.00001) scaleX *= ((target.ascaleX - 1 + this.data.offsetScaleX) * scaleMix) + 1; if (scaleY > 0.00001) scaleY *= ((target.ascaleY - 1 + this.data.offsetScaleY) * scaleMix) + 1; } var shearY = bone.ashearY; if (shearMix != 0) shearY += (target.ashearY + this.data.offsetShearY) * shearMix; bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY); } }; TransformConstraint.prototype.getOrder = function () { return this.data.order; }; return TransformConstraint; }()); spine.TransformConstraint = TransformConstraint; })(spine || (spine = {})); var spine; (function (spine) { var TransformConstraintData = (function () { function TransformConstraintData(name) { this.order = 0; this.bones = new Array(); this.rotateMix = 0; this.translateMix = 0; this.scaleMix = 0; this.shearMix = 0; this.offsetRotation = 0; this.offsetX = 0; this.offsetY = 0; this.offsetScaleX = 0; this.offsetScaleY = 0; this.offsetShearY = 0; this.relative = false; this.local = false; if (name == null) throw new Error("name cannot be null."); this.name = name; } return TransformConstraintData; }()); spine.TransformConstraintData = TransformConstraintData; })(spine || (spine = {})); var spine; (function (spine) { var Triangulator = (function () { function Triangulator() { this.convexPolygons = new Array(); this.convexPolygonsIndices = new Array(); this.indicesArray = new Array(); this.isConcaveArray = new Array(); this.triangles = new Array(); this.polygonPool = new spine.Pool(function () { return new Array(); }); this.polygonIndicesPool = new spine.Pool(function () { return new Array(); }); } Triangulator.prototype.triangulate = function (verticesArray) { var vertices = verticesArray; var vertexCount = verticesArray.length >> 1; var indices = this.indicesArray; indices.length = 0; for (var i = 0; i < vertexCount; i++) indices[i] = i; var isConcave = this.isConcaveArray; isConcave.length = 0; for (var i = 0, n = vertexCount; i < n; ++i) isConcave[i] = Triangulator.isConcave(i, vertexCount, vertices, indices); var triangles = this.triangles; triangles.length = 0; while (vertexCount > 3) { var previous = vertexCount - 1, i = 0, next = 1; while (true) { outer: if (!isConcave[i]) { var p1 = indices[previous] << 1, p2 = indices[i] << 1, p3 = indices[next] << 1; var p1x = vertices[p1], p1y = vertices[p1 + 1]; var p2x = vertices[p2], p2y = vertices[p2 + 1]; var p3x = vertices[p3], p3y = vertices[p3 + 1]; for (var ii = (next + 1) % vertexCount; ii != previous; ii = (ii + 1) % vertexCount) { if (!isConcave[ii]) continue; var v = indices[ii] << 1; var vx = vertices[v], vy = vertices[v + 1]; if (Triangulator.positiveArea(p3x, p3y, p1x, p1y, vx, vy)) { if (Triangulator.positiveArea(p1x, p1y, p2x, p2y, vx, vy)) { if (Triangulator.positiveArea(p2x, p2y, p3x, p3y, vx, vy)) break outer; } } } break; } if (next == 0) { do { if (!isConcave[i]) break; i--; } while (i > 0); break; } previous = i; i = next; next = (next + 1) % vertexCount; } triangles.push(indices[(vertexCount + i - 1) % vertexCount]); triangles.push(indices[i]); triangles.push(indices[(i + 1) % vertexCount]); indices.splice(i, 1); isConcave.splice(i, 1); vertexCount--; var previousIndex = (vertexCount + i - 1) % vertexCount; var nextIndex = i == vertexCount ? 0 : i; isConcave[previousIndex] = Triangulator.isConcave(previousIndex, vertexCount, vertices, indices); isConcave[nextIndex] = Triangulator.isConcave(nextIndex, vertexCount, vertices, indices); } if (vertexCount == 3) { triangles.push(indices[2]); triangles.push(indices[0]); triangles.push(indices[1]); } return triangles; }; Triangulator.prototype.decompose = function (verticesArray, triangles) { var vertices = verticesArray; var convexPolygons = this.convexPolygons; this.polygonPool.freeAll(convexPolygons); convexPolygons.length = 0; var convexPolygonsIndices = this.convexPolygonsIndices; this.polygonIndicesPool.freeAll(convexPolygonsIndices); convexPolygonsIndices.length = 0; var polygonIndices = this.polygonIndicesPool.obtain(); polygonIndices.length = 0; var polygon = this.polygonPool.obtain(); polygon.length = 0; var fanBaseIndex = -1, lastWinding = 0; for (var i = 0, n = triangles.length; i < n; i += 3) { var t1 = triangles[i] << 1, t2 = triangles[i + 1] << 1, t3 = triangles[i + 2] << 1; var x1 = vertices[t1], y1 = vertices[t1 + 1]; var x2 = vertices[t2], y2 = vertices[t2 + 1]; var x3 = vertices[t3], y3 = vertices[t3 + 1]; var merged = false; if (fanBaseIndex == t1) { var o = polygon.length - 4; var winding1 = Triangulator.winding(polygon[o], polygon[o + 1], polygon[o + 2], polygon[o + 3], x3, y3); var winding2 = Triangulator.winding(x3, y3, polygon[0], polygon[1], polygon[2], polygon[3]); if (winding1 == lastWinding && winding2 == lastWinding) { polygon.push(x3); polygon.push(y3); polygonIndices.push(t3); merged = true; } } if (!merged) { if (polygon.length > 0) { convexPolygons.push(polygon); convexPolygonsIndices.push(polygonIndices); } else { this.polygonPool.free(polygon); this.polygonIndicesPool.free(polygonIndices); } polygon = this.polygonPool.obtain(); polygon.length = 0; polygon.push(x1); polygon.push(y1); polygon.push(x2); polygon.push(y2); polygon.push(x3); polygon.push(y3); polygonIndices = this.polygonIndicesPool.obtain(); polygonIndices.length = 0; polygonIndices.push(t1); polygonIndices.push(t2); polygonIndices.push(t3); lastWinding = Triangulator.winding(x1, y1, x2, y2, x3, y3); fanBaseIndex = t1; } } if (polygon.length > 0) { convexPolygons.push(polygon); convexPolygonsIndices.push(polygonIndices); } for (var i = 0, n = convexPolygons.length; i < n; i++) { polygonIndices = convexPolygonsIndices[i]; if (polygonIndices.length == 0) continue; var firstIndex = polygonIndices[0]; var lastIndex = polygonIndices[polygonIndices.length - 1]; polygon = convexPolygons[i]; var o = polygon.length - 4; var prevPrevX = polygon[o], prevPrevY = polygon[o + 1]; var prevX = polygon[o + 2], prevY = polygon[o + 3]; var firstX = polygon[0], firstY = polygon[1]; var secondX = polygon[2], secondY = polygon[3]; var winding = Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, firstX, firstY); for (var ii = 0; ii < n; ii++) { if (ii == i) continue; var otherIndices = convexPolygonsIndices[ii]; if (otherIndices.length != 3) continue; var otherFirstIndex = otherIndices[0]; var otherSecondIndex = otherIndices[1]; var otherLastIndex = otherIndices[2]; var otherPoly = convexPolygons[ii]; var x3 = otherPoly[otherPoly.length - 2], y3 = otherPoly[otherPoly.length - 1]; if (otherFirstIndex != firstIndex || otherSecondIndex != lastIndex) continue; var winding1 = Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, x3, y3); var winding2 = Triangulator.winding(x3, y3, firstX, firstY, secondX, secondY); if (winding1 == winding && winding2 == winding) { otherPoly.length = 0; otherIndices.length = 0; polygon.push(x3); polygon.push(y3); polygonIndices.push(otherLastIndex); prevPrevX = prevX; prevPrevY = prevY; prevX = x3; prevY = y3; ii = 0; } } } for (var i = convexPolygons.length - 1; i >= 0; i--) { polygon = convexPolygons[i]; if (polygon.length == 0) { convexPolygons.splice(i, 1); this.polygonPool.free(polygon); polygonIndices = convexPolygonsIndices[i]; convexPolygonsIndices.splice(i, 1); this.polygonIndicesPool.free(polygonIndices); } } return convexPolygons; }; Triangulator.isConcave = function (index, vertexCount, vertices, indices) { var previous = indices[(vertexCount + index - 1) % vertexCount] << 1; var current = indices[index] << 1; var next = indices[(index + 1) % vertexCount] << 1; return !this.positiveArea(vertices[previous], vertices[previous + 1], vertices[current], vertices[current + 1], vertices[next], vertices[next + 1]); }; Triangulator.positiveArea = function (p1x, p1y, p2x, p2y, p3x, p3y) { return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0; }; Triangulator.winding = function (p1x, p1y, p2x, p2y, p3x, p3y) { var px = p2x - p1x, py = p2y - p1y; return p3x * py - p3y * px + px * p1y - p1x * py >= 0 ? 1 : -1; }; return Triangulator; }()); spine.Triangulator = Triangulator; })(spine || (spine = {})); var spine; (function (spine) { var IntSet = (function () { function IntSet() { this.array = new Array(); } IntSet.prototype.add = function (value) { var contains = this.contains(value); this.array[value | 0] = value | 0; return !contains; }; IntSet.prototype.contains = function (value) { return this.array[value | 0] != undefined; }; IntSet.prototype.remove = function (value) { this.array[value | 0] = undefined; }; IntSet.prototype.clear = function () { this.array.length = 0; }; return IntSet; }()); spine.IntSet = IntSet; var Color = (function () { function Color(r, g, b, a) { if (r === void 0) { r = 0; } if (g === void 0) { g = 0; } if (b === void 0) { b = 0; } if (a === void 0) { a = 0; } this.r = r; this.g = g; this.b = b; this.a = a; } Color.prototype.set = function (r, g, b, a) { this.r = r; this.g = g; this.b = b; this.a = a; this.clamp(); return this; }; Color.prototype.setFromColor = function (c) { this.r = c.r; this.g = c.g; this.b = c.b; this.a = c.a; return this; }; Color.prototype.setFromString = function (hex) { hex = hex.charAt(0) == '#' ? hex.substr(1) : hex; this.r = parseInt(hex.substr(0, 2), 16) / 255.0; this.g = parseInt(hex.substr(2, 2), 16) / 255.0; this.b = parseInt(hex.substr(4, 2), 16) / 255.0; this.a = (hex.length != 8 ? 255 : parseInt(hex.substr(6, 2), 16)) / 255.0; return this; }; Color.prototype.add = function (r, g, b, a) { this.r += r; this.g += g; this.b += b; this.a += a; this.clamp(); return this; }; Color.prototype.clamp = function () { if (this.r < 0) this.r = 0; else if (this.r > 1) this.r = 1; if (this.g < 0) this.g = 0; else if (this.g > 1) this.g = 1; if (this.b < 0) this.b = 0; else if (this.b > 1) this.b = 1; if (this.a < 0) this.a = 0; else if (this.a > 1) this.a = 1; return this; }; Color.WHITE = new Color(1, 1, 1, 1); Color.RED = new Color(1, 0, 0, 1); Color.GREEN = new Color(0, 1, 0, 1); Color.BLUE = new Color(0, 0, 1, 1); Color.MAGENTA = new Color(1, 0, 1, 1); return Color; }()); spine.Color = Color; var MathUtils = (function () { function MathUtils() { } MathUtils.clamp = function (value, min, max) { if (value < min) return min; if (value > max) return max; return value; }; MathUtils.cosDeg = function (degrees) { return Math.cos(degrees * MathUtils.degRad); }; MathUtils.sinDeg = function (degrees) { return Math.sin(degrees * MathUtils.degRad); }; MathUtils.signum = function (value) { return value > 0 ? 1 : value < 0 ? -1 : 0; }; MathUtils.toInt = function (x) { return x > 0 ? Math.floor(x) : Math.ceil(x); }; MathUtils.cbrt = function (x) { var y = Math.pow(Math.abs(x), 1 / 3); return x < 0 ? -y : y; }; MathUtils.randomTriangular = function (min, max) { return MathUtils.randomTriangularWith(min, max, (min + max) * 0.5); }; MathUtils.randomTriangularWith = function (min, max, mode) { var u = Math.random(); var d = max - min; if (u <= (mode - min) / d) return min + Math.sqrt(u * d * (mode - min)); return max - Math.sqrt((1 - u) * d * (max - mode)); }; MathUtils.PI = 3.1415927; MathUtils.PI2 = MathUtils.PI * 2; MathUtils.radiansToDegrees = 180 / MathUtils.PI; MathUtils.radDeg = MathUtils.radiansToDegrees; MathUtils.degreesToRadians = MathUtils.PI / 180; MathUtils.degRad = MathUtils.degreesToRadians; return MathUtils; }()); spine.MathUtils = MathUtils; var Interpolation = (function () { function Interpolation() { } Interpolation.prototype.apply = function (start, end, a) { return start + (end - start) * this.applyInternal(a); }; return Interpolation; }()); spine.Interpolation = Interpolation; var Pow = (function (_super) { __extends(Pow, _super); function Pow(power) { var _this = _super.call(this) || this; _this.power = 2; _this.power = power; return _this; } Pow.prototype.applyInternal = function (a) { if (a <= 0.5) return Math.pow(a * 2, this.power) / 2; return Math.pow((a - 1) * 2, this.power) / (this.power % 2 == 0 ? -2 : 2) + 1; }; return Pow; }(Interpolation)); spine.Pow = Pow; var PowOut = (function (_super) { __extends(PowOut, _super); function PowOut(power) { return _super.call(this, power) || this; } PowOut.prototype.applyInternal = function (a) { return Math.pow(a - 1, this.power) * (this.power % 2 == 0 ? -1 : 1) + 1; }; return PowOut; }(Pow)); spine.PowOut = PowOut; var Utils = (function () { function Utils() { } Utils.arrayCopy = function (source, sourceStart, dest, destStart, numElements) { for (var i = sourceStart, j = destStart; i < sourceStart + numElements; i++, j++) { dest[j] = source[i]; } }; Utils.setArraySize = function (array, size, value) { if (value === void 0) { value = 0; } var oldSize = array.length; if (oldSize == size) return array; array.length = size; if (oldSize < size) { for (var i = oldSize; i < size; i++) array[i] = value; } return array; }; Utils.ensureArrayCapacity = function (array, size, value) { if (value === void 0) { value = 0; } if (array.length >= size) return array; return Utils.setArraySize(array, size, value); }; Utils.newArray = function (size, defaultValue) { var array = new Array(size); for (var i = 0; i < size; i++) array[i] = defaultValue; return array; }; Utils.newFloatArray = function (size) { if (Utils.SUPPORTS_TYPED_ARRAYS) { return new Float32Array(size); } else { var array = new Array(size); for (var i = 0; i < array.length; i++) array[i] = 0; return array; } }; Utils.newShortArray = function (size) { if (Utils.SUPPORTS_TYPED_ARRAYS) { return new Int16Array(size); } else { var array = new Array(size); for (var i = 0; i < array.length; i++) array[i] = 0; return array; } }; Utils.toFloatArray = function (array) { return Utils.SUPPORTS_TYPED_ARRAYS ? new Float32Array(array) : array; }; Utils.toSinglePrecision = function (value) { return Utils.SUPPORTS_TYPED_ARRAYS ? Math.fround(value) : value; }; Utils.webkit602BugfixHelper = function (alpha, blend) { }; Utils.SUPPORTS_TYPED_ARRAYS = typeof (Float32Array) !== "undefined"; return Utils; }()); spine.Utils = Utils; var DebugUtils = (function () { function DebugUtils() { } DebugUtils.logBones = function (skeleton) { for (var i = 0; i < skeleton.bones.length; i++) { var bone = skeleton.bones[i]; console.log(bone.data.name + ", " + bone.a + ", " + bone.b + ", " + bone.c + ", " + bone.d + ", " + bone.worldX + ", " + bone.worldY); } }; return DebugUtils; }()); spine.DebugUtils = DebugUtils; var Pool = (function () { function Pool(instantiator) { this.items = new Array(); this.instantiator = instantiator; } Pool.prototype.obtain = function () { return this.items.length > 0 ? this.items.pop() : this.instantiator(); }; Pool.prototype.free = function (item) { if (item.reset) item.reset(); this.items.push(item); }; Pool.prototype.freeAll = function (items) { for (var i = 0; i < items.length; i++) { if (items[i].reset) items[i].reset(); this.items[i] = items[i]; } }; Pool.prototype.clear = function () { this.items.length = 0; }; return Pool; }()); spine.Pool = Pool; var Vector2 = (function () { function Vector2(x, y) { if (x === void 0) { x = 0; } if (y === void 0) { y = 0; } this.x = x; this.y = y; } Vector2.prototype.set = function (x, y) { this.x = x; this.y = y; return this; }; Vector2.prototype.length = function () { var x = this.x; var y = this.y; return Math.sqrt(x * x + y * y); }; Vector2.prototype.normalize = function () { var len = this.length(); if (len != 0) { this.x /= len; this.y /= len; } return this; }; return Vector2; }()); spine.Vector2 = Vector2; var TimeKeeper = (function () { function TimeKeeper() { this.maxDelta = 0.064; this.framesPerSecond = 0; this.delta = 0; this.totalTime = 0; this.lastTime = Date.now() / 1000; this.frameCount = 0; this.frameTime = 0; } TimeKeeper.prototype.update = function () { var now = Date.now() / 1000; this.delta = now - this.lastTime; this.frameTime += this.delta; this.totalTime += this.delta; if (this.delta > this.maxDelta) this.delta = this.maxDelta; this.lastTime = now; this.frameCount++; if (this.frameTime > 1) { this.framesPerSecond = this.frameCount / this.frameTime; this.frameTime = 0; this.frameCount = 0; } }; return TimeKeeper; }()); spine.TimeKeeper = TimeKeeper; var WindowedMean = (function () { function WindowedMean(windowSize) { if (windowSize === void 0) { windowSize = 32; } this.addedValues = 0; this.lastValue = 0; this.mean = 0; this.dirty = true; this.values = new Array(windowSize); } WindowedMean.prototype.hasEnoughData = function () { return this.addedValues >= this.values.length; }; WindowedMean.prototype.addValue = function (value) { if (this.addedValues < this.values.length) this.addedValues++; this.values[this.lastValue++] = value; if (this.lastValue > this.values.length - 1) this.lastValue = 0; this.dirty = true; }; WindowedMean.prototype.getMean = function () { if (this.hasEnoughData()) { if (this.dirty) { var mean = 0; for (var i = 0; i < this.values.length; i++) { mean += this.values[i]; } this.mean = mean / this.values.length; this.dirty = false; } return this.mean; } else { return 0; } }; return WindowedMean; }()); spine.WindowedMean = WindowedMean; })(spine || (spine = {})); (function () { if (!Math.fround) { Math.fround = (function (array) { return function (x) { return array[0] = x, array[0]; }; })(new Float32Array(1)); } })(); var spine; (function (spine) { var Attachment = (function () { function Attachment(name) { if (name == null) throw new Error("name cannot be null."); this.name = name; } return Attachment; }()); spine.Attachment = Attachment; var VertexAttachment = (function (_super) { __extends(VertexAttachment, _super); function VertexAttachment(name) { var _this = _super.call(this, name) || this; _this.id = (VertexAttachment.nextID++ & 65535) << 11; _this.worldVerticesLength = 0; return _this; } VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) { count = offset + (count >> 1) * stride; var skeleton = slot.bone.skeleton; var deformArray = slot.attachmentVertices; var vertices = this.vertices; var bones = this.bones; if (bones == null) { if (deformArray.length > 0) vertices = deformArray; var bone = slot.bone; var x = bone.worldX; var y = bone.worldY; var a = bone.a, b = bone.b, c = bone.c, d = bone.d; for (var v_1 = start, w = offset; w < count; v_1 += 2, w += stride) { var vx = vertices[v_1], vy = vertices[v_1 + 1]; worldVertices[w] = vx * a + vy * b + x; worldVertices[w + 1] = vx * c + vy * d + y; } return; } var v = 0, skip = 0; for (var i = 0; i < start; i += 2) { var n = bones[v]; v += n + 1; skip += n; } var skeletonBones = skeleton.bones; if (deformArray.length == 0) { for (var w = offset, b = skip * 3; w < count; w += stride) { var wx = 0, wy = 0; var n = bones[v++]; n += v; for (; v < n; v++, b += 3) { var bone = skeletonBones[bones[v]]; var vx = vertices[b], vy = vertices[b + 1], weight = vertices[b + 2]; wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight; wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight; } worldVertices[w] = wx; worldVertices[w + 1] = wy; } } else { var deform = deformArray; for (var w = offset, b = skip * 3, f = skip << 1; w < count; w += stride) { var wx = 0, wy = 0; var n = bones[v++]; n += v; for (; v < n; v++, b += 3, f += 2) { var bone = skeletonBones[bones[v]]; var vx = vertices[b] + deform[f], vy = vertices[b + 1] + deform[f + 1], weight = vertices[b + 2]; wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight; wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight; } worldVertices[w] = wx; worldVertices[w + 1] = wy; } } }; VertexAttachment.prototype.applyDeform = function (sourceAttachment) { return this == sourceAttachment; }; VertexAttachment.nextID = 0; return VertexAttachment; }(Attachment)); spine.VertexAttachment = VertexAttachment; })(spine || (spine = {})); var spine; (function (spine) { var AttachmentType; (function (AttachmentType) { AttachmentType[AttachmentType["Region"] = 0] = "Region"; AttachmentType[AttachmentType["BoundingBox"] = 1] = "BoundingBox"; AttachmentType[AttachmentType["Mesh"] = 2] = "Mesh"; AttachmentType[AttachmentType["LinkedMesh"] = 3] = "LinkedMesh"; AttachmentType[AttachmentType["Path"] = 4] = "Path"; AttachmentType[AttachmentType["Point"] = 5] = "Point"; })(AttachmentType = spine.AttachmentType || (spine.AttachmentType = {})); })(spine || (spine = {})); var spine; (function (spine) { var BoundingBoxAttachment = (function (_super) { __extends(BoundingBoxAttachment, _super); function BoundingBoxAttachment(name) { var _this = _super.call(this, name) || this; _this.color = new spine.Color(1, 1, 1, 1); return _this; } return BoundingBoxAttachment; }(spine.VertexAttachment)); spine.BoundingBoxAttachment = BoundingBoxAttachment; })(spine || (spine = {})); var spine; (function (spine) { var ClippingAttachment = (function (_super) { __extends(ClippingAttachment, _super); function ClippingAttachment(name) { var _this = _super.call(this, name) || this; _this.color = new spine.Color(0.2275, 0.2275, 0.8078, 1); return _this; } return ClippingAttachment; }(spine.VertexAttachment)); spine.ClippingAttachment = ClippingAttachment; })(spine || (spine = {})); var spine; (function (spine) { var MeshAttachment = (function (_super) { __extends(MeshAttachment, _super); function MeshAttachment(name) { var _this = _super.call(this, name) || this; _this.color = new spine.Color(1, 1, 1, 1); _this.inheritDeform = false; _this.tempColor = new spine.Color(0, 0, 0, 0); return _this; } MeshAttachment.prototype.updateUVs = function () { var regionUVs = this.regionUVs; if (this.uvs == null || this.uvs.length != regionUVs.length) this.uvs = spine.Utils.newFloatArray(regionUVs.length); var uvs = this.uvs; var u = 0, v = 0, width = 0, height = 0; if (this.region instanceof spine.TextureAtlasRegion) { var region = this.region; var textureWidth = region.texture.getImage().width, textureHeight = region.texture.getImage().height; if (region.rotate) { u = region.u - (region.originalHeight - region.offsetY - region.height) / textureWidth; v = region.v - (region.originalWidth - region.offsetX - region.width) / textureHeight; width = region.originalHeight / textureWidth; height = region.originalWidth / textureHeight; for (var i = 0, n = uvs.length; i < n; i += 2) { uvs[i] = u + regionUVs[i + 1] * width; uvs[i + 1] = v + height - regionUVs[i] * height; } return; } u = region.u - region.offsetX / textureWidth; v = region.v - (region.originalHeight - region.offsetY - region.height) / textureHeight; width = region.originalWidth / textureWidth; height = region.originalHeight / textureHeight; } else if (this.region == null) { u = v = 0; width = height = 1; } else { u = this.region.u; v = this.region.v; width = this.region.u2 - u; height = this.region.v2 - v; } for (var i = 0, n = uvs.length; i < n; i += 2) { uvs[i] = u + regionUVs[i] * width; uvs[i + 1] = v + regionUVs[i + 1] * height; } }; MeshAttachment.prototype.applyDeform = function (sourceAttachment) { return this == sourceAttachment || (this.inheritDeform && this.parentMesh == sourceAttachment); }; MeshAttachment.prototype.getParentMesh = function () { return this.parentMesh; }; MeshAttachment.prototype.setParentMesh = function (parentMesh) { this.parentMesh = parentMesh; if (parentMesh != null) { this.bones = parentMesh.bones; this.vertices = parentMesh.vertices; this.worldVerticesLength = parentMesh.worldVerticesLength; this.regionUVs = parentMesh.regionUVs; this.triangles = parentMesh.triangles; this.hullLength = parentMesh.hullLength; this.worldVerticesLength = parentMesh.worldVerticesLength; } }; return MeshAttachment; }(spine.VertexAttachment)); spine.MeshAttachment = MeshAttachment; })(spine || (spine = {})); var spine; (function (spine) { var PathAttachment = (function (_super) { __extends(PathAttachment, _super); function PathAttachment(name) { var _this = _super.call(this, name) || this; _this.closed = false; _this.constantSpeed = false; _this.color = new spine.Color(1, 1, 1, 1); return _this; } return PathAttachment; }(spine.VertexAttachment)); spine.PathAttachment = PathAttachment; })(spine || (spine = {})); var spine; (function (spine) { var PointAttachment = (function (_super) { __extends(PointAttachment, _super); function PointAttachment(name) { var _this = _super.call(this, name) || this; _this.color = new spine.Color(0.38, 0.94, 0, 1); return _this; } PointAttachment.prototype.computeWorldPosition = function (bone, point) { point.x = this.x * bone.a + this.y * bone.b + bone.worldX; point.y = this.x * bone.c + this.y * bone.d + bone.worldY; return point; }; PointAttachment.prototype.computeWorldRotation = function (bone) { var cos = spine.MathUtils.cosDeg(this.rotation), sin = spine.MathUtils.sinDeg(this.rotation); var x = cos * bone.a + sin * bone.b; var y = cos * bone.c + sin * bone.d; return Math.atan2(y, x) * spine.MathUtils.radDeg; }; return PointAttachment; }(spine.VertexAttachment)); spine.PointAttachment = PointAttachment; })(spine || (spine = {})); var spine; (function (spine) { var RegionAttachment = (function (_super) { __extends(RegionAttachment, _super); function RegionAttachment(name) { var _this = _super.call(this, name) || this; _this.x = 0; _this.y = 0; _this.scaleX = 1; _this.scaleY = 1; _this.rotation = 0; _this.width = 0; _this.height = 0; _this.color = new spine.Color(1, 1, 1, 1); _this.offset = spine.Utils.newFloatArray(8); _this.uvs = spine.Utils.newFloatArray(8); _this.tempColor = new spine.Color(1, 1, 1, 1); return _this; } RegionAttachment.prototype.updateOffset = function () { var regionScaleX = this.width / this.region.originalWidth * this.scaleX; var regionScaleY = this.height / this.region.originalHeight * this.scaleY; var localX = -this.width / 2 * this.scaleX + this.region.offsetX * regionScaleX; var localY = -this.height / 2 * this.scaleY + this.region.offsetY * regionScaleY; var localX2 = localX + this.region.width * regionScaleX; var localY2 = localY + this.region.height * regionScaleY; var radians = this.rotation * Math.PI / 180; var cos = Math.cos(radians); var sin = Math.sin(radians); var localXCos = localX * cos + this.x; var localXSin = localX * sin; var localYCos = localY * cos + this.y; var localYSin = localY * sin; var localX2Cos = localX2 * cos + this.x; var localX2Sin = localX2 * sin; var localY2Cos = localY2 * cos + this.y; var localY2Sin = localY2 * sin; var offset = this.offset; offset[RegionAttachment.OX1] = localXCos - localYSin; offset[RegionAttachment.OY1] = localYCos + localXSin; offset[RegionAttachment.OX2] = localXCos - localY2Sin; offset[RegionAttachment.OY2] = localY2Cos + localXSin; offset[RegionAttachment.OX3] = localX2Cos - localY2Sin; offset[RegionAttachment.OY3] = localY2Cos + localX2Sin; offset[RegionAttachment.OX4] = localX2Cos - localYSin; offset[RegionAttachment.OY4] = localYCos + localX2Sin; }; RegionAttachment.prototype.setRegion = function (region) { this.region = region; var uvs = this.uvs; if (region.rotate) { uvs[2] = region.u; uvs[3] = region.v2; uvs[4] = region.u; uvs[5] = region.v; uvs[6] = region.u2; uvs[7] = region.v; uvs[0] = region.u2; uvs[1] = region.v2; } else { uvs[0] = region.u; uvs[1] = region.v2; uvs[2] = region.u; uvs[3] = region.v; uvs[4] = region.u2; uvs[5] = region.v; uvs[6] = region.u2; uvs[7] = region.v2; } }; RegionAttachment.prototype.computeWorldVertices = function (bone, worldVertices, offset, stride) { var vertexOffset = this.offset; var x = bone.worldX, y = bone.worldY; var a = bone.a, b = bone.b, c = bone.c, d = bone.d; var offsetX = 0, offsetY = 0; offsetX = vertexOffset[RegionAttachment.OX1]; offsetY = vertexOffset[RegionAttachment.OY1]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; offset += stride; offsetX = vertexOffset[RegionAttachment.OX2]; offsetY = vertexOffset[RegionAttachment.OY2]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; offset += stride; offsetX = vertexOffset[RegionAttachment.OX3]; offsetY = vertexOffset[RegionAttachment.OY3]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; offset += stride; offsetX = vertexOffset[RegionAttachment.OX4]; offsetY = vertexOffset[RegionAttachment.OY4]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; }; RegionAttachment.OX1 = 0; RegionAttachment.OY1 = 1; RegionAttachment.OX2 = 2; RegionAttachment.OY2 = 3; RegionAttachment.OX3 = 4; RegionAttachment.OY3 = 5; RegionAttachment.OX4 = 6; RegionAttachment.OY4 = 7; RegionAttachment.X1 = 0; RegionAttachment.Y1 = 1; RegionAttachment.C1R = 2; RegionAttachment.C1G = 3; RegionAttachment.C1B = 4; RegionAttachment.C1A = 5; RegionAttachment.U1 = 6; RegionAttachment.V1 = 7; RegionAttachment.X2 = 8; RegionAttachment.Y2 = 9; RegionAttachment.C2R = 10; RegionAttachment.C2G = 11; RegionAttachment.C2B = 12; RegionAttachment.C2A = 13; RegionAttachment.U2 = 14; RegionAttachment.V2 = 15; RegionAttachment.X3 = 16; RegionAttachment.Y3 = 17; RegionAttachment.C3R = 18; RegionAttachment.C3G = 19; RegionAttachment.C3B = 20; RegionAttachment.C3A = 21; RegionAttachment.U3 = 22; RegionAttachment.V3 = 23; RegionAttachment.X4 = 24; RegionAttachment.Y4 = 25; RegionAttachment.C4R = 26; RegionAttachment.C4G = 27; RegionAttachment.C4B = 28; RegionAttachment.C4A = 29; RegionAttachment.U4 = 30; RegionAttachment.V4 = 31; return RegionAttachment; }(spine.Attachment)); spine.RegionAttachment = RegionAttachment; })(spine || (spine = {})); var spine; (function (spine) { var JitterEffect = (function () { function JitterEffect(jitterX, jitterY) { this.jitterX = 0; this.jitterY = 0; this.jitterX = jitterX; this.jitterY = jitterY; } JitterEffect.prototype.begin = function (skeleton) { }; JitterEffect.prototype.transform = function (position, uv, light, dark) { position.x += spine.MathUtils.randomTriangular(-this.jitterX, this.jitterY); position.y += spine.MathUtils.randomTriangular(-this.jitterX, this.jitterY); }; JitterEffect.prototype.end = function () { }; return JitterEffect; }()); spine.JitterEffect = JitterEffect; })(spine || (spine = {})); var spine; (function (spine) { var SwirlEffect = (function () { function SwirlEffect(radius) { this.centerX = 0; this.centerY = 0; this.radius = 0; this.angle = 0; this.worldX = 0; this.worldY = 0; this.radius = radius; } SwirlEffect.prototype.begin = function (skeleton) { this.worldX = skeleton.x + this.centerX; this.worldY = skeleton.y + this.centerY; }; SwirlEffect.prototype.transform = function (position, uv, light, dark) { var radAngle = this.angle * spine.MathUtils.degreesToRadians; var x = position.x - this.worldX; var y = position.y - this.worldY; var dist = Math.sqrt(x * x + y * y); if (dist < this.radius) { var theta = SwirlEffect.interpolation.apply(0, radAngle, (this.radius - dist) / this.radius); var cos = Math.cos(theta); var sin = Math.sin(theta); position.x = cos * x - sin * y + this.worldX; position.y = sin * x + cos * y + this.worldY; } }; SwirlEffect.prototype.end = function () { }; SwirlEffect.interpolation = new spine.PowOut(2); return SwirlEffect; }()); spine.SwirlEffect = SwirlEffect; })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var AssetManager = (function (_super) { __extends(AssetManager, _super); function AssetManager(context, pathPrefix) { if (pathPrefix === void 0) { pathPrefix = ""; } return _super.call(this, function (image) { return new spine.webgl.GLTexture(context, image); }, pathPrefix) || this; } return AssetManager; }(spine.AssetManager)); webgl.AssetManager = AssetManager; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var OrthoCamera = (function () { function OrthoCamera(viewportWidth, viewportHeight) { this.position = new webgl.Vector3(0, 0, 0); this.direction = new webgl.Vector3(0, 0, -1); this.up = new webgl.Vector3(0, 1, 0); this.near = 0; this.far = 100; this.zoom = 1; this.viewportWidth = 0; this.viewportHeight = 0; this.projectionView = new webgl.Matrix4(); this.inverseProjectionView = new webgl.Matrix4(); this.projection = new webgl.Matrix4(); this.view = new webgl.Matrix4(); this.tmp = new webgl.Vector3(); this.viewportWidth = viewportWidth; this.viewportHeight = viewportHeight; this.update(); } OrthoCamera.prototype.update = function () { var projection = this.projection; var view = this.view; var projectionView = this.projectionView; var inverseProjectionView = this.inverseProjectionView; var zoom = this.zoom, viewportWidth = this.viewportWidth, viewportHeight = this.viewportHeight; projection.ortho(zoom * (-viewportWidth / 2), zoom * (viewportWidth / 2), zoom * (-viewportHeight / 2), zoom * (viewportHeight / 2), this.near, this.far); view.lookAt(this.position, this.direction, this.up); projectionView.set(projection.values); projectionView.multiply(view); inverseProjectionView.set(projectionView.values).invert(); }; OrthoCamera.prototype.screenToWorld = function (screenCoords, screenWidth, screenHeight) { var x = screenCoords.x, y = screenHeight - screenCoords.y - 1; var tmp = this.tmp; tmp.x = (2 * x) / screenWidth - 1; tmp.y = (2 * y) / screenHeight - 1; tmp.z = (2 * screenCoords.z) - 1; tmp.project(this.inverseProjectionView); screenCoords.set(tmp.x, tmp.y, tmp.z); return screenCoords; }; OrthoCamera.prototype.setViewport = function (viewportWidth, viewportHeight) { this.viewportWidth = viewportWidth; this.viewportHeight = viewportHeight; }; return OrthoCamera; }()); webgl.OrthoCamera = OrthoCamera; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var GLTexture = (function (_super) { __extends(GLTexture, _super); function GLTexture(context, image, useMipMaps) { if (useMipMaps === void 0) { useMipMaps = false; } var _this = _super.call(this, image) || this; _this.texture = null; _this.boundUnit = 0; _this.useMipMaps = false; _this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context); _this.useMipMaps = useMipMaps; _this.restore(); _this.context.addRestorable(_this); return _this; } GLTexture.prototype.setFilters = function (minFilter, magFilter) { var gl = this.context.gl; this.bind(); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter); }; GLTexture.prototype.setWraps = function (uWrap, vWrap) { var gl = this.context.gl; this.bind(); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, uWrap); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, vWrap); }; GLTexture.prototype.update = function (useMipMaps) { var gl = this.context.gl; if (!this.texture) { this.texture = this.context.gl.createTexture(); } this.bind(); gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._image); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, useMipMaps ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); if (useMipMaps) gl.generateMipmap(gl.TEXTURE_2D); }; GLTexture.prototype.restore = function () { this.texture = null; this.update(this.useMipMaps); }; GLTexture.prototype.bind = function (unit) { if (unit === void 0) { unit = 0; } var gl = this.context.gl; this.boundUnit = unit; gl.activeTexture(gl.TEXTURE0 + unit); gl.bindTexture(gl.TEXTURE_2D, this.texture); }; GLTexture.prototype.unbind = function () { var gl = this.context.gl; gl.activeTexture(gl.TEXTURE0 + this.boundUnit); gl.bindTexture(gl.TEXTURE_2D, null); }; GLTexture.prototype.dispose = function () { this.context.removeRestorable(this); var gl = this.context.gl; gl.deleteTexture(this.texture); }; return GLTexture; }(spine.Texture)); webgl.GLTexture = GLTexture; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var Input = (function () { function Input(element) { this.lastX = 0; this.lastY = 0; this.buttonDown = false; this.currTouch = null; this.touchesPool = new spine.Pool(function () { return new spine.webgl.Touch(0, 0, 0); }); this.listeners = new Array(); this.element = element; this.setupCallbacks(element); } Input.prototype.setupCallbacks = function (element) { var _this = this; var mouseDown = function (ev) { if (ev instanceof MouseEvent) { var rect = element.getBoundingClientRect(); var x = ev.clientX - rect.left; var y = ev.clientY - rect.top; var listeners = _this.listeners; for (var i = 0; i < listeners.length; i++) { listeners[i].down(x, y); } _this.lastX = x; _this.lastY = y; _this.buttonDown = true; document.addEventListener("mousemove", mouseMove); document.addEventListener("mouseup", mouseUp); } }; var mouseMove = function (ev) { if (ev instanceof MouseEvent) { var rect = element.getBoundingClientRect(); var x = ev.clientX - rect.left; var y = ev.clientY - rect.top; var listeners = _this.listeners; for (var i = 0; i < listeners.length; i++) { if (_this.buttonDown) { listeners[i].dragged(x, y); } else { listeners[i].moved(x, y); } } _this.lastX = x; _this.lastY = y; } }; var mouseUp = function (ev) { if (ev instanceof MouseEvent) { var rect = element.getBoundingClientRect(); var x = ev.clientX - rect.left; var y = ev.clientY - rect.top; var listeners = _this.listeners; for (var i = 0; i < listeners.length; i++) { listeners[i].up(x, y); } _this.lastX = x; _this.lastY = y; _this.buttonDown = false; document.removeEventListener("mousemove", mouseMove); document.removeEventListener("mouseup", mouseUp); } }; element.addEventListener("mousedown", mouseDown, true); element.addEventListener("mousemove", mouseMove, true); element.addEventListener("mouseup", mouseUp, true); element.addEventListener("touchstart", function (ev) { if (_this.currTouch != null) return; var touches = ev.changedTouches; for (var i = 0; i < touches.length; i++) { var touch = touches[i]; var rect = element.getBoundingClientRect(); var x = touch.clientX - rect.left; var y = touch.clientY - rect.top; _this.currTouch = _this.touchesPool.obtain(); _this.currTouch.identifier = touch.identifier; _this.currTouch.x = x; _this.currTouch.y = y; break; } var listeners = _this.listeners; for (var i_16 = 0; i_16 < listeners.length; i_16++) { listeners[i_16].down(_this.currTouch.x, _this.currTouch.y); } console.log("Start " + _this.currTouch.x + ", " + _this.currTouch.y); _this.lastX = _this.currTouch.x; _this.lastY = _this.currTouch.y; _this.buttonDown = true; ev.preventDefault(); }, false); element.addEventListener("touchend", function (ev) { var touches = ev.changedTouches; for (var i = 0; i < touches.length; i++) { var touch = touches[i]; if (_this.currTouch.identifier === touch.identifier) { var rect = element.getBoundingClientRect(); var x = _this.currTouch.x = touch.clientX - rect.left; var y = _this.currTouch.y = touch.clientY - rect.top; _this.touchesPool.free(_this.currTouch); var listeners = _this.listeners; for (var i_17 = 0; i_17 < listeners.length; i_17++) { listeners[i_17].up(x, y); } console.log("End " + x + ", " + y); _this.lastX = x; _this.lastY = y; _this.buttonDown = false; _this.currTouch = null; break; } } ev.preventDefault(); }, false); element.addEventListener("touchcancel", function (ev) { var touches = ev.changedTouches; for (var i = 0; i < touches.length; i++) { var touch = touches[i]; if (_this.currTouch.identifier === touch.identifier) { var rect = element.getBoundingClientRect(); var x = _this.currTouch.x = touch.clientX - rect.left; var y = _this.currTouch.y = touch.clientY - rect.top; _this.touchesPool.free(_this.currTouch); var listeners = _this.listeners; for (var i_18 = 0; i_18 < listeners.length; i_18++) { listeners[i_18].up(x, y); } console.log("End " + x + ", " + y); _this.lastX = x; _this.lastY = y; _this.buttonDown = false; _this.currTouch = null; break; } } ev.preventDefault(); }, false); element.addEventListener("touchmove", function (ev) { if (_this.currTouch == null) return; var touches = ev.changedTouches; for (var i = 0; i < touches.length; i++) { var touch = touches[i]; if (_this.currTouch.identifier === touch.identifier) { var rect = element.getBoundingClientRect(); var x = touch.clientX - rect.left; var y = touch.clientY - rect.top; var listeners = _this.listeners; for (var i_19 = 0; i_19 < listeners.length; i_19++) { listeners[i_19].dragged(x, y); } console.log("Drag " + x + ", " + y); _this.lastX = _this.currTouch.x = x; _this.lastY = _this.currTouch.y = y; break; } } ev.preventDefault(); }, false); }; Input.prototype.addListener = function (listener) { this.listeners.push(listener); }; Input.prototype.removeListener = function (listener) { var idx = this.listeners.indexOf(listener); if (idx > -1) { this.listeners.splice(idx, 1); } }; return Input; }()); webgl.Input = Input; var Touch = (function () { function Touch(identifier, x, y) { this.identifier = identifier; this.x = x; this.y = y; } return Touch; }()); webgl.Touch = Touch; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var LoadingScreen = (function () { function LoadingScreen(renderer) { this.logo = null; this.spinner = null; this.angle = 0; this.fadeOut = 0; this.timeKeeper = new spine.TimeKeeper(); this.backgroundColor = new spine.Color(0.135, 0.135, 0.135, 1); this.tempColor = new spine.Color(); this.firstDraw = 0; this.renderer = renderer; this.timeKeeper.maxDelta = 9; if (LoadingScreen.logoImg === null) { var isSafari = navigator.userAgent.indexOf("Safari") > -1; LoadingScreen.logoImg = new Image(); LoadingScreen.logoImg.src = LoadingScreen.SPINE_LOGO_DATA; if (!isSafari) LoadingScreen.logoImg.crossOrigin = "anonymous"; LoadingScreen.logoImg.onload = function (ev) { LoadingScreen.loaded++; }; LoadingScreen.spinnerImg = new Image(); LoadingScreen.spinnerImg.src = LoadingScreen.SPINNER_DATA; if (!isSafari) LoadingScreen.spinnerImg.crossOrigin = "anonymous"; LoadingScreen.spinnerImg.onload = function (ev) { LoadingScreen.loaded++; }; } } LoadingScreen.prototype.draw = function (complete) { if (complete === void 0) { complete = false; } if (complete && this.fadeOut > LoadingScreen.FADE_SECONDS) return; this.timeKeeper.update(); var a = Math.abs(Math.sin(this.timeKeeper.totalTime + 0.75)); this.angle -= this.timeKeeper.delta / 1.4 * 360 * (1 + 1.5 * Math.pow(a, 5)); var renderer = this.renderer; var canvas = renderer.canvas; var gl = renderer.context.gl; renderer.resize(webgl.ResizeMode.Stretch); var oldX = renderer.camera.position.x, oldY = renderer.camera.position.y; renderer.camera.position.set(canvas.width / 2, canvas.height / 2, 0); renderer.camera.viewportWidth = canvas.width; renderer.camera.viewportHeight = canvas.height; if (!complete) { gl.clearColor(this.backgroundColor.r, this.backgroundColor.g, this.backgroundColor.b, this.backgroundColor.a); gl.clear(gl.COLOR_BUFFER_BIT); this.tempColor.a = 1; } else { this.fadeOut += this.timeKeeper.delta * (this.timeKeeper.totalTime < 1 ? 2 : 1); if (this.fadeOut > LoadingScreen.FADE_SECONDS) { renderer.camera.position.set(oldX, oldY, 0); return; } a = 1 - this.fadeOut / LoadingScreen.FADE_SECONDS; this.tempColor.setFromColor(this.backgroundColor); this.tempColor.a = 1 - (a - 1) * (a - 1); renderer.begin(); renderer.quad(true, 0, 0, canvas.width, 0, canvas.width, canvas.height, 0, canvas.height, this.tempColor, this.tempColor, this.tempColor, this.tempColor); renderer.end(); } this.tempColor.set(1, 1, 1, this.tempColor.a); if (LoadingScreen.loaded != 2) return; if (this.logo === null) { this.logo = new webgl.GLTexture(renderer.context, LoadingScreen.logoImg); this.spinner = new webgl.GLTexture(renderer.context, LoadingScreen.spinnerImg); } this.logo.update(false); this.spinner.update(false); var logoWidth = this.logo.getImage().width; var logoHeight = this.logo.getImage().height; var spinnerWidth = this.spinner.getImage().width; var spinnerHeight = this.spinner.getImage().height; renderer.batcher.setBlendMode(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA); renderer.begin(); renderer.drawTexture(this.logo, (canvas.width - logoWidth) / 2, (canvas.height - logoHeight) / 2, logoWidth, logoHeight, this.tempColor); renderer.drawTextureRotated(this.spinner, (canvas.width - spinnerWidth) / 2, (canvas.height - spinnerHeight) / 2, spinnerWidth, spinnerHeight, spinnerWidth / 2, spinnerHeight / 2, this.angle, this.tempColor); renderer.end(); renderer.camera.position.set(oldX, oldY, 0); }; LoadingScreen.FADE_SECONDS = 1; LoadingScreen.loaded = 0; LoadingScreen.spinnerImg = null; LoadingScreen.logoImg = null; LoadingScreen.SPINNER_DATA = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKMAAACjCAYAAADmbK6AAAAACXBIWXMAAAsTAAALEwEAmpwYAAALB2lUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS42LWMxNDIgNzkuMTYwOTI0LCAyMDE3LzA3LzEzLTAxOjA2OjM5ICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0RXZ0PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VFdmVudCMiIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczpwaG90b3Nob3A9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGhvdG9zaG9wLzEuMC8iIHhtbG5zOnRpZmY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vdGlmZi8xLjAvIiB4bWxuczpleGlmPSJodHRwOi8vbnMuYWRvYmUuY29tL2V4aWYvMS4wLyIgeG1wOkNyZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ0MgMjAxNS41IChXaW5kb3dzKSIgeG1wOkNyZWF0ZURhdGU9IjIwMTYtMDktMDhUMTQ6MjU6MTIrMDI6MDAiIHhtcDpNZXRhZGF0YURhdGU9IjIwMTgtMTEtMTVUMTY6NDA6NTkrMDE6MDAiIHhtcDpNb2RpZnlEYXRlPSIyMDE4LTExLTE1VDE2OjQwOjU5KzAxOjAwIiBkYzpmb3JtYXQ9ImltYWdlL3BuZyIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDpmZDhlNTljMC02NGJjLTIxNGQtODAyZi1jZDlhODJjM2ZjMGMiIHhtcE1NOkRvY3VtZW50SUQ9ImFkb2JlOmRvY2lkOnBob3Rvc2hvcDpmYmNmZWJlYS03MjY2LWE0NGQtOTI4NS0wOTJmNGNhYzk4ZWEiIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDowODMzNWIyYy04NzYyLWQzNGMtOTBhOS02ODJjYjJmYTQ2M2UiIHBob3Rvc2hvcDpDb2xvck1vZGU9IjMiIHRpZmY6T3JpZW50YXRpb249IjEiIHRpZmY6WFJlc29sdXRpb249IjcyMDAwMC8xMDAwMCIgdGlmZjpZUmVzb2x1dGlvbj0iNzIwMDAwLzEwMDAwIiB0aWZmOlJlc29sdXRpb25Vbml0PSIyIiBleGlmOkNvbG9yU3BhY2U9IjY1NTM1IiBleGlmOlBpeGVsWERpbWVuc2lvbj0iMjk3IiBleGlmOlBpeGVsWURpbWVuc2lvbj0iMjQyIj4gPHhtcE1NOkhpc3Rvcnk+IDxyZGY6U2VxPiA8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iY3JlYXRlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowODMzNWIyYy04NzYyLWQzNGMtOTBhOS02ODJjYjJmYTQ2M2UiIHN0RXZ0OndoZW49IjIwMTYtMDktMDhUMTQ6MjU6MTIrMDI6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDQyAyMDE1LjUgKFdpbmRvd3MpIi8+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpiNThlMTlkNi0xYTRjLTQyNDEtODU0ZC01MDVlZjYxMjRhODQiIHN0RXZ0OndoZW49IjIwMTgtMTEtMTVUMTY6NDA6MjMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDQyAoV2luZG93cykiIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjQ3YzYzYzIwLWJkYjgtYzM0YS1hYzMyLWQ5MDdjOWEyOTA0MCIgc3RFdnQ6d2hlbj0iMjAxOC0xMS0xNVQxNjo0MDo1OSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENDIChXaW5kb3dzKSIgc3RFdnQ6Y2hhbmdlZD0iLyIvPiA8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iY29udmVydGVkIiBzdEV2dDpwYXJhbWV0ZXJzPSJmcm9tIGFwcGxpY2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8gaW1hZ2UvcG5nIi8+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJkZXJpdmVkIiBzdEV2dDpwYXJhbWV0ZXJzPSJjb252ZXJ0ZWQgZnJvbSBhcHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRvIGltYWdlL3BuZyIvPiA8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6ZmQ4ZTU5YzAtNjRiYy0yMTRkLTgwMmYtY2Q5YTgyYzNmYzBjIiBzdEV2dDp3aGVuPSIyMDE4LTExLTE1VDE2OjQwOjU5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ0MgKFdpbmRvd3MpIiBzdEV2dDpjaGFuZ2VkPSIvIi8+IDwvcmRmOlNlcT4gPC94bXBNTTpIaXN0b3J5PiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDo0N2M2M2MyMC1iZGI4LWMzNGEtYWMzMi1kOTA3YzlhMjkwNDAiIHN0UmVmOmRvY3VtZW50SUQ9ImFkb2JlOmRvY2lkOnBob3Rvc2hvcDo2OWRmZjljYy01YzFiLWE5NDctOTc3OS03ODgxZjM0ODk3MDMiIHN0UmVmOm9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDowODMzNWIyYy04NzYyLWQzNGMtOTBhOS02ODJjYjJmYTQ2M2UiLz4gPHBob3Rvc2hvcDpEb2N1bWVudEFuY2VzdG9ycz4gPHJkZjpCYWc+IDxyZGY6bGk+eG1wLmRpZDowODMzNWIyYy04NzYyLWQzNGMtOTBhOS02ODJjYjJmYTQ2M2U8L3JkZjpsaT4gPC9yZGY6QmFnPiA8L3Bob3Rvc2hvcDpEb2N1bWVudEFuY2VzdG9ycz4gPC9yZGY6RGVzY3JpcHRpb24+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz7qS4aQAAAKZElEQVR42u2de4xVxR3HP8dd3rQryPKo4dGNbtVAQRa1YB93E1tTS7VYqCBiSWhsqGltSx+0xD60tKBorYnNkkBtFUt9xJaGNGlty6EqRAK1KlalshK2C8tzpcIigpz+MbPr5e5y987dM2fv4/tJbjC7v3P2+JvPnTMzZ85MEEURQhQClUpB7gRBAECUYiYwH6gDqoEKoA1oBDYCy4OQJgB92R3yq2S5yRilWASs6CZ0DzA5CNmn/ObOOUpB7kQpRgNLcwj9AHCnMiYZfXIT0C/H2DlRSs0gyeiPaQ6xg4FapUwy+mKUY/wwpUwy+uK4Y/xhpUwy+mKfY3yTUiYZfdHiENsahBxRyiSjL5odYncpXZLRJ3sdYhuVLslYKDKqZpSMBXObVs0oGQumA6OaUTL6Iwg5CBzNMXy7MiYZffNCDjH7g5DdSpVk9M36mGKEZOwxq4Fj3cT8UmmSjEm0Gw8At2UJaQhCtilTeeRWM5EdkmVfOwCIUtQBE4AqILC1ZQuwPgjpSKryWwgy1gfZfjsQ886IKFY2xO9N0jOR69srDOAtzCyYFuCUSrcg6AOcBIYCY4C3gVeT+uNJyvg94GPAxzFjcDuBl4C/AP+UBwXBR4AaYDYwDvgr8Drwi1KScRnwXfut6wNcYT+7Ma97LgX+JRd6jfOAucAXgCvTfl4DvAuMtJVJ0cu41IoYWRHTGWM/1TZmq/2fF8nR14r4U2BQF7+LgMW2k7bY54X4Htr5EvD99s5SlriPArcAY+VGsh1YYDpwMzAgSwy2svhWscpYA/wkx9gKm5S5wBA5kgjnAJcDX7NNpVxcWAZMLUYZJwHDHeKrgXnAdWjZlSS4BLgVuMzRlxt9eeNTxsG2veFyy7gQWAR8Sq54byfeYDssAx3LqLabJldBytgMHMjjuPHAQvTOsU++aJtE/fI4dpevTqZPGV+2veN8+DTwIHCBr29hmVJhJXwA+GAex7cBjxZjm7EFWAL8DfeX39s7NPOy9PKEO7XAV+k8xJYLrcDPgL8Xo4xgJqIuA7bkeXw9ZsBVxMMMYEqex64FfuO7e++bTcAPgD8Bpx2PvRSYKIdi61DOs3edXImAV4Cv2zJsKnYZ24B/AJ+xteRrwAmHBF4mj2JhEnCRg4QnrYh3YZ5NH/J9gUmP5zXYtsdsW+Pl8vffkEex8I5D7HHgGeBhe0dLhKRlbMJM298NXI8Z68rGk8AGeRQLu4DHMGOL2dgJPA78AXguyQvsjScdrTYp2zBDPzfbXl7mmNc64B7MFCbRc/bbfPYHrs343WnbZHsG+BXwZ8y65JS6jOnfwPuBg8BnMQtxjsWsh/0IsNJ2fkR8bAHutbfhG2x7vp9tDzZiFs5/Non2YaHJ2N6OWQf8BxiBeRx4EDPZ9nm544WNVsLtwFWYJ2Wh/fmO3ryw3noHpiv6YyZ5NsuXROhrRypeAv7nfHQJvAOTjbclYuJ3pWcL6YL03rSQjEJIRiEZhZCMQjIKIRmFZBRCMgrJKIRkFJJRCMkoJKMQklFIRiEkoxCSUUhGISSjkIxCSEYhGYWQjEIyCiEZhWQUQjIKySiEZBSSUQjJKCSjEAVCJUAQmCWPoxSjgZuAaZgF348D+zD7ADYDe+2nGWgJQg52dVJvSzOLgqHdmU5ln2IYZou9861Do+x/j8Ss2z7AOrQJWBOEZtetKIrMmt5BEBClWAQsxW3b16OY/QHXA6uD0GzpG0VRPmt6i2KSMeyQrxpYgNl4dCJmV7NcOQEsCULu6ZCR+mAmZiOannAMuC0IWS0Zy0PGKMUCzFZug3p4ullsiJ5obzPOj+H6BgGrohR1KqrSx5bzqhhE7PCvXcY4BZqgoioL4iznunQZq2M8cZXKqSyIs5yr02WsiPHEaiyWSbMxxnNVpMvYFuOJj6mcyoI4y7ktXcbGGE/conIqC+Is58Z0GTfGdNIGzJijKH3W2/KOg43pMi4n//2F92P2KJ4ShCwMQvT4pRwajCFRELIQmGLLf3+ep9pj/TvjCcwI4E5gDp1H0VsxO7k3Zvy7PQjZnXl2DXqXhYydiFKMAcYD44CajH+HZIQfBdYCtwch+854HJh2wkqgFhgGHAaagpAjLhcqGctTxqxOpKgCRgNDMXuK7whCTqU7U9khz3ucAv59xomUe9FVhePGEfs5q1eaQiYKBskoJKMQklFIRiEko5CMQkhGIRmFkIxCMgohGYVkFEIyCskohGQUklEIySiEZBSSUQjJKCSjEJJRSEYhJKOQjEJIRiEZhZCMQjIKIRmFZBSijGXMvIZ+KpZEaF8qeygwHOjb2xdUWQBJqQL6ADOBi4GHMGuGH5Iv3hiG2SJtIWaV4mZgB/AadF6jvVxkvAKzv3UdMNX+bDJm9fx10PV+1qLHIl4P3GLzfh3QBLwKbAZ+DJwuFxkDm5CZmN0Vzsv4/TTMyviVwGOYnRZEPAwBZgDfAC5K+/lo+5kKXAjcBzwPnCz1NuP77LfxO12I2M7FNmFXE+++huVOPfDNDBEz25FzgHuBa4Bzk8x/0jJeCiwCFmP2BsnGh4BbgYFyKDZmZRExnTpbGcywHZySuk0PsbeAG4HZDt+2C6yMb8mjWHgXs+NFd5v09Ac+AYzC7An0EPBKqdSM1wDfBqY7Vvubk263lDhPYHamypVa4MvAHUCq2GvGgcB8YAEwKQ/5nwa33blEVrYDLwJXOhxzLvBJzDhkK/BCMdaMA4C5wF2Y4RrXv7UF+KO9tYh42A08msfoRxVwLfBDYGwxyliLGUMclMexL9rOy075EyvvAKuBlcCbeTa3Pl+MMk7GbP/qyiHg18BWueOFNnu3ymeP8X62h11dbDKm7K3a9Zv7e+BJOeOVRmCNvQO5cgmdt4AueBkH5zCE0FWHpQH4r3zxzlPAw3kcdxg4VmwybnaMfx1YAWxTpyURjtj24wpHuZ7C0yNanzL+FnjZIX4lsEGOJEorcDewKcf4vTb+ZLHJuAeYBxzvJm4/8CPg58AJ+ZE4BzBDNk93k//jwOeAN4qxNw1m5sdV9jZwtlvv48ADujX3GpFtUt0OhPZnJzN63wdtOW7xeSFJPJvehBnBv8/2ricAp2wb8UHgETRvsRDYCiy3IrbPCWi0Mt4BPOf7AoIoivycub5TR/rDmBkjs4Df2fbHJjlQcLwfuNyW13rMXILOkyQ2REUtI5jnnG+mNRFOF3Gh1dlavgozhHUMaLEFGJWImBVnbT4VlYwlSBCYL1iUYgGw6ixhDUHIwo4GmfIrGX3JGKWotj3KbM/cpwQh2yRjYfWmS5EFdD/54ytKk2RMgukxxQjJ2GMm5hAzPEoxRqmSjN6IUgwj9xkr45UxyeiTkQ6x45QuyeiT8x1ia5QuyeiTUaoZJWMxyqiaUTIWzG1aNaNkLJgOzJAoRZVSJhl9McIxfrRSJhl94fq241ClTDL6Yq9jvCYNS0ZvuEwGPopZmlhIRi+sIfeXxtYGIaeUMsnohSCkCViSQ+gezAtOwiW/mvzpkKz3ZnrPxCz1V4dZd6YC8+JSI2YNm+VWXE2ulYyiGPk/nslB8d6ayMkAAAAASUVORK5CYII="; LoadingScreen.SPINE_LOGO_DATA = "data:image/png;base64,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"; return LoadingScreen; }()); webgl.LoadingScreen = LoadingScreen; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { webgl.M00 = 0; webgl.M01 = 4; webgl.M02 = 8; webgl.M03 = 12; webgl.M10 = 1; webgl.M11 = 5; webgl.M12 = 9; webgl.M13 = 13; webgl.M20 = 2; webgl.M21 = 6; webgl.M22 = 10; webgl.M23 = 14; webgl.M30 = 3; webgl.M31 = 7; webgl.M32 = 11; webgl.M33 = 15; var Matrix4 = (function () { function Matrix4() { this.temp = new Float32Array(16); this.values = new Float32Array(16); var v = this.values; v[webgl.M00] = 1; v[webgl.M11] = 1; v[webgl.M22] = 1; v[webgl.M33] = 1; } Matrix4.prototype.set = function (values) { this.values.set(values); return this; }; Matrix4.prototype.transpose = function () { var t = this.temp; var v = this.values; t[webgl.M00] = v[webgl.M00]; t[webgl.M01] = v[webgl.M10]; t[webgl.M02] = v[webgl.M20]; t[webgl.M03] = v[webgl.M30]; t[webgl.M10] = v[webgl.M01]; t[webgl.M11] = v[webgl.M11]; t[webgl.M12] = v[webgl.M21]; t[webgl.M13] = v[webgl.M31]; t[webgl.M20] = v[webgl.M02]; t[webgl.M21] = v[webgl.M12]; t[webgl.M22] = v[webgl.M22]; t[webgl.M23] = v[webgl.M32]; t[webgl.M30] = v[webgl.M03]; t[webgl.M31] = v[webgl.M13]; t[webgl.M32] = v[webgl.M23]; t[webgl.M33] = v[webgl.M33]; return this.set(t); }; Matrix4.prototype.identity = function () { var v = this.values; v[webgl.M00] = 1; v[webgl.M01] = 0; v[webgl.M02] = 0; v[webgl.M03] = 0; v[webgl.M10] = 0; v[webgl.M11] = 1; v[webgl.M12] = 0; v[webgl.M13] = 0; v[webgl.M20] = 0; v[webgl.M21] = 0; v[webgl.M22] = 1; v[webgl.M23] = 0; v[webgl.M30] = 0; v[webgl.M31] = 0; v[webgl.M32] = 0; v[webgl.M33] = 1; return this; }; Matrix4.prototype.invert = function () { var v = this.values; var t = this.temp; var l_det = v[webgl.M30] * v[webgl.M21] * v[webgl.M12] * v[webgl.M03] - v[webgl.M20] * v[webgl.M31] * v[webgl.M12] * v[webgl.M03] - v[webgl.M30] * v[webgl.M11] * v[webgl.M22] * v[webgl.M03] + v[webgl.M10] * v[webgl.M31] * v[webgl.M22] * v[webgl.M03] + v[webgl.M20] * v[webgl.M11] * v[webgl.M32] * v[webgl.M03] - v[webgl.M10] * v[webgl.M21] * v[webgl.M32] * v[webgl.M03] - v[webgl.M30] * v[webgl.M21] * v[webgl.M02] * v[webgl.M13] + v[webgl.M20] * v[webgl.M31] * v[webgl.M02] * v[webgl.M13] + v[webgl.M30] * v[webgl.M01] * v[webgl.M22] * v[webgl.M13] - v[webgl.M00] * v[webgl.M31] * v[webgl.M22] * v[webgl.M13] - v[webgl.M20] * v[webgl.M01] * v[webgl.M32] * v[webgl.M13] + v[webgl.M00] * v[webgl.M21] * v[webgl.M32] * v[webgl.M13] + v[webgl.M30] * v[webgl.M11] * v[webgl.M02] * v[webgl.M23] - v[webgl.M10] * v[webgl.M31] * v[webgl.M02] * v[webgl.M23] - v[webgl.M30] * v[webgl.M01] * v[webgl.M12] * v[webgl.M23] + v[webgl.M00] * v[webgl.M31] * v[webgl.M12] * v[webgl.M23] + v[webgl.M10] * v[webgl.M01] * v[webgl.M32] * v[webgl.M23] - v[webgl.M00] * v[webgl.M11] * v[webgl.M32] * v[webgl.M23] - v[webgl.M20] * v[webgl.M11] * v[webgl.M02] * v[webgl.M33] + v[webgl.M10] * v[webgl.M21] * v[webgl.M02] * v[webgl.M33] + v[webgl.M20] * v[webgl.M01] * v[webgl.M12] * v[webgl.M33] - v[webgl.M00] * v[webgl.M21] * v[webgl.M12] * v[webgl.M33] - v[webgl.M10] * v[webgl.M01] * v[webgl.M22] * v[webgl.M33] + v[webgl.M00] * v[webgl.M11] * v[webgl.M22] * v[webgl.M33]; if (l_det == 0) throw new Error("non-invertible matrix"); var inv_det = 1.0 / l_det; t[webgl.M00] = v[webgl.M12] * v[webgl.M23] * v[webgl.M31] - v[webgl.M13] * v[webgl.M22] * v[webgl.M31] + v[webgl.M13] * v[webgl.M21] * v[webgl.M32] - v[webgl.M11] * v[webgl.M23] * v[webgl.M32] - v[webgl.M12] * v[webgl.M21] * v[webgl.M33] + v[webgl.M11] * v[webgl.M22] * v[webgl.M33]; t[webgl.M01] = v[webgl.M03] * v[webgl.M22] * v[webgl.M31] - v[webgl.M02] * v[webgl.M23] * v[webgl.M31] - v[webgl.M03] * v[webgl.M21] * v[webgl.M32] + v[webgl.M01] * v[webgl.M23] * v[webgl.M32] + v[webgl.M02] * v[webgl.M21] * v[webgl.M33] - v[webgl.M01] * v[webgl.M22] * v[webgl.M33]; t[webgl.M02] = v[webgl.M02] * v[webgl.M13] * v[webgl.M31] - v[webgl.M03] * v[webgl.M12] * v[webgl.M31] + v[webgl.M03] * v[webgl.M11] * v[webgl.M32] - v[webgl.M01] * v[webgl.M13] * v[webgl.M32] - v[webgl.M02] * v[webgl.M11] * v[webgl.M33] + v[webgl.M01] * v[webgl.M12] * v[webgl.M33]; t[webgl.M03] = v[webgl.M03] * v[webgl.M12] * v[webgl.M21] - v[webgl.M02] * v[webgl.M13] * v[webgl.M21] - v[webgl.M03] * v[webgl.M11] * v[webgl.M22] + v[webgl.M01] * v[webgl.M13] * v[webgl.M22] + v[webgl.M02] * v[webgl.M11] * v[webgl.M23] - v[webgl.M01] * v[webgl.M12] * v[webgl.M23]; t[webgl.M10] = v[webgl.M13] * v[webgl.M22] * v[webgl.M30] - v[webgl.M12] * v[webgl.M23] * v[webgl.M30] - v[webgl.M13] * v[webgl.M20] * v[webgl.M32] + v[webgl.M10] * v[webgl.M23] * v[webgl.M32] + v[webgl.M12] * v[webgl.M20] * v[webgl.M33] - v[webgl.M10] * v[webgl.M22] * v[webgl.M33]; t[webgl.M11] = v[webgl.M02] * v[webgl.M23] * v[webgl.M30] - v[webgl.M03] * v[webgl.M22] * v[webgl.M30] + v[webgl.M03] * v[webgl.M20] * v[webgl.M32] - v[webgl.M00] * v[webgl.M23] * v[webgl.M32] - v[webgl.M02] * v[webgl.M20] * v[webgl.M33] + v[webgl.M00] * v[webgl.M22] * v[webgl.M33]; t[webgl.M12] = v[webgl.M03] * v[webgl.M12] * v[webgl.M30] - v[webgl.M02] * v[webgl.M13] * v[webgl.M30] - v[webgl.M03] * v[webgl.M10] * v[webgl.M32] + v[webgl.M00] * v[webgl.M13] * v[webgl.M32] + v[webgl.M02] * v[webgl.M10] * v[webgl.M33] - v[webgl.M00] * v[webgl.M12] * v[webgl.M33]; t[webgl.M13] = v[webgl.M02] * v[webgl.M13] * v[webgl.M20] - v[webgl.M03] * v[webgl.M12] * v[webgl.M20] + v[webgl.M03] * v[webgl.M10] * v[webgl.M22] - v[webgl.M00] * v[webgl.M13] * v[webgl.M22] - v[webgl.M02] * v[webgl.M10] * v[webgl.M23] + v[webgl.M00] * v[webgl.M12] * v[webgl.M23]; t[webgl.M20] = v[webgl.M11] * v[webgl.M23] * v[webgl.M30] - v[webgl.M13] * v[webgl.M21] * v[webgl.M30] + v[webgl.M13] * v[webgl.M20] * v[webgl.M31] - v[webgl.M10] * v[webgl.M23] * v[webgl.M31] - v[webgl.M11] * v[webgl.M20] * v[webgl.M33] + v[webgl.M10] * v[webgl.M21] * v[webgl.M33]; t[webgl.M21] = v[webgl.M03] * v[webgl.M21] * v[webgl.M30] - v[webgl.M01] * v[webgl.M23] * v[webgl.M30] - v[webgl.M03] * v[webgl.M20] * v[webgl.M31] + v[webgl.M00] * v[webgl.M23] * v[webgl.M31] + v[webgl.M01] * v[webgl.M20] * v[webgl.M33] - v[webgl.M00] * v[webgl.M21] * v[webgl.M33]; t[webgl.M22] = v[webgl.M01] * v[webgl.M13] * v[webgl.M30] - v[webgl.M03] * v[webgl.M11] * v[webgl.M30] + v[webgl.M03] * v[webgl.M10] * v[webgl.M31] - v[webgl.M00] * v[webgl.M13] * v[webgl.M31] - v[webgl.M01] * v[webgl.M10] * v[webgl.M33] + v[webgl.M00] * v[webgl.M11] * v[webgl.M33]; t[webgl.M23] = v[webgl.M03] * v[webgl.M11] * v[webgl.M20] - v[webgl.M01] * v[webgl.M13] * v[webgl.M20] - v[webgl.M03] * v[webgl.M10] * v[webgl.M21] + v[webgl.M00] * v[webgl.M13] * v[webgl.M21] + v[webgl.M01] * v[webgl.M10] * v[webgl.M23] - v[webgl.M00] * v[webgl.M11] * v[webgl.M23]; t[webgl.M30] = v[webgl.M12] * v[webgl.M21] * v[webgl.M30] - v[webgl.M11] * v[webgl.M22] * v[webgl.M30] - v[webgl.M12] * v[webgl.M20] * v[webgl.M31] + v[webgl.M10] * v[webgl.M22] * v[webgl.M31] + v[webgl.M11] * v[webgl.M20] * v[webgl.M32] - v[webgl.M10] * v[webgl.M21] * v[webgl.M32]; t[webgl.M31] = v[webgl.M01] * v[webgl.M22] * v[webgl.M30] - v[webgl.M02] * v[webgl.M21] * v[webgl.M30] + v[webgl.M02] * v[webgl.M20] * v[webgl.M31] - v[webgl.M00] * v[webgl.M22] * v[webgl.M31] - v[webgl.M01] * v[webgl.M20] * v[webgl.M32] + v[webgl.M00] * v[webgl.M21] * v[webgl.M32]; t[webgl.M32] = v[webgl.M02] * v[webgl.M11] * v[webgl.M30] - v[webgl.M01] * v[webgl.M12] * v[webgl.M30] - v[webgl.M02] * v[webgl.M10] * v[webgl.M31] + v[webgl.M00] * v[webgl.M12] * v[webgl.M31] + v[webgl.M01] * v[webgl.M10] * v[webgl.M32] - v[webgl.M00] * v[webgl.M11] * v[webgl.M32]; t[webgl.M33] = v[webgl.M01] * v[webgl.M12] * v[webgl.M20] - v[webgl.M02] * v[webgl.M11] * v[webgl.M20] + v[webgl.M02] * v[webgl.M10] * v[webgl.M21] - v[webgl.M00] * v[webgl.M12] * v[webgl.M21] - v[webgl.M01] * v[webgl.M10] * v[webgl.M22] + v[webgl.M00] * v[webgl.M11] * v[webgl.M22]; v[webgl.M00] = t[webgl.M00] * inv_det; v[webgl.M01] = t[webgl.M01] * inv_det; v[webgl.M02] = t[webgl.M02] * inv_det; v[webgl.M03] = t[webgl.M03] * inv_det; v[webgl.M10] = t[webgl.M10] * inv_det; v[webgl.M11] = t[webgl.M11] * inv_det; v[webgl.M12] = t[webgl.M12] * inv_det; v[webgl.M13] = t[webgl.M13] * inv_det; v[webgl.M20] = t[webgl.M20] * inv_det; v[webgl.M21] = t[webgl.M21] * inv_det; v[webgl.M22] = t[webgl.M22] * inv_det; v[webgl.M23] = t[webgl.M23] * inv_det; v[webgl.M30] = t[webgl.M30] * inv_det; v[webgl.M31] = t[webgl.M31] * inv_det; v[webgl.M32] = t[webgl.M32] * inv_det; v[webgl.M33] = t[webgl.M33] * inv_det; return this; }; Matrix4.prototype.determinant = function () { var v = this.values; return v[webgl.M30] * v[webgl.M21] * v[webgl.M12] * v[webgl.M03] - v[webgl.M20] * v[webgl.M31] * v[webgl.M12] * v[webgl.M03] - v[webgl.M30] * v[webgl.M11] * v[webgl.M22] * v[webgl.M03] + v[webgl.M10] * v[webgl.M31] * v[webgl.M22] * v[webgl.M03] + v[webgl.M20] * v[webgl.M11] * v[webgl.M32] * v[webgl.M03] - v[webgl.M10] * v[webgl.M21] * v[webgl.M32] * v[webgl.M03] - v[webgl.M30] * v[webgl.M21] * v[webgl.M02] * v[webgl.M13] + v[webgl.M20] * v[webgl.M31] * v[webgl.M02] * v[webgl.M13] + v[webgl.M30] * v[webgl.M01] * v[webgl.M22] * v[webgl.M13] - v[webgl.M00] * v[webgl.M31] * v[webgl.M22] * v[webgl.M13] - v[webgl.M20] * v[webgl.M01] * v[webgl.M32] * v[webgl.M13] + v[webgl.M00] * v[webgl.M21] * v[webgl.M32] * v[webgl.M13] + v[webgl.M30] * v[webgl.M11] * v[webgl.M02] * v[webgl.M23] - v[webgl.M10] * v[webgl.M31] * v[webgl.M02] * v[webgl.M23] - v[webgl.M30] * v[webgl.M01] * v[webgl.M12] * v[webgl.M23] + v[webgl.M00] * v[webgl.M31] * v[webgl.M12] * v[webgl.M23] + v[webgl.M10] * v[webgl.M01] * v[webgl.M32] * v[webgl.M23] - v[webgl.M00] * v[webgl.M11] * v[webgl.M32] * v[webgl.M23] - v[webgl.M20] * v[webgl.M11] * v[webgl.M02] * v[webgl.M33] + v[webgl.M10] * v[webgl.M21] * v[webgl.M02] * v[webgl.M33] + v[webgl.M20] * v[webgl.M01] * v[webgl.M12] * v[webgl.M33] - v[webgl.M00] * v[webgl.M21] * v[webgl.M12] * v[webgl.M33] - v[webgl.M10] * v[webgl.M01] * v[webgl.M22] * v[webgl.M33] + v[webgl.M00] * v[webgl.M11] * v[webgl.M22] * v[webgl.M33]; }; Matrix4.prototype.translate = function (x, y, z) { var v = this.values; v[webgl.M03] += x; v[webgl.M13] += y; v[webgl.M23] += z; return this; }; Matrix4.prototype.copy = function () { return new Matrix4().set(this.values); }; Matrix4.prototype.projection = function (near, far, fovy, aspectRatio) { this.identity(); var l_fd = (1.0 / Math.tan((fovy * (Math.PI / 180)) / 2.0)); var l_a1 = (far + near) / (near - far); var l_a2 = (2 * far * near) / (near - far); var v = this.values; v[webgl.M00] = l_fd / aspectRatio; v[webgl.M10] = 0; v[webgl.M20] = 0; v[webgl.M30] = 0; v[webgl.M01] = 0; v[webgl.M11] = l_fd; v[webgl.M21] = 0; v[webgl.M31] = 0; v[webgl.M02] = 0; v[webgl.M12] = 0; v[webgl.M22] = l_a1; v[webgl.M32] = -1; v[webgl.M03] = 0; v[webgl.M13] = 0; v[webgl.M23] = l_a2; v[webgl.M33] = 0; return this; }; Matrix4.prototype.ortho2d = function (x, y, width, height) { return this.ortho(x, x + width, y, y + height, 0, 1); }; Matrix4.prototype.ortho = function (left, right, bottom, top, near, far) { this.identity(); var x_orth = 2 / (right - left); var y_orth = 2 / (top - bottom); var z_orth = -2 / (far - near); var tx = -(right + left) / (right - left); var ty = -(top + bottom) / (top - bottom); var tz = -(far + near) / (far - near); var v = this.values; v[webgl.M00] = x_orth; v[webgl.M10] = 0; v[webgl.M20] = 0; v[webgl.M30] = 0; v[webgl.M01] = 0; v[webgl.M11] = y_orth; v[webgl.M21] = 0; v[webgl.M31] = 0; v[webgl.M02] = 0; v[webgl.M12] = 0; v[webgl.M22] = z_orth; v[webgl.M32] = 0; v[webgl.M03] = tx; v[webgl.M13] = ty; v[webgl.M23] = tz; v[webgl.M33] = 1; return this; }; Matrix4.prototype.multiply = function (matrix) { var t = this.temp; var v = this.values; var m = matrix.values; t[webgl.M00] = v[webgl.M00] * m[webgl.M00] + v[webgl.M01] * m[webgl.M10] + v[webgl.M02] * m[webgl.M20] + v[webgl.M03] * m[webgl.M30]; t[webgl.M01] = v[webgl.M00] * m[webgl.M01] + v[webgl.M01] * m[webgl.M11] + v[webgl.M02] * m[webgl.M21] + v[webgl.M03] * m[webgl.M31]; t[webgl.M02] = v[webgl.M00] * m[webgl.M02] + v[webgl.M01] * m[webgl.M12] + v[webgl.M02] * m[webgl.M22] + v[webgl.M03] * m[webgl.M32]; t[webgl.M03] = v[webgl.M00] * m[webgl.M03] + v[webgl.M01] * m[webgl.M13] + v[webgl.M02] * m[webgl.M23] + v[webgl.M03] * m[webgl.M33]; t[webgl.M10] = v[webgl.M10] * m[webgl.M00] + v[webgl.M11] * m[webgl.M10] + v[webgl.M12] * m[webgl.M20] + v[webgl.M13] * m[webgl.M30]; t[webgl.M11] = v[webgl.M10] * m[webgl.M01] + v[webgl.M11] * m[webgl.M11] + v[webgl.M12] * m[webgl.M21] + v[webgl.M13] * m[webgl.M31]; t[webgl.M12] = v[webgl.M10] * m[webgl.M02] + v[webgl.M11] * m[webgl.M12] + v[webgl.M12] * m[webgl.M22] + v[webgl.M13] * m[webgl.M32]; t[webgl.M13] = v[webgl.M10] * m[webgl.M03] + v[webgl.M11] * m[webgl.M13] + v[webgl.M12] * m[webgl.M23] + v[webgl.M13] * m[webgl.M33]; t[webgl.M20] = v[webgl.M20] * m[webgl.M00] + v[webgl.M21] * m[webgl.M10] + v[webgl.M22] * m[webgl.M20] + v[webgl.M23] * m[webgl.M30]; t[webgl.M21] = v[webgl.M20] * m[webgl.M01] + v[webgl.M21] * m[webgl.M11] + v[webgl.M22] * m[webgl.M21] + v[webgl.M23] * m[webgl.M31]; t[webgl.M22] = v[webgl.M20] * m[webgl.M02] + v[webgl.M21] * m[webgl.M12] + v[webgl.M22] * m[webgl.M22] + v[webgl.M23] * m[webgl.M32]; t[webgl.M23] = v[webgl.M20] * m[webgl.M03] + v[webgl.M21] * m[webgl.M13] + v[webgl.M22] * m[webgl.M23] + v[webgl.M23] * m[webgl.M33]; t[webgl.M30] = v[webgl.M30] * m[webgl.M00] + v[webgl.M31] * m[webgl.M10] + v[webgl.M32] * m[webgl.M20] + v[webgl.M33] * m[webgl.M30]; t[webgl.M31] = v[webgl.M30] * m[webgl.M01] + v[webgl.M31] * m[webgl.M11] + v[webgl.M32] * m[webgl.M21] + v[webgl.M33] * m[webgl.M31]; t[webgl.M32] = v[webgl.M30] * m[webgl.M02] + v[webgl.M31] * m[webgl.M12] + v[webgl.M32] * m[webgl.M22] + v[webgl.M33] * m[webgl.M32]; t[webgl.M33] = v[webgl.M30] * m[webgl.M03] + v[webgl.M31] * m[webgl.M13] + v[webgl.M32] * m[webgl.M23] + v[webgl.M33] * m[webgl.M33]; return this.set(this.temp); }; Matrix4.prototype.multiplyLeft = function (matrix) { var t = this.temp; var v = this.values; var m = matrix.values; t[webgl.M00] = m[webgl.M00] * v[webgl.M00] + m[webgl.M01] * v[webgl.M10] + m[webgl.M02] * v[webgl.M20] + m[webgl.M03] * v[webgl.M30]; t[webgl.M01] = m[webgl.M00] * v[webgl.M01] + m[webgl.M01] * v[webgl.M11] + m[webgl.M02] * v[webgl.M21] + m[webgl.M03] * v[webgl.M31]; t[webgl.M02] = m[webgl.M00] * v[webgl.M02] + m[webgl.M01] * v[webgl.M12] + m[webgl.M02] * v[webgl.M22] + m[webgl.M03] * v[webgl.M32]; t[webgl.M03] = m[webgl.M00] * v[webgl.M03] + m[webgl.M01] * v[webgl.M13] + m[webgl.M02] * v[webgl.M23] + m[webgl.M03] * v[webgl.M33]; t[webgl.M10] = m[webgl.M10] * v[webgl.M00] + m[webgl.M11] * v[webgl.M10] + m[webgl.M12] * v[webgl.M20] + m[webgl.M13] * v[webgl.M30]; t[webgl.M11] = m[webgl.M10] * v[webgl.M01] + m[webgl.M11] * v[webgl.M11] + m[webgl.M12] * v[webgl.M21] + m[webgl.M13] * v[webgl.M31]; t[webgl.M12] = m[webgl.M10] * v[webgl.M02] + m[webgl.M11] * v[webgl.M12] + m[webgl.M12] * v[webgl.M22] + m[webgl.M13] * v[webgl.M32]; t[webgl.M13] = m[webgl.M10] * v[webgl.M03] + m[webgl.M11] * v[webgl.M13] + m[webgl.M12] * v[webgl.M23] + m[webgl.M13] * v[webgl.M33]; t[webgl.M20] = m[webgl.M20] * v[webgl.M00] + m[webgl.M21] * v[webgl.M10] + m[webgl.M22] * v[webgl.M20] + m[webgl.M23] * v[webgl.M30]; t[webgl.M21] = m[webgl.M20] * v[webgl.M01] + m[webgl.M21] * v[webgl.M11] + m[webgl.M22] * v[webgl.M21] + m[webgl.M23] * v[webgl.M31]; t[webgl.M22] = m[webgl.M20] * v[webgl.M02] + m[webgl.M21] * v[webgl.M12] + m[webgl.M22] * v[webgl.M22] + m[webgl.M23] * v[webgl.M32]; t[webgl.M23] = m[webgl.M20] * v[webgl.M03] + m[webgl.M21] * v[webgl.M13] + m[webgl.M22] * v[webgl.M23] + m[webgl.M23] * v[webgl.M33]; t[webgl.M30] = m[webgl.M30] * v[webgl.M00] + m[webgl.M31] * v[webgl.M10] + m[webgl.M32] * v[webgl.M20] + m[webgl.M33] * v[webgl.M30]; t[webgl.M31] = m[webgl.M30] * v[webgl.M01] + m[webgl.M31] * v[webgl.M11] + m[webgl.M32] * v[webgl.M21] + m[webgl.M33] * v[webgl.M31]; t[webgl.M32] = m[webgl.M30] * v[webgl.M02] + m[webgl.M31] * v[webgl.M12] + m[webgl.M32] * v[webgl.M22] + m[webgl.M33] * v[webgl.M32]; t[webgl.M33] = m[webgl.M30] * v[webgl.M03] + m[webgl.M31] * v[webgl.M13] + m[webgl.M32] * v[webgl.M23] + m[webgl.M33] * v[webgl.M33]; return this.set(this.temp); }; Matrix4.prototype.lookAt = function (position, direction, up) { Matrix4.initTemps(); var xAxis = Matrix4.xAxis, yAxis = Matrix4.yAxis, zAxis = Matrix4.zAxis; zAxis.setFrom(direction).normalize(); xAxis.setFrom(direction).normalize(); xAxis.cross(up).normalize(); yAxis.setFrom(xAxis).cross(zAxis).normalize(); this.identity(); var val = this.values; val[webgl.M00] = xAxis.x; val[webgl.M01] = xAxis.y; val[webgl.M02] = xAxis.z; val[webgl.M10] = yAxis.x; val[webgl.M11] = yAxis.y; val[webgl.M12] = yAxis.z; val[webgl.M20] = -zAxis.x; val[webgl.M21] = -zAxis.y; val[webgl.M22] = -zAxis.z; Matrix4.tmpMatrix.identity(); Matrix4.tmpMatrix.values[webgl.M03] = -position.x; Matrix4.tmpMatrix.values[webgl.M13] = -position.y; Matrix4.tmpMatrix.values[webgl.M23] = -position.z; this.multiply(Matrix4.tmpMatrix); return this; }; Matrix4.initTemps = function () { if (Matrix4.xAxis === null) Matrix4.xAxis = new webgl.Vector3(); if (Matrix4.yAxis === null) Matrix4.yAxis = new webgl.Vector3(); if (Matrix4.zAxis === null) Matrix4.zAxis = new webgl.Vector3(); }; Matrix4.xAxis = null; Matrix4.yAxis = null; Matrix4.zAxis = null; Matrix4.tmpMatrix = new Matrix4(); return Matrix4; }()); webgl.Matrix4 = Matrix4; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var Mesh = (function () { function Mesh(context, attributes, maxVertices, maxIndices) { this.attributes = attributes; this.verticesLength = 0; this.dirtyVertices = false; this.indicesLength = 0; this.dirtyIndices = false; this.elementsPerVertex = 0; this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context); this.elementsPerVertex = 0; for (var i = 0; i < attributes.length; i++) { this.elementsPerVertex += attributes[i].numElements; } this.vertices = new Float32Array(maxVertices * this.elementsPerVertex); this.indices = new Uint16Array(maxIndices); this.context.addRestorable(this); } Mesh.prototype.getAttributes = function () { return this.attributes; }; Mesh.prototype.maxVertices = function () { return this.vertices.length / this.elementsPerVertex; }; Mesh.prototype.numVertices = function () { return this.verticesLength / this.elementsPerVertex; }; Mesh.prototype.setVerticesLength = function (length) { this.dirtyVertices = true; this.verticesLength = length; }; Mesh.prototype.getVertices = function () { return this.vertices; }; Mesh.prototype.maxIndices = function () { return this.indices.length; }; Mesh.prototype.numIndices = function () { return this.indicesLength; }; Mesh.prototype.setIndicesLength = function (length) { this.dirtyIndices = true; this.indicesLength = length; }; Mesh.prototype.getIndices = function () { return this.indices; }; ; Mesh.prototype.getVertexSizeInFloats = function () { var size = 0; for (var i = 0; i < this.attributes.length; i++) { var attribute = this.attributes[i]; size += attribute.numElements; } return size; }; Mesh.prototype.setVertices = function (vertices) { this.dirtyVertices = true; if (vertices.length > this.vertices.length) throw Error("Mesh can't store more than " + this.maxVertices() + " vertices"); this.vertices.set(vertices, 0); this.verticesLength = vertices.length; }; Mesh.prototype.setIndices = function (indices) { this.dirtyIndices = true; if (indices.length > this.indices.length) throw Error("Mesh can't store more than " + this.maxIndices() + " indices"); this.indices.set(indices, 0); this.indicesLength = indices.length; }; Mesh.prototype.draw = function (shader, primitiveType) { this.drawWithOffset(shader, primitiveType, 0, this.indicesLength > 0 ? this.indicesLength : this.verticesLength / this.elementsPerVertex); }; Mesh.prototype.drawWithOffset = function (shader, primitiveType, offset, count) { var gl = this.context.gl; if (this.dirtyVertices || this.dirtyIndices) this.update(); this.bind(shader); if (this.indicesLength > 0) { gl.drawElements(primitiveType, count, gl.UNSIGNED_SHORT, offset * 2); } else { gl.drawArrays(primitiveType, offset, count); } this.unbind(shader); }; Mesh.prototype.bind = function (shader) { var gl = this.context.gl; gl.bindBuffer(gl.ARRAY_BUFFER, this.verticesBuffer); var offset = 0; for (var i = 0; i < this.attributes.length; i++) { var attrib = this.attributes[i]; var location_1 = shader.getAttributeLocation(attrib.name); gl.enableVertexAttribArray(location_1); gl.vertexAttribPointer(location_1, attrib.numElements, gl.FLOAT, false, this.elementsPerVertex * 4, offset * 4); offset += attrib.numElements; } if (this.indicesLength > 0) gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indicesBuffer); }; Mesh.prototype.unbind = function (shader) { var gl = this.context.gl; for (var i = 0; i < this.attributes.length; i++) { var attrib = this.attributes[i]; var location_2 = shader.getAttributeLocation(attrib.name); gl.disableVertexAttribArray(location_2); } gl.bindBuffer(gl.ARRAY_BUFFER, null); if (this.indicesLength > 0) gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }; Mesh.prototype.update = function () { var gl = this.context.gl; if (this.dirtyVertices) { if (!this.verticesBuffer) { this.verticesBuffer = gl.createBuffer(); } gl.bindBuffer(gl.ARRAY_BUFFER, this.verticesBuffer); gl.bufferData(gl.ARRAY_BUFFER, this.vertices.subarray(0, this.verticesLength), gl.DYNAMIC_DRAW); this.dirtyVertices = false; } if (this.dirtyIndices) { if (!this.indicesBuffer) { this.indicesBuffer = gl.createBuffer(); } gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indicesBuffer); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.indices.subarray(0, this.indicesLength), gl.DYNAMIC_DRAW); this.dirtyIndices = false; } }; Mesh.prototype.restore = function () { this.verticesBuffer = null; this.indicesBuffer = null; this.update(); }; Mesh.prototype.dispose = function () { this.context.removeRestorable(this); var gl = this.context.gl; gl.deleteBuffer(this.verticesBuffer); gl.deleteBuffer(this.indicesBuffer); }; return Mesh; }()); webgl.Mesh = Mesh; var VertexAttribute = (function () { function VertexAttribute(name, type, numElements) { this.name = name; this.type = type; this.numElements = numElements; } return VertexAttribute; }()); webgl.VertexAttribute = VertexAttribute; var Position2Attribute = (function (_super) { __extends(Position2Attribute, _super); function Position2Attribute() { return _super.call(this, webgl.Shader.POSITION, VertexAttributeType.Float, 2) || this; } return Position2Attribute; }(VertexAttribute)); webgl.Position2Attribute = Position2Attribute; var Position3Attribute = (function (_super) { __extends(Position3Attribute, _super); function Position3Attribute() { return _super.call(this, webgl.Shader.POSITION, VertexAttributeType.Float, 3) || this; } return Position3Attribute; }(VertexAttribute)); webgl.Position3Attribute = Position3Attribute; var TexCoordAttribute = (function (_super) { __extends(TexCoordAttribute, _super); function TexCoordAttribute(unit) { if (unit === void 0) { unit = 0; } return _super.call(this, webgl.Shader.TEXCOORDS + (unit == 0 ? "" : unit), VertexAttributeType.Float, 2) || this; } return TexCoordAttribute; }(VertexAttribute)); webgl.TexCoordAttribute = TexCoordAttribute; var ColorAttribute = (function (_super) { __extends(ColorAttribute, _super); function ColorAttribute() { return _super.call(this, webgl.Shader.COLOR, VertexAttributeType.Float, 4) || this; } return ColorAttribute; }(VertexAttribute)); webgl.ColorAttribute = ColorAttribute; var Color2Attribute = (function (_super) { __extends(Color2Attribute, _super); function Color2Attribute() { return _super.call(this, webgl.Shader.COLOR2, VertexAttributeType.Float, 4) || this; } return Color2Attribute; }(VertexAttribute)); webgl.Color2Attribute = Color2Attribute; var VertexAttributeType; (function (VertexAttributeType) { VertexAttributeType[VertexAttributeType["Float"] = 0] = "Float"; })(VertexAttributeType = webgl.VertexAttributeType || (webgl.VertexAttributeType = {})); })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var PolygonBatcher = (function () { function PolygonBatcher(context, twoColorTint, maxVertices) { if (twoColorTint === void 0) { twoColorTint = true; } if (maxVertices === void 0) { maxVertices = 10920; } this.isDrawing = false; this.shader = null; this.lastTexture = null; this.verticesLength = 0; this.indicesLength = 0; if (maxVertices > 10920) throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices); this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context); var attributes = twoColorTint ? [new webgl.Position2Attribute(), new webgl.ColorAttribute(), new webgl.TexCoordAttribute(), new webgl.Color2Attribute()] : [new webgl.Position2Attribute(), new webgl.ColorAttribute(), new webgl.TexCoordAttribute()]; this.mesh = new webgl.Mesh(context, attributes, maxVertices, maxVertices * 3); this.srcBlend = this.context.gl.SRC_ALPHA; this.dstBlend = this.context.gl.ONE_MINUS_SRC_ALPHA; } PolygonBatcher.prototype.begin = function (shader) { var gl = this.context.gl; if (this.isDrawing) throw new Error("PolygonBatch is already drawing. Call PolygonBatch.end() before calling PolygonBatch.begin()"); this.drawCalls = 0; this.shader = shader; this.lastTexture = null; this.isDrawing = true; gl.enable(gl.BLEND); gl.blendFunc(this.srcBlend, this.dstBlend); }; PolygonBatcher.prototype.setBlendMode = function (srcBlend, dstBlend) { var gl = this.context.gl; this.srcBlend = srcBlend; this.dstBlend = dstBlend; if (this.isDrawing) { this.flush(); gl.blendFunc(this.srcBlend, this.dstBlend); } }; PolygonBatcher.prototype.draw = function (texture, vertices, indices) { if (texture != this.lastTexture) { this.flush(); this.lastTexture = texture; } else if (this.verticesLength + vertices.length > this.mesh.getVertices().length || this.indicesLength + indices.length > this.mesh.getIndices().length) { this.flush(); } var indexStart = this.mesh.numVertices(); this.mesh.getVertices().set(vertices, this.verticesLength); this.verticesLength += vertices.length; this.mesh.setVerticesLength(this.verticesLength); var indicesArray = this.mesh.getIndices(); for (var i = this.indicesLength, j = 0; j < indices.length; i++, j++) indicesArray[i] = indices[j] + indexStart; this.indicesLength += indices.length; this.mesh.setIndicesLength(this.indicesLength); }; PolygonBatcher.prototype.flush = function () { var gl = this.context.gl; if (this.verticesLength == 0) return; this.lastTexture.bind(); this.mesh.draw(this.shader, gl.TRIANGLES); this.verticesLength = 0; this.indicesLength = 0; this.mesh.setVerticesLength(0); this.mesh.setIndicesLength(0); this.drawCalls++; }; PolygonBatcher.prototype.end = function () { var gl = this.context.gl; if (!this.isDrawing) throw new Error("PolygonBatch is not drawing. Call PolygonBatch.begin() before calling PolygonBatch.end()"); if (this.verticesLength > 0 || this.indicesLength > 0) this.flush(); this.shader = null; this.lastTexture = null; this.isDrawing = false; gl.disable(gl.BLEND); }; PolygonBatcher.prototype.getDrawCalls = function () { return this.drawCalls; }; PolygonBatcher.prototype.dispose = function () { this.mesh.dispose(); }; return PolygonBatcher; }()); webgl.PolygonBatcher = PolygonBatcher; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var SceneRenderer = (function () { function SceneRenderer(canvas, context, twoColorTint) { if (twoColorTint === void 0) { twoColorTint = true; } this.twoColorTint = false; this.activeRenderer = null; this.QUAD = [ 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, ]; this.QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0]; this.WHITE = new spine.Color(1, 1, 1, 1); this.canvas = canvas; this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context); this.twoColorTint = twoColorTint; this.camera = new webgl.OrthoCamera(canvas.width, canvas.height); this.batcherShader = twoColorTint ? webgl.Shader.newTwoColoredTextured(this.context) : webgl.Shader.newColoredTextured(this.context); this.batcher = new webgl.PolygonBatcher(this.context, twoColorTint); this.shapesShader = webgl.Shader.newColored(this.context); this.shapes = new webgl.ShapeRenderer(this.context); this.skeletonRenderer = new webgl.SkeletonRenderer(this.context, twoColorTint); this.skeletonDebugRenderer = new webgl.SkeletonDebugRenderer(this.context); } SceneRenderer.prototype.begin = function () { this.camera.update(); this.enableRenderer(this.batcher); }; SceneRenderer.prototype.drawSkeleton = function (skeleton, premultipliedAlpha, slotRangeStart, slotRangeEnd) { if (premultipliedAlpha === void 0) { premultipliedAlpha = false; } if (slotRangeStart === void 0) { slotRangeStart = -1; } if (slotRangeEnd === void 0) { slotRangeEnd = -1; } this.enableRenderer(this.batcher); this.skeletonRenderer.premultipliedAlpha = premultipliedAlpha; this.skeletonRenderer.draw(this.batcher, skeleton, slotRangeStart, slotRangeEnd); }; SceneRenderer.prototype.drawSkeletonDebug = function (skeleton, premultipliedAlpha, ignoredBones) { if (premultipliedAlpha === void 0) { premultipliedAlpha = false; } if (ignoredBones === void 0) { ignoredBones = null; } this.enableRenderer(this.shapes); this.skeletonDebugRenderer.premultipliedAlpha = premultipliedAlpha; this.skeletonDebugRenderer.draw(this.shapes, skeleton, ignoredBones); }; SceneRenderer.prototype.drawTexture = function (texture, x, y, width, height, color) { if (color === void 0) { color = null; } this.enableRenderer(this.batcher); if (color === null) color = this.WHITE; var quad = this.QUAD; var i = 0; quad[i++] = x; quad[i++] = y; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 0; quad[i++] = 1; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x + width; quad[i++] = y; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 1; quad[i++] = 1; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x + width; quad[i++] = y + height; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 1; quad[i++] = 0; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x; quad[i++] = y + height; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 0; quad[i++] = 0; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } this.batcher.draw(texture, quad, this.QUAD_TRIANGLES); }; SceneRenderer.prototype.drawTextureUV = function (texture, x, y, width, height, u, v, u2, v2, color) { if (color === void 0) { color = null; } this.enableRenderer(this.batcher); if (color === null) color = this.WHITE; var quad = this.QUAD; var i = 0; quad[i++] = x; quad[i++] = y; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = u; quad[i++] = v; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x + width; quad[i++] = y; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = u2; quad[i++] = v; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x + width; quad[i++] = y + height; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = u2; quad[i++] = v2; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x; quad[i++] = y + height; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = u; quad[i++] = v2; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } this.batcher.draw(texture, quad, this.QUAD_TRIANGLES); }; SceneRenderer.prototype.drawTextureRotated = function (texture, x, y, width, height, pivotX, pivotY, angle, color, premultipliedAlpha) { if (color === void 0) { color = null; } if (premultipliedAlpha === void 0) { premultipliedAlpha = false; } this.enableRenderer(this.batcher); if (color === null) color = this.WHITE; var quad = this.QUAD; var worldOriginX = x + pivotX; var worldOriginY = y + pivotY; var fx = -pivotX; var fy = -pivotY; var fx2 = width - pivotX; var fy2 = height - pivotY; var p1x = fx; var p1y = fy; var p2x = fx; var p2y = fy2; var p3x = fx2; var p3y = fy2; var p4x = fx2; var p4y = fy; var x1 = 0; var y1 = 0; var x2 = 0; var y2 = 0; var x3 = 0; var y3 = 0; var x4 = 0; var y4 = 0; if (angle != 0) { var cos = spine.MathUtils.cosDeg(angle); var sin = spine.MathUtils.sinDeg(angle); x1 = cos * p1x - sin * p1y; y1 = sin * p1x + cos * p1y; x4 = cos * p2x - sin * p2y; y4 = sin * p2x + cos * p2y; x3 = cos * p3x - sin * p3y; y3 = sin * p3x + cos * p3y; x2 = x3 + (x1 - x4); y2 = y3 + (y1 - y4); } else { x1 = p1x; y1 = p1y; x4 = p2x; y4 = p2y; x3 = p3x; y3 = p3y; x2 = p4x; y2 = p4y; } x1 += worldOriginX; y1 += worldOriginY; x2 += worldOriginX; y2 += worldOriginY; x3 += worldOriginX; y3 += worldOriginY; x4 += worldOriginX; y4 += worldOriginY; var i = 0; quad[i++] = x1; quad[i++] = y1; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 0; quad[i++] = 1; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x2; quad[i++] = y2; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 1; quad[i++] = 1; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x3; quad[i++] = y3; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 1; quad[i++] = 0; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x4; quad[i++] = y4; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = 0; quad[i++] = 0; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } this.batcher.draw(texture, quad, this.QUAD_TRIANGLES); }; SceneRenderer.prototype.drawRegion = function (region, x, y, width, height, color, premultipliedAlpha) { if (color === void 0) { color = null; } if (premultipliedAlpha === void 0) { premultipliedAlpha = false; } this.enableRenderer(this.batcher); if (color === null) color = this.WHITE; var quad = this.QUAD; var i = 0; quad[i++] = x; quad[i++] = y; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = region.u; quad[i++] = region.v2; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x + width; quad[i++] = y; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = region.u2; quad[i++] = region.v2; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x + width; quad[i++] = y + height; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = region.u2; quad[i++] = region.v; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } quad[i++] = x; quad[i++] = y + height; quad[i++] = color.r; quad[i++] = color.g; quad[i++] = color.b; quad[i++] = color.a; quad[i++] = region.u; quad[i++] = region.v; if (this.twoColorTint) { quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; quad[i++] = 0; } this.batcher.draw(region.texture, quad, this.QUAD_TRIANGLES); }; SceneRenderer.prototype.line = function (x, y, x2, y2, color, color2) { if (color === void 0) { color = null; } if (color2 === void 0) { color2 = null; } this.enableRenderer(this.shapes); this.shapes.line(x, y, x2, y2, color); }; SceneRenderer.prototype.triangle = function (filled, x, y, x2, y2, x3, y3, color, color2, color3) { if (color === void 0) { color = null; } if (color2 === void 0) { color2 = null; } if (color3 === void 0) { color3 = null; } this.enableRenderer(this.shapes); this.shapes.triangle(filled, x, y, x2, y2, x3, y3, color, color2, color3); }; SceneRenderer.prototype.quad = function (filled, x, y, x2, y2, x3, y3, x4, y4, color, color2, color3, color4) { if (color === void 0) { color = null; } if (color2 === void 0) { color2 = null; } if (color3 === void 0) { color3 = null; } if (color4 === void 0) { color4 = null; } this.enableRenderer(this.shapes); this.shapes.quad(filled, x, y, x2, y2, x3, y3, x4, y4, color, color2, color3, color4); }; SceneRenderer.prototype.rect = function (filled, x, y, width, height, color) { if (color === void 0) { color = null; } this.enableRenderer(this.shapes); this.shapes.rect(filled, x, y, width, height, color); }; SceneRenderer.prototype.rectLine = function (filled, x1, y1, x2, y2, width, color) { if (color === void 0) { color = null; } this.enableRenderer(this.shapes); this.shapes.rectLine(filled, x1, y1, x2, y2, width, color); }; SceneRenderer.prototype.polygon = function (polygonVertices, offset, count, color) { if (color === void 0) { color = null; } this.enableRenderer(this.shapes); this.shapes.polygon(polygonVertices, offset, count, color); }; SceneRenderer.prototype.circle = function (filled, x, y, radius, color, segments) { if (color === void 0) { color = null; } if (segments === void 0) { segments = 0; } this.enableRenderer(this.shapes); this.shapes.circle(filled, x, y, radius, color, segments); }; SceneRenderer.prototype.curve = function (x1, y1, cx1, cy1, cx2, cy2, x2, y2, segments, color) { if (color === void 0) { color = null; } this.enableRenderer(this.shapes); this.shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, segments, color); }; SceneRenderer.prototype.end = function () { if (this.activeRenderer === this.batcher) this.batcher.end(); else if (this.activeRenderer === this.shapes) this.shapes.end(); this.activeRenderer = null; }; SceneRenderer.prototype.resize = function (resizeMode) { var canvas = this.canvas; var w = canvas.clientWidth; var h = canvas.clientHeight; if (canvas.width != w || canvas.height != h) { canvas.width = w; canvas.height = h; } this.context.gl.viewport(0, 0, canvas.width, canvas.height); if (resizeMode === ResizeMode.Stretch) { } else if (resizeMode === ResizeMode.Expand) { this.camera.setViewport(w, h); } else if (resizeMode === ResizeMode.Fit) { var sourceWidth = canvas.width, sourceHeight = canvas.height; var targetWidth = this.camera.viewportWidth, targetHeight = this.camera.viewportHeight; var targetRatio = targetHeight / targetWidth; var sourceRatio = sourceHeight / sourceWidth; var scale = targetRatio < sourceRatio ? targetWidth / sourceWidth : targetHeight / sourceHeight; this.camera.viewportWidth = sourceWidth * scale; this.camera.viewportHeight = sourceHeight * scale; } this.camera.update(); }; SceneRenderer.prototype.enableRenderer = function (renderer) { if (this.activeRenderer === renderer) return; this.end(); if (renderer instanceof webgl.PolygonBatcher) { this.batcherShader.bind(); this.batcherShader.setUniform4x4f(webgl.Shader.MVP_MATRIX, this.camera.projectionView.values); this.batcherShader.setUniformi("u_texture", 0); this.batcher.begin(this.batcherShader); this.activeRenderer = this.batcher; } else if (renderer instanceof webgl.ShapeRenderer) { this.shapesShader.bind(); this.shapesShader.setUniform4x4f(webgl.Shader.MVP_MATRIX, this.camera.projectionView.values); this.shapes.begin(this.shapesShader); this.activeRenderer = this.shapes; } else { this.activeRenderer = this.skeletonDebugRenderer; } }; SceneRenderer.prototype.dispose = function () { this.batcher.dispose(); this.batcherShader.dispose(); this.shapes.dispose(); this.shapesShader.dispose(); this.skeletonDebugRenderer.dispose(); }; return SceneRenderer; }()); webgl.SceneRenderer = SceneRenderer; var ResizeMode; (function (ResizeMode) { ResizeMode[ResizeMode["Stretch"] = 0] = "Stretch"; ResizeMode[ResizeMode["Expand"] = 1] = "Expand"; ResizeMode[ResizeMode["Fit"] = 2] = "Fit"; })(ResizeMode = webgl.ResizeMode || (webgl.ResizeMode = {})); })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var Shader = (function () { function Shader(context, vertexShader, fragmentShader) { this.vertexShader = vertexShader; this.fragmentShader = fragmentShader; this.vs = null; this.fs = null; this.program = null; this.tmp2x2 = new Float32Array(2 * 2); this.tmp3x3 = new Float32Array(3 * 3); this.tmp4x4 = new Float32Array(4 * 4); this.vsSource = vertexShader; this.fsSource = fragmentShader; this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context); this.context.addRestorable(this); this.compile(); } Shader.prototype.getProgram = function () { return this.program; }; Shader.prototype.getVertexShader = function () { return this.vertexShader; }; Shader.prototype.getFragmentShader = function () { return this.fragmentShader; }; Shader.prototype.getVertexShaderSource = function () { return this.vsSource; }; Shader.prototype.getFragmentSource = function () { return this.fsSource; }; Shader.prototype.compile = function () { var gl = this.context.gl; try { this.vs = this.compileShader(gl.VERTEX_SHADER, this.vertexShader); this.fs = this.compileShader(gl.FRAGMENT_SHADER, this.fragmentShader); this.program = this.compileProgram(this.vs, this.fs); } catch (e) { this.dispose(); throw e; } }; Shader.prototype.compileShader = function (type, source) { var gl = this.context.gl; var shader = gl.createShader(type); gl.shaderSource(shader, source); gl.compileShader(shader); if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) { var error = "Couldn't compile shader: " + gl.getShaderInfoLog(shader); gl.deleteShader(shader); if (!gl.isContextLost()) throw new Error(error); } return shader; }; Shader.prototype.compileProgram = function (vs, fs) { var gl = this.context.gl; var program = gl.createProgram(); gl.attachShader(program, vs); gl.attachShader(program, fs); gl.linkProgram(program); if (!gl.getProgramParameter(program, gl.LINK_STATUS)) { var error = "Couldn't compile shader program: " + gl.getProgramInfoLog(program); gl.deleteProgram(program); if (!gl.isContextLost()) throw new Error(error); } return program; }; Shader.prototype.restore = function () { this.compile(); }; Shader.prototype.bind = function () { this.context.gl.useProgram(this.program); }; Shader.prototype.unbind = function () { this.context.gl.useProgram(null); }; Shader.prototype.setUniformi = function (uniform, value) { this.context.gl.uniform1i(this.getUniformLocation(uniform), value); }; Shader.prototype.setUniformf = function (uniform, value) { this.context.gl.uniform1f(this.getUniformLocation(uniform), value); }; Shader.prototype.setUniform2f = function (uniform, value, value2) { this.context.gl.uniform2f(this.getUniformLocation(uniform), value, value2); }; Shader.prototype.setUniform3f = function (uniform, value, value2, value3) { this.context.gl.uniform3f(this.getUniformLocation(uniform), value, value2, value3); }; Shader.prototype.setUniform4f = function (uniform, value, value2, value3, value4) { this.context.gl.uniform4f(this.getUniformLocation(uniform), value, value2, value3, value4); }; Shader.prototype.setUniform2x2f = function (uniform, value) { var gl = this.context.gl; this.tmp2x2.set(value); gl.uniformMatrix2fv(this.getUniformLocation(uniform), false, this.tmp2x2); }; Shader.prototype.setUniform3x3f = function (uniform, value) { var gl = this.context.gl; this.tmp3x3.set(value); gl.uniformMatrix3fv(this.getUniformLocation(uniform), false, this.tmp3x3); }; Shader.prototype.setUniform4x4f = function (uniform, value) { var gl = this.context.gl; this.tmp4x4.set(value); gl.uniformMatrix4fv(this.getUniformLocation(uniform), false, this.tmp4x4); }; Shader.prototype.getUniformLocation = function (uniform) { var gl = this.context.gl; var location = gl.getUniformLocation(this.program, uniform); if (!location && !gl.isContextLost()) throw new Error("Couldn't find location for uniform " + uniform); return location; }; Shader.prototype.getAttributeLocation = function (attribute) { var gl = this.context.gl; var location = gl.getAttribLocation(this.program, attribute); if (location == -1 && !gl.isContextLost()) throw new Error("Couldn't find location for attribute " + attribute); return location; }; Shader.prototype.dispose = function () { this.context.removeRestorable(this); var gl = this.context.gl; if (this.vs) { gl.deleteShader(this.vs); this.vs = null; } if (this.fs) { gl.deleteShader(this.fs); this.fs = null; } if (this.program) { gl.deleteProgram(this.program); this.program = null; } }; Shader.newColoredTextured = function (context) { var vs = "\n\t\t\t\tattribute vec4 " + Shader.POSITION + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR + ";\n\t\t\t\tattribute vec2 " + Shader.TEXCOORDS + ";\n\t\t\t\tuniform mat4 " + Shader.MVP_MATRIX + ";\n\t\t\t\tvarying vec4 v_color;\n\t\t\t\tvarying vec2 v_texCoords;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tv_color = " + Shader.COLOR + ";\n\t\t\t\t\tv_texCoords = " + Shader.TEXCOORDS + ";\n\t\t\t\t\tgl_Position = " + Shader.MVP_MATRIX + " * " + Shader.POSITION + ";\n\t\t\t\t}\n\t\t\t"; var fs = "\n\t\t\t\t#ifdef GL_ES\n\t\t\t\t\t#define LOWP lowp\n\t\t\t\t\tprecision mediump float;\n\t\t\t\t#else\n\t\t\t\t\t#define LOWP\n\t\t\t\t#endif\n\t\t\t\tvarying LOWP vec4 v_color;\n\t\t\t\tvarying vec2 v_texCoords;\n\t\t\t\tuniform sampler2D u_texture;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tgl_FragColor = v_color * texture2D(u_texture, v_texCoords);\n\t\t\t\t}\n\t\t\t"; return new Shader(context, vs, fs); }; Shader.newTwoColoredTextured = function (context) { var vs = "\n\t\t\t\tattribute vec4 " + Shader.POSITION + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR2 + ";\n\t\t\t\tattribute vec2 " + Shader.TEXCOORDS + ";\n\t\t\t\tuniform mat4 " + Shader.MVP_MATRIX + ";\n\t\t\t\tvarying vec4 v_light;\n\t\t\t\tvarying vec4 v_dark;\n\t\t\t\tvarying vec2 v_texCoords;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tv_light = " + Shader.COLOR + ";\n\t\t\t\t\tv_dark = " + Shader.COLOR2 + ";\n\t\t\t\t\tv_texCoords = " + Shader.TEXCOORDS + ";\n\t\t\t\t\tgl_Position = " + Shader.MVP_MATRIX + " * " + Shader.POSITION + ";\n\t\t\t\t}\n\t\t\t"; var fs = "\n\t\t\t\t#ifdef GL_ES\n\t\t\t\t\t#define LOWP lowp\n\t\t\t\t\tprecision mediump float;\n\t\t\t\t#else\n\t\t\t\t\t#define LOWP\n\t\t\t\t#endif\n\t\t\t\tvarying LOWP vec4 v_light;\n\t\t\t\tvarying LOWP vec4 v_dark;\n\t\t\t\tvarying vec2 v_texCoords;\n\t\t\t\tuniform sampler2D u_texture;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tvec4 texColor = texture2D(u_texture, v_texCoords);\n\t\t\t\t\tgl_FragColor.a = texColor.a * v_light.a;\n\t\t\t\t\tgl_FragColor.rgb = ((texColor.a - 1.0) * v_dark.a + 1.0 - texColor.rgb) * v_dark.rgb + texColor.rgb * v_light.rgb;\n\t\t\t\t}\n\t\t\t"; return new Shader(context, vs, fs); }; Shader.newColored = function (context) { var vs = "\n\t\t\t\tattribute vec4 " + Shader.POSITION + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR + ";\n\t\t\t\tuniform mat4 " + Shader.MVP_MATRIX + ";\n\t\t\t\tvarying vec4 v_color;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tv_color = " + Shader.COLOR + ";\n\t\t\t\t\tgl_Position = " + Shader.MVP_MATRIX + " * " + Shader.POSITION + ";\n\t\t\t\t}\n\t\t\t"; var fs = "\n\t\t\t\t#ifdef GL_ES\n\t\t\t\t\t#define LOWP lowp\n\t\t\t\t\tprecision mediump float;\n\t\t\t\t#else\n\t\t\t\t\t#define LOWP\n\t\t\t\t#endif\n\t\t\t\tvarying LOWP vec4 v_color;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tgl_FragColor = v_color;\n\t\t\t\t}\n\t\t\t"; return new Shader(context, vs, fs); }; Shader.MVP_MATRIX = "u_projTrans"; Shader.POSITION = "a_position"; Shader.COLOR = "a_color"; Shader.COLOR2 = "a_color2"; Shader.TEXCOORDS = "a_texCoords"; Shader.SAMPLER = "u_texture"; return Shader; }()); webgl.Shader = Shader; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var ShapeRenderer = (function () { function ShapeRenderer(context, maxVertices) { if (maxVertices === void 0) { maxVertices = 10920; } this.isDrawing = false; this.shapeType = ShapeType.Filled; this.color = new spine.Color(1, 1, 1, 1); this.vertexIndex = 0; this.tmp = new spine.Vector2(); if (maxVertices > 10920) throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices); this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context); this.mesh = new webgl.Mesh(context, [new webgl.Position2Attribute(), new webgl.ColorAttribute()], maxVertices, 0); this.srcBlend = this.context.gl.SRC_ALPHA; this.dstBlend = this.context.gl.ONE_MINUS_SRC_ALPHA; } ShapeRenderer.prototype.begin = function (shader) { if (this.isDrawing) throw new Error("ShapeRenderer.begin() has already been called"); this.shader = shader; this.vertexIndex = 0; this.isDrawing = true; var gl = this.context.gl; gl.enable(gl.BLEND); gl.blendFunc(this.srcBlend, this.dstBlend); }; ShapeRenderer.prototype.setBlendMode = function (srcBlend, dstBlend) { var gl = this.context.gl; this.srcBlend = srcBlend; this.dstBlend = dstBlend; if (this.isDrawing) { this.flush(); gl.blendFunc(this.srcBlend, this.dstBlend); } }; ShapeRenderer.prototype.setColor = function (color) { this.color.setFromColor(color); }; ShapeRenderer.prototype.setColorWith = function (r, g, b, a) { this.color.set(r, g, b, a); }; ShapeRenderer.prototype.point = function (x, y, color) { if (color === void 0) { color = null; } this.check(ShapeType.Point, 1); if (color === null) color = this.color; this.vertex(x, y, color); }; ShapeRenderer.prototype.line = function (x, y, x2, y2, color) { if (color === void 0) { color = null; } this.check(ShapeType.Line, 2); var vertices = this.mesh.getVertices(); var idx = this.vertexIndex; if (color === null) color = this.color; this.vertex(x, y, color); this.vertex(x2, y2, color); }; ShapeRenderer.prototype.triangle = function (filled, x, y, x2, y2, x3, y3, color, color2, color3) { if (color === void 0) { color = null; } if (color2 === void 0) { color2 = null; } if (color3 === void 0) { color3 = null; } this.check(filled ? ShapeType.Filled : ShapeType.Line, 3); var vertices = this.mesh.getVertices(); var idx = this.vertexIndex; if (color === null) color = this.color; if (color2 === null) color2 = this.color; if (color3 === null) color3 = this.color; if (filled) { this.vertex(x, y, color); this.vertex(x2, y2, color2); this.vertex(x3, y3, color3); } else { this.vertex(x, y, color); this.vertex(x2, y2, color2); this.vertex(x2, y2, color); this.vertex(x3, y3, color2); this.vertex(x3, y3, color); this.vertex(x, y, color2); } }; ShapeRenderer.prototype.quad = function (filled, x, y, x2, y2, x3, y3, x4, y4, color, color2, color3, color4) { if (color === void 0) { color = null; } if (color2 === void 0) { color2 = null; } if (color3 === void 0) { color3 = null; } if (color4 === void 0) { color4 = null; } this.check(filled ? ShapeType.Filled : ShapeType.Line, 3); var vertices = this.mesh.getVertices(); var idx = this.vertexIndex; if (color === null) color = this.color; if (color2 === null) color2 = this.color; if (color3 === null) color3 = this.color; if (color4 === null) color4 = this.color; if (filled) { this.vertex(x, y, color); this.vertex(x2, y2, color2); this.vertex(x3, y3, color3); this.vertex(x3, y3, color3); this.vertex(x4, y4, color4); this.vertex(x, y, color); } else { this.vertex(x, y, color); this.vertex(x2, y2, color2); this.vertex(x2, y2, color2); this.vertex(x3, y3, color3); this.vertex(x3, y3, color3); this.vertex(x4, y4, color4); this.vertex(x4, y4, color4); this.vertex(x, y, color); } }; ShapeRenderer.prototype.rect = function (filled, x, y, width, height, color) { if (color === void 0) { color = null; } this.quad(filled, x, y, x + width, y, x + width, y + height, x, y + height, color, color, color, color); }; ShapeRenderer.prototype.rectLine = function (filled, x1, y1, x2, y2, width, color) { if (color === void 0) { color = null; } this.check(filled ? ShapeType.Filled : ShapeType.Line, 8); if (color === null) color = this.color; var t = this.tmp.set(y2 - y1, x1 - x2); t.normalize(); width *= 0.5; var tx = t.x * width; var ty = t.y * width; if (!filled) { this.vertex(x1 + tx, y1 + ty, color); this.vertex(x1 - tx, y1 - ty, color); this.vertex(x2 + tx, y2 + ty, color); this.vertex(x2 - tx, y2 - ty, color); this.vertex(x2 + tx, y2 + ty, color); this.vertex(x1 + tx, y1 + ty, color); this.vertex(x2 - tx, y2 - ty, color); this.vertex(x1 - tx, y1 - ty, color); } else { this.vertex(x1 + tx, y1 + ty, color); this.vertex(x1 - tx, y1 - ty, color); this.vertex(x2 + tx, y2 + ty, color); this.vertex(x2 - tx, y2 - ty, color); this.vertex(x2 + tx, y2 + ty, color); this.vertex(x1 - tx, y1 - ty, color); } }; ShapeRenderer.prototype.x = function (x, y, size) { this.line(x - size, y - size, x + size, y + size); this.line(x - size, y + size, x + size, y - size); }; ShapeRenderer.prototype.polygon = function (polygonVertices, offset, count, color) { if (color === void 0) { color = null; } if (count < 3) throw new Error("Polygon must contain at least 3 vertices"); this.check(ShapeType.Line, count * 2); if (color === null) color = this.color; var vertices = this.mesh.getVertices(); var idx = this.vertexIndex; offset <<= 1; count <<= 1; var firstX = polygonVertices[offset]; var firstY = polygonVertices[offset + 1]; var last = offset + count; for (var i = offset, n = offset + count - 2; i < n; i += 2) { var x1 = polygonVertices[i]; var y1 = polygonVertices[i + 1]; var x2 = 0; var y2 = 0; if (i + 2 >= last) { x2 = firstX; y2 = firstY; } else { x2 = polygonVertices[i + 2]; y2 = polygonVertices[i + 3]; } this.vertex(x1, y1, color); this.vertex(x2, y2, color); } }; ShapeRenderer.prototype.circle = function (filled, x, y, radius, color, segments) { if (color === void 0) { color = null; } if (segments === void 0) { segments = 0; } if (segments === 0) segments = Math.max(1, (6 * spine.MathUtils.cbrt(radius)) | 0); if (segments <= 0) throw new Error("segments must be > 0."); if (color === null) color = this.color; var angle = 2 * spine.MathUtils.PI / segments; var cos = Math.cos(angle); var sin = Math.sin(angle); var cx = radius, cy = 0; if (!filled) { this.check(ShapeType.Line, segments * 2 + 2); for (var i = 0; i < segments; i++) { this.vertex(x + cx, y + cy, color); var temp_1 = cx; cx = cos * cx - sin * cy; cy = sin * temp_1 + cos * cy; this.vertex(x + cx, y + cy, color); } this.vertex(x + cx, y + cy, color); } else { this.check(ShapeType.Filled, segments * 3 + 3); segments--; for (var i = 0; i < segments; i++) { this.vertex(x, y, color); this.vertex(x + cx, y + cy, color); var temp_2 = cx; cx = cos * cx - sin * cy; cy = sin * temp_2 + cos * cy; this.vertex(x + cx, y + cy, color); } this.vertex(x, y, color); this.vertex(x + cx, y + cy, color); } var temp = cx; cx = radius; cy = 0; this.vertex(x + cx, y + cy, color); }; ShapeRenderer.prototype.curve = function (x1, y1, cx1, cy1, cx2, cy2, x2, y2, segments, color) { if (color === void 0) { color = null; } this.check(ShapeType.Line, segments * 2 + 2); if (color === null) color = this.color; var subdiv_step = 1 / segments; var subdiv_step2 = subdiv_step * subdiv_step; var subdiv_step3 = subdiv_step * subdiv_step * subdiv_step; var pre1 = 3 * subdiv_step; var pre2 = 3 * subdiv_step2; var pre4 = 6 * subdiv_step2; var pre5 = 6 * subdiv_step3; var tmp1x = x1 - cx1 * 2 + cx2; var tmp1y = y1 - cy1 * 2 + cy2; var tmp2x = (cx1 - cx2) * 3 - x1 + x2; var tmp2y = (cy1 - cy2) * 3 - y1 + y2; var fx = x1; var fy = y1; var dfx = (cx1 - x1) * pre1 + tmp1x * pre2 + tmp2x * subdiv_step3; var dfy = (cy1 - y1) * pre1 + tmp1y * pre2 + tmp2y * subdiv_step3; var ddfx = tmp1x * pre4 + tmp2x * pre5; var ddfy = tmp1y * pre4 + tmp2y * pre5; var dddfx = tmp2x * pre5; var dddfy = tmp2y * pre5; while (segments-- > 0) { this.vertex(fx, fy, color); fx += dfx; fy += dfy; dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; this.vertex(fx, fy, color); } this.vertex(fx, fy, color); this.vertex(x2, y2, color); }; ShapeRenderer.prototype.vertex = function (x, y, color) { var idx = this.vertexIndex; var vertices = this.mesh.getVertices(); vertices[idx++] = x; vertices[idx++] = y; vertices[idx++] = color.r; vertices[idx++] = color.g; vertices[idx++] = color.b; vertices[idx++] = color.a; this.vertexIndex = idx; }; ShapeRenderer.prototype.end = function () { if (!this.isDrawing) throw new Error("ShapeRenderer.begin() has not been called"); this.flush(); this.context.gl.disable(this.context.gl.BLEND); this.isDrawing = false; }; ShapeRenderer.prototype.flush = function () { if (this.vertexIndex == 0) return; this.mesh.setVerticesLength(this.vertexIndex); this.mesh.draw(this.shader, this.shapeType); this.vertexIndex = 0; }; ShapeRenderer.prototype.check = function (shapeType, numVertices) { if (!this.isDrawing) throw new Error("ShapeRenderer.begin() has not been called"); if (this.shapeType == shapeType) { if (this.mesh.maxVertices() - this.mesh.numVertices() < numVertices) this.flush(); else return; } else { this.flush(); this.shapeType = shapeType; } }; ShapeRenderer.prototype.dispose = function () { this.mesh.dispose(); }; return ShapeRenderer; }()); webgl.ShapeRenderer = ShapeRenderer; var ShapeType; (function (ShapeType) { ShapeType[ShapeType["Point"] = 0] = "Point"; ShapeType[ShapeType["Line"] = 1] = "Line"; ShapeType[ShapeType["Filled"] = 4] = "Filled"; })(ShapeType = webgl.ShapeType || (webgl.ShapeType = {})); })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var SkeletonDebugRenderer = (function () { function SkeletonDebugRenderer(context) { this.boneLineColor = new spine.Color(1, 0, 0, 1); this.boneOriginColor = new spine.Color(0, 1, 0, 1); this.attachmentLineColor = new spine.Color(0, 0, 1, 0.5); this.triangleLineColor = new spine.Color(1, 0.64, 0, 0.5); this.pathColor = new spine.Color().setFromString("FF7F00"); this.clipColor = new spine.Color(0.8, 0, 0, 2); this.aabbColor = new spine.Color(0, 1, 0, 0.5); this.drawBones = true; this.drawRegionAttachments = true; this.drawBoundingBoxes = true; this.drawMeshHull = true; this.drawMeshTriangles = true; this.drawPaths = true; this.drawSkeletonXY = false; this.drawClipping = true; this.premultipliedAlpha = false; this.scale = 1; this.boneWidth = 2; this.bounds = new spine.SkeletonBounds(); this.temp = new Array(); this.vertices = spine.Utils.newFloatArray(2 * 1024); this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context); } SkeletonDebugRenderer.prototype.draw = function (shapes, skeleton, ignoredBones) { if (ignoredBones === void 0) { ignoredBones = null; } var skeletonX = skeleton.x; var skeletonY = skeleton.y; var gl = this.context.gl; var srcFunc = this.premultipliedAlpha ? gl.ONE : gl.SRC_ALPHA; shapes.setBlendMode(srcFunc, gl.ONE_MINUS_SRC_ALPHA); var bones = skeleton.bones; if (this.drawBones) { shapes.setColor(this.boneLineColor); for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; if (ignoredBones && ignoredBones.indexOf(bone.data.name) > -1) continue; if (bone.parent == null) continue; var x = skeletonX + bone.data.length * bone.a + bone.worldX; var y = skeletonY + bone.data.length * bone.c + bone.worldY; shapes.rectLine(true, skeletonX + bone.worldX, skeletonY + bone.worldY, x, y, this.boneWidth * this.scale); } if (this.drawSkeletonXY) shapes.x(skeletonX, skeletonY, 4 * this.scale); } if (this.drawRegionAttachments) { shapes.setColor(this.attachmentLineColor); var slots = skeleton.slots; for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; var attachment = slot.getAttachment(); if (attachment instanceof spine.RegionAttachment) { var regionAttachment = attachment; var vertices = this.vertices; regionAttachment.computeWorldVertices(slot.bone, vertices, 0, 2); shapes.line(vertices[0], vertices[1], vertices[2], vertices[3]); shapes.line(vertices[2], vertices[3], vertices[4], vertices[5]); shapes.line(vertices[4], vertices[5], vertices[6], vertices[7]); shapes.line(vertices[6], vertices[7], vertices[0], vertices[1]); } } } if (this.drawMeshHull || this.drawMeshTriangles) { var slots = skeleton.slots; for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; var attachment = slot.getAttachment(); if (!(attachment instanceof spine.MeshAttachment)) continue; var mesh = attachment; var vertices = this.vertices; mesh.computeWorldVertices(slot, 0, mesh.worldVerticesLength, vertices, 0, 2); var triangles = mesh.triangles; var hullLength = mesh.hullLength; if (this.drawMeshTriangles) { shapes.setColor(this.triangleLineColor); for (var ii = 0, nn = triangles.length; ii < nn; ii += 3) { var v1 = triangles[ii] * 2, v2 = triangles[ii + 1] * 2, v3 = triangles[ii + 2] * 2; shapes.triangle(false, vertices[v1], vertices[v1 + 1], vertices[v2], vertices[v2 + 1], vertices[v3], vertices[v3 + 1]); } } if (this.drawMeshHull && hullLength > 0) { shapes.setColor(this.attachmentLineColor); hullLength = (hullLength >> 1) * 2; var lastX = vertices[hullLength - 2], lastY = vertices[hullLength - 1]; for (var ii = 0, nn = hullLength; ii < nn; ii += 2) { var x = vertices[ii], y = vertices[ii + 1]; shapes.line(x, y, lastX, lastY); lastX = x; lastY = y; } } } } if (this.drawBoundingBoxes) { var bounds = this.bounds; bounds.update(skeleton, true); shapes.setColor(this.aabbColor); shapes.rect(false, bounds.minX, bounds.minY, bounds.getWidth(), bounds.getHeight()); var polygons = bounds.polygons; var boxes = bounds.boundingBoxes; for (var i = 0, n = polygons.length; i < n; i++) { var polygon = polygons[i]; shapes.setColor(boxes[i].color); shapes.polygon(polygon, 0, polygon.length); } } if (this.drawPaths) { var slots = skeleton.slots; for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; var attachment = slot.getAttachment(); if (!(attachment instanceof spine.PathAttachment)) continue; var path = attachment; var nn = path.worldVerticesLength; var world = this.temp = spine.Utils.setArraySize(this.temp, nn, 0); path.computeWorldVertices(slot, 0, nn, world, 0, 2); var color = this.pathColor; var x1 = world[2], y1 = world[3], x2 = 0, y2 = 0; if (path.closed) { shapes.setColor(color); var cx1 = world[0], cy1 = world[1], cx2 = world[nn - 2], cy2 = world[nn - 1]; x2 = world[nn - 4]; y2 = world[nn - 3]; shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, 32); shapes.setColor(SkeletonDebugRenderer.LIGHT_GRAY); shapes.line(x1, y1, cx1, cy1); shapes.line(x2, y2, cx2, cy2); } nn -= 4; for (var ii = 4; ii < nn; ii += 6) { var cx1 = world[ii], cy1 = world[ii + 1], cx2 = world[ii + 2], cy2 = world[ii + 3]; x2 = world[ii + 4]; y2 = world[ii + 5]; shapes.setColor(color); shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, 32); shapes.setColor(SkeletonDebugRenderer.LIGHT_GRAY); shapes.line(x1, y1, cx1, cy1); shapes.line(x2, y2, cx2, cy2); x1 = x2; y1 = y2; } } } if (this.drawBones) { shapes.setColor(this.boneOriginColor); for (var i = 0, n = bones.length; i < n; i++) { var bone = bones[i]; if (ignoredBones && ignoredBones.indexOf(bone.data.name) > -1) continue; shapes.circle(true, skeletonX + bone.worldX, skeletonY + bone.worldY, 3 * this.scale, SkeletonDebugRenderer.GREEN, 8); } } if (this.drawClipping) { var slots = skeleton.slots; shapes.setColor(this.clipColor); for (var i = 0, n = slots.length; i < n; i++) { var slot = slots[i]; var attachment = slot.getAttachment(); if (!(attachment instanceof spine.ClippingAttachment)) continue; var clip = attachment; var nn = clip.worldVerticesLength; var world = this.temp = spine.Utils.setArraySize(this.temp, nn, 0); clip.computeWorldVertices(slot, 0, nn, world, 0, 2); for (var i_20 = 0, n_2 = world.length; i_20 < n_2; i_20 += 2) { var x = world[i_20]; var y = world[i_20 + 1]; var x2 = world[(i_20 + 2) % world.length]; var y2 = world[(i_20 + 3) % world.length]; shapes.line(x, y, x2, y2); } } } }; SkeletonDebugRenderer.prototype.dispose = function () { }; SkeletonDebugRenderer.LIGHT_GRAY = new spine.Color(192 / 255, 192 / 255, 192 / 255, 1); SkeletonDebugRenderer.GREEN = new spine.Color(0, 1, 0, 1); return SkeletonDebugRenderer; }()); webgl.SkeletonDebugRenderer = SkeletonDebugRenderer; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var Renderable = (function () { function Renderable(vertices, numVertices, numFloats) { this.vertices = vertices; this.numVertices = numVertices; this.numFloats = numFloats; } return Renderable; }()); ; var SkeletonRenderer = (function () { function SkeletonRenderer(context, twoColorTint) { if (twoColorTint === void 0) { twoColorTint = true; } this.premultipliedAlpha = false; this.vertexEffect = null; this.tempColor = new spine.Color(); this.tempColor2 = new spine.Color(); this.vertexSize = 2 + 2 + 4; this.twoColorTint = false; this.renderable = new Renderable(null, 0, 0); this.clipper = new spine.SkeletonClipping(); this.temp = new spine.Vector2(); this.temp2 = new spine.Vector2(); this.temp3 = new spine.Color(); this.temp4 = new spine.Color(); this.twoColorTint = twoColorTint; if (twoColorTint) this.vertexSize += 4; this.vertices = spine.Utils.newFloatArray(this.vertexSize * 1024); } SkeletonRenderer.prototype.draw = function (batcher, skeleton, slotRangeStart, slotRangeEnd) { if (slotRangeStart === void 0) { slotRangeStart = -1; } if (slotRangeEnd === void 0) { slotRangeEnd = -1; } var clipper = this.clipper; var premultipliedAlpha = this.premultipliedAlpha; var twoColorTint = this.twoColorTint; var blendMode = null; var tempPos = this.temp; var tempUv = this.temp2; var tempLight = this.temp3; var tempDark = this.temp4; var renderable = this.renderable; var uvs = null; var triangles = null; var drawOrder = skeleton.drawOrder; var attachmentColor = null; var skeletonColor = skeleton.color; var vertexSize = twoColorTint ? 12 : 8; var inRange = false; if (slotRangeStart == -1) inRange = true; for (var i = 0, n = drawOrder.length; i < n; i++) { var clippedVertexSize = clipper.isClipping() ? 2 : vertexSize; var slot = drawOrder[i]; if (slotRangeStart >= 0 && slotRangeStart == slot.data.index) { inRange = true; } if (!inRange) { clipper.clipEndWithSlot(slot); continue; } if (slotRangeEnd >= 0 && slotRangeEnd == slot.data.index) { inRange = false; } var attachment = slot.getAttachment(); var texture = null; if (attachment instanceof spine.RegionAttachment) { var region = attachment; renderable.vertices = this.vertices; renderable.numVertices = 4; renderable.numFloats = clippedVertexSize << 2; region.computeWorldVertices(slot.bone, renderable.vertices, 0, clippedVertexSize); triangles = SkeletonRenderer.QUAD_TRIANGLES; uvs = region.uvs; texture = region.region.renderObject.texture; attachmentColor = region.color; } else if (attachment instanceof spine.MeshAttachment) { var mesh = attachment; renderable.vertices = this.vertices; renderable.numVertices = (mesh.worldVerticesLength >> 1); renderable.numFloats = renderable.numVertices * clippedVertexSize; if (renderable.numFloats > renderable.vertices.length) { renderable.vertices = this.vertices = spine.Utils.newFloatArray(renderable.numFloats); } mesh.computeWorldVertices(slot, 0, mesh.worldVerticesLength, renderable.vertices, 0, clippedVertexSize); triangles = mesh.triangles; texture = mesh.region.renderObject.texture; uvs = mesh.uvs; attachmentColor = mesh.color; } else if (attachment instanceof spine.ClippingAttachment) { var clip = (attachment); clipper.clipStart(slot, clip); continue; } else { clipper.clipEndWithSlot(slot); continue; } if (texture != null) { var slotColor = slot.color; var finalColor = this.tempColor; finalColor.r = skeletonColor.r * slotColor.r * attachmentColor.r; finalColor.g = skeletonColor.g * slotColor.g * attachmentColor.g; finalColor.b = skeletonColor.b * slotColor.b * attachmentColor.b; finalColor.a = skeletonColor.a * slotColor.a * attachmentColor.a; if (premultipliedAlpha) { finalColor.r *= finalColor.a; finalColor.g *= finalColor.a; finalColor.b *= finalColor.a; } var darkColor = this.tempColor2; if (slot.darkColor == null) darkColor.set(0, 0, 0, 1.0); else { if (premultipliedAlpha) { darkColor.r = slot.darkColor.r * finalColor.a; darkColor.g = slot.darkColor.g * finalColor.a; darkColor.b = slot.darkColor.b * finalColor.a; } else { darkColor.setFromColor(slot.darkColor); } darkColor.a = premultipliedAlpha ? 1.0 : 0.0; } var slotBlendMode = slot.data.blendMode; if (slotBlendMode != blendMode) { blendMode = slotBlendMode; batcher.setBlendMode(webgl.WebGLBlendModeConverter.getSourceGLBlendMode(blendMode, premultipliedAlpha), webgl.WebGLBlendModeConverter.getDestGLBlendMode(blendMode)); } if (clipper.isClipping()) { clipper.clipTriangles(renderable.vertices, renderable.numFloats, triangles, triangles.length, uvs, finalColor, darkColor, twoColorTint); var clippedVertices = new Float32Array(clipper.clippedVertices); var clippedTriangles = clipper.clippedTriangles; if (this.vertexEffect != null) { var vertexEffect = this.vertexEffect; var verts = clippedVertices; if (!twoColorTint) { for (var v = 0, n_3 = clippedVertices.length; v < n_3; v += vertexSize) { tempPos.x = verts[v]; tempPos.y = verts[v + 1]; tempLight.set(verts[v + 2], verts[v + 3], verts[v + 4], verts[v + 5]); tempUv.x = verts[v + 6]; tempUv.y = verts[v + 7]; tempDark.set(0, 0, 0, 0); vertexEffect.transform(tempPos, tempUv, tempLight, tempDark); verts[v] = tempPos.x; verts[v + 1] = tempPos.y; verts[v + 2] = tempLight.r; verts[v + 3] = tempLight.g; verts[v + 4] = tempLight.b; verts[v + 5] = tempLight.a; verts[v + 6] = tempUv.x; verts[v + 7] = tempUv.y; } } else { for (var v = 0, n_4 = clippedVertices.length; v < n_4; v += vertexSize) { tempPos.x = verts[v]; tempPos.y = verts[v + 1]; tempLight.set(verts[v + 2], verts[v + 3], verts[v + 4], verts[v + 5]); tempUv.x = verts[v + 6]; tempUv.y = verts[v + 7]; tempDark.set(verts[v + 8], verts[v + 9], verts[v + 10], verts[v + 11]); vertexEffect.transform(tempPos, tempUv, tempLight, tempDark); verts[v] = tempPos.x; verts[v + 1] = tempPos.y; verts[v + 2] = tempLight.r; verts[v + 3] = tempLight.g; verts[v + 4] = tempLight.b; verts[v + 5] = tempLight.a; verts[v + 6] = tempUv.x; verts[v + 7] = tempUv.y; verts[v + 8] = tempDark.r; verts[v + 9] = tempDark.g; verts[v + 10] = tempDark.b; verts[v + 11] = tempDark.a; } } } batcher.draw(texture, clippedVertices, clippedTriangles); } else { var verts = renderable.vertices; if (this.vertexEffect != null) { var vertexEffect = this.vertexEffect; if (!twoColorTint) { for (var v = 0, u = 0, n_5 = renderable.numFloats; v < n_5; v += vertexSize, u += 2) { tempPos.x = verts[v]; tempPos.y = verts[v + 1]; tempUv.x = uvs[u]; tempUv.y = uvs[u + 1]; tempLight.setFromColor(finalColor); tempDark.set(0, 0, 0, 0); vertexEffect.transform(tempPos, tempUv, tempLight, tempDark); verts[v] = tempPos.x; verts[v + 1] = tempPos.y; verts[v + 2] = tempLight.r; verts[v + 3] = tempLight.g; verts[v + 4] = tempLight.b; verts[v + 5] = tempLight.a; verts[v + 6] = tempUv.x; verts[v + 7] = tempUv.y; } } else { for (var v = 0, u = 0, n_6 = renderable.numFloats; v < n_6; v += vertexSize, u += 2) { tempPos.x = verts[v]; tempPos.y = verts[v + 1]; tempUv.x = uvs[u]; tempUv.y = uvs[u + 1]; tempLight.setFromColor(finalColor); tempDark.setFromColor(darkColor); vertexEffect.transform(tempPos, tempUv, tempLight, tempDark); verts[v] = tempPos.x; verts[v + 1] = tempPos.y; verts[v + 2] = tempLight.r; verts[v + 3] = tempLight.g; verts[v + 4] = tempLight.b; verts[v + 5] = tempLight.a; verts[v + 6] = tempUv.x; verts[v + 7] = tempUv.y; verts[v + 8] = tempDark.r; verts[v + 9] = tempDark.g; verts[v + 10] = tempDark.b; verts[v + 11] = tempDark.a; } } } else { if (!twoColorTint) { for (var v = 2, u = 0, n_7 = renderable.numFloats; v < n_7; v += vertexSize, u += 2) { verts[v] = finalColor.r; verts[v + 1] = finalColor.g; verts[v + 2] = finalColor.b; verts[v + 3] = finalColor.a; verts[v + 4] = uvs[u]; verts[v + 5] = uvs[u + 1]; } } else { for (var v = 2, u = 0, n_8 = renderable.numFloats; v < n_8; v += vertexSize, u += 2) { verts[v] = finalColor.r; verts[v + 1] = finalColor.g; verts[v + 2] = finalColor.b; verts[v + 3] = finalColor.a; verts[v + 4] = uvs[u]; verts[v + 5] = uvs[u + 1]; verts[v + 6] = darkColor.r; verts[v + 7] = darkColor.g; verts[v + 8] = darkColor.b; verts[v + 9] = darkColor.a; } } } var view = renderable.vertices.subarray(0, renderable.numFloats); batcher.draw(texture, view, triangles); } } clipper.clipEndWithSlot(slot); } clipper.clipEnd(); }; SkeletonRenderer.QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0]; return SkeletonRenderer; }()); webgl.SkeletonRenderer = SkeletonRenderer; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var Vector3 = (function () { function Vector3(x, y, z) { if (x === void 0) { x = 0; } if (y === void 0) { y = 0; } if (z === void 0) { z = 0; } this.x = 0; this.y = 0; this.z = 0; this.x = x; this.y = y; this.z = z; } Vector3.prototype.setFrom = function (v) { this.x = v.x; this.y = v.y; this.z = v.z; return this; }; Vector3.prototype.set = function (x, y, z) { this.x = x; this.y = y; this.z = z; return this; }; Vector3.prototype.add = function (v) { this.x += v.x; this.y += v.y; this.z += v.z; return this; }; Vector3.prototype.sub = function (v) { this.x -= v.x; this.y -= v.y; this.z -= v.z; return this; }; Vector3.prototype.scale = function (s) { this.x *= s; this.y *= s; this.z *= s; return this; }; Vector3.prototype.normalize = function () { var len = this.length(); if (len == 0) return this; len = 1 / len; this.x *= len; this.y *= len; this.z *= len; return this; }; Vector3.prototype.cross = function (v) { return this.set(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x); }; Vector3.prototype.multiply = function (matrix) { var l_mat = matrix.values; return this.set(this.x * l_mat[webgl.M00] + this.y * l_mat[webgl.M01] + this.z * l_mat[webgl.M02] + l_mat[webgl.M03], this.x * l_mat[webgl.M10] + this.y * l_mat[webgl.M11] + this.z * l_mat[webgl.M12] + l_mat[webgl.M13], this.x * l_mat[webgl.M20] + this.y * l_mat[webgl.M21] + this.z * l_mat[webgl.M22] + l_mat[webgl.M23]); }; Vector3.prototype.project = function (matrix) { var l_mat = matrix.values; var l_w = 1 / (this.x * l_mat[webgl.M30] + this.y * l_mat[webgl.M31] + this.z * l_mat[webgl.M32] + l_mat[webgl.M33]); return this.set((this.x * l_mat[webgl.M00] + this.y * l_mat[webgl.M01] + this.z * l_mat[webgl.M02] + l_mat[webgl.M03]) * l_w, (this.x * l_mat[webgl.M10] + this.y * l_mat[webgl.M11] + this.z * l_mat[webgl.M12] + l_mat[webgl.M13]) * l_w, (this.x * l_mat[webgl.M20] + this.y * l_mat[webgl.M21] + this.z * l_mat[webgl.M22] + l_mat[webgl.M23]) * l_w); }; Vector3.prototype.dot = function (v) { return this.x * v.x + this.y * v.y + this.z * v.z; }; Vector3.prototype.length = function () { return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); }; Vector3.prototype.distance = function (v) { var a = v.x - this.x; var b = v.y - this.y; var c = v.z - this.z; return Math.sqrt(a * a + b * b + c * c); }; return Vector3; }()); webgl.Vector3 = Vector3; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); var spine; (function (spine) { var webgl; (function (webgl) { var ManagedWebGLRenderingContext = (function () { function ManagedWebGLRenderingContext(canvasOrContext, contextConfig) { if (contextConfig === void 0) { contextConfig = { alpha: "true" }; } var _this = this; this.restorables = new Array(); if (canvasOrContext instanceof HTMLCanvasElement) { var canvas = canvasOrContext; this.gl = (canvas.getContext("webgl", contextConfig) || canvas.getContext("experimental-webgl", contextConfig)); this.canvas = canvas; canvas.addEventListener("webglcontextlost", function (e) { var event = e; if (e) { e.preventDefault(); } }); canvas.addEventListener("webglcontextrestored", function (e) { for (var i = 0, n = _this.restorables.length; i < n; i++) { _this.restorables[i].restore(); } }); } else { this.gl = canvasOrContext; this.canvas = this.gl.canvas; } } ManagedWebGLRenderingContext.prototype.addRestorable = function (restorable) { this.restorables.push(restorable); }; ManagedWebGLRenderingContext.prototype.removeRestorable = function (restorable) { var index = this.restorables.indexOf(restorable); if (index > -1) this.restorables.splice(index, 1); }; return ManagedWebGLRenderingContext; }()); webgl.ManagedWebGLRenderingContext = ManagedWebGLRenderingContext; var WebGLBlendModeConverter = (function () { function WebGLBlendModeConverter() { } WebGLBlendModeConverter.getDestGLBlendMode = function (blendMode) { switch (blendMode) { case spine.BlendMode.Normal: return WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA; case spine.BlendMode.Additive: return WebGLBlendModeConverter.ONE; case spine.BlendMode.Multiply: return WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA; case spine.BlendMode.Screen: return WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA; default: throw new Error("Unknown blend mode: " + blendMode); } }; WebGLBlendModeConverter.getSourceGLBlendMode = function (blendMode, premultipliedAlpha) { if (premultipliedAlpha === void 0) { premultipliedAlpha = false; } switch (blendMode) { case spine.BlendMode.Normal: return premultipliedAlpha ? WebGLBlendModeConverter.ONE : WebGLBlendModeConverter.SRC_ALPHA; case spine.BlendMode.Additive: return premultipliedAlpha ? WebGLBlendModeConverter.ONE : WebGLBlendModeConverter.SRC_ALPHA; case spine.BlendMode.Multiply: return WebGLBlendModeConverter.DST_COLOR; case spine.BlendMode.Screen: return WebGLBlendModeConverter.ONE; default: throw new Error("Unknown blend mode: " + blendMode); } }; WebGLBlendModeConverter.ZERO = 0; WebGLBlendModeConverter.ONE = 1; WebGLBlendModeConverter.SRC_COLOR = 0x0300; WebGLBlendModeConverter.ONE_MINUS_SRC_COLOR = 0x0301; WebGLBlendModeConverter.SRC_ALPHA = 0x0302; WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA = 0x0303; WebGLBlendModeConverter.DST_ALPHA = 0x0304; WebGLBlendModeConverter.ONE_MINUS_DST_ALPHA = 0x0305; WebGLBlendModeConverter.DST_COLOR = 0x0306; return WebGLBlendModeConverter; }()); webgl.WebGLBlendModeConverter = WebGLBlendModeConverter; })(webgl = spine.webgl || (spine.webgl = {})); })(spine || (spine = {})); module.exports = spine;