// spine-pixi-v7/src/require-shim.ts if (typeof window !== "undefined" && window.PIXI) { const prevRequire = window.require; window.require = (x) => { if (prevRequire) return prevRequire(x); else if (x.startsWith("@pixi/")) return window.PIXI; }; } // spine-core/src/Utils.ts var IntSet = class { array = []; add(value) { const contains = this.contains(value); this.array[value | 0] = value | 0; return !contains; } contains(value) { return this.array[value | 0] !== void 0; } remove(value) { this.array[value | 0] = void 0; } clear() { this.array.length = 0; } }; var StringSet = class { entries = {}; size = 0; add(value) { const contains = this.entries[value]; this.entries[value] = true; if (!contains) { this.size++; return true; } return false; } addAll(values) { const oldSize = this.size; for (let i = 0, n = values.length; i < n; i++) this.add(values[i]); return oldSize !== this.size; } contains(value) { return this.entries[value]; } clear() { this.entries = {}; this.size = 0; } }; var Color = class _Color { constructor(r = 0, g = 0, b = 0, a = 0) { this.r = r; this.g = g; this.b = b; this.a = a; } static WHITE = new _Color(1, 1, 1, 1); static RED = new _Color(1, 0, 0, 1); static GREEN = new _Color(0, 1, 0, 1); static BLUE = new _Color(0, 0, 1, 1); static MAGENTA = new _Color(1, 0, 1, 1); set(r, g, b, a) { this.r = r; this.g = g; this.b = b; this.a = a; return this.clamp(); } setFromColor(c) { this.r = c.r; this.g = c.g; this.b = c.b; this.a = c.a; return this; } setFromString(hex) { hex = hex.charAt(0) === "#" ? hex.substr(1) : hex; this.r = parseInt(hex.substr(0, 2), 16) / 255; this.g = parseInt(hex.substr(2, 2), 16) / 255; this.b = parseInt(hex.substr(4, 2), 16) / 255; this.a = hex.length !== 8 ? 1 : parseInt(hex.substr(6, 2), 16) / 255; return this; } add(r, g, b, a) { this.r += r; this.g += g; this.b += b; this.a += a; return this.clamp(); } clamp() { 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; } static rgba8888ToColor(color, value) { color.r = ((value & 4278190080) >>> 24) / 255; color.g = ((value & 16711680) >>> 16) / 255; color.b = ((value & 65280) >>> 8) / 255; color.a = (value & 255) / 255; } static rgb888ToColor(color, value) { color.r = ((value & 16711680) >>> 16) / 255; color.g = ((value & 65280) >>> 8) / 255; color.b = (value & 255) / 255; } toRgb888() { const hex = (x) => `0${(x * 255).toString(16)}`.slice(-2); return Number(`0x${hex(this.r)}${hex(this.g)}${hex(this.b)}`); } static fromString(hex, color = new _Color()) { return color.setFromString(hex); } }; var MathUtils = class _MathUtils { static epsilon = 1e-5; static epsilon2 = _MathUtils.epsilon * _MathUtils.epsilon; // biome-ignore lint/suspicious/noApproximativeNumericConstant: reference runtime static PI = 3.1415927; static PI2 = _MathUtils.PI * 2; static invPI2 = 1 / _MathUtils.PI2; static radiansToDegrees = 180 / _MathUtils.PI; static radDeg = _MathUtils.radiansToDegrees; static degreesToRadians = _MathUtils.PI / 180; static degRad = _MathUtils.degreesToRadians; static clamp(value, min, max) { if (value < min) return min; if (value > max) return max; return value; } static cosDeg(degrees) { return Math.cos(degrees * _MathUtils.degRad); } static sinDeg(degrees) { return Math.sin(degrees * _MathUtils.degRad); } static atan2Deg(y, x) { return Math.atan2(y, x) * _MathUtils.radDeg; } static signum(value) { return value > 0 ? 1 : value < 0 ? -1 : 0; } static toInt(x) { return x > 0 ? Math.floor(x) : Math.ceil(x); } static cbrt(x) { const y = Math.pow(Math.abs(x), 1 / 3); return x < 0 ? -y : y; } static randomTriangular(min, max) { return _MathUtils.randomTriangularWith(min, max, (min + max) * 0.5); } static randomTriangularWith(min, max, mode) { const u = Math.random(); const 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)); } static isPowerOfTwo(value) { return value && (value & value - 1) === 0; } }; var Interpolation = class _Interpolation { static linear = new class extends _Interpolation { applyInternal(a) { return a; } }(); /** Aka "smoothstep". */ static smooth = new class extends _Interpolation { applyInternal(a) { return a * a * (3 - 2 * a); } }(); /** Slow, then fast. */ static slowFast = new class extends _Interpolation { applyInternal(a) { return a * a; } }(); /** Fast, then slow. */ static fastSlow = new class extends _Interpolation { applyInternal(a) { return (a - 1) * (a - 1) * -1 + 1; } }(); static circle = new class extends _Interpolation { applyInternal(a) { if (a <= 0.5) { a *= 2; return (1 - Math.sqrt(1 - a * a)) / 2; } a--; a *= 2; return (Math.sqrt(1 - a * a) + 1) / 2; } }(); apply(start, end, a) { if (end === void 0 || a === void 0) return this.applyInternal(start); return start + (end - start) * this.applyInternal(a); } }; var Pow = class extends Interpolation { power = 2; constructor(power) { super(); this.power = power; } applyInternal(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; } }; var PowOut = class extends Pow { constructor(power) { super(power); } applyInternal(a) { return Math.pow(a - 1, this.power) * (this.power % 2 === 0 ? -1 : 1) + 1; } }; var Utils = class _Utils { static SUPPORTS_TYPED_ARRAYS = typeof Float32Array !== "undefined"; static arrayCopy(source, sourceStart, dest, destStart, numElements) { for (let i = sourceStart, j = destStart; i < sourceStart + numElements; i++, j++) { dest[j] = source[i]; } } static arrayFill(array, fromIndex, toIndex, value) { for (let i = fromIndex; i < toIndex; i++) array[i] = value; } // biome-ignore lint/suspicious/noExplicitAny: ok any in this case static setArraySize(array, size, value = 0) { const oldSize = array.length; if (oldSize === size) return array; array.length = size; if (oldSize < size) { for (let i = oldSize; i < size; i++) array[i] = value; } return array; } // biome-ignore lint/suspicious/noExplicitAny: ok any in this case static ensureArrayCapacity(array, size, value = 0) { if (array.length >= size) return array; return _Utils.setArraySize(array, size, value); } static newArray(size, defaultValue) { const array = []; for (let i = 0; i < size; i++) array[i] = defaultValue; return array; } static newFloatArray(size) { if (_Utils.SUPPORTS_TYPED_ARRAYS) return new Float32Array(size); else { const array = []; for (let i = 0; i < array.length; i++) array[i] = 0; return array; } } static newShortArray(size) { if (_Utils.SUPPORTS_TYPED_ARRAYS) return new Int16Array(size); else { const array = []; for (let i = 0; i < array.length; i++) array[i] = 0; return array; } } static toFloatArray(array) { return _Utils.SUPPORTS_TYPED_ARRAYS ? new Float32Array(array) : array; } static toSinglePrecision(value) { return _Utils.SUPPORTS_TYPED_ARRAYS ? Math.fround(value) : value; } // This function is used to fix WebKit 602 specific issue described at https://esotericsoftware.com/forum/d/10109-ios-10-disappearing-graphics static webkit602BugfixHelper(alpha) { } static contains(array, element, identity = true) { for (let i = 0; i < array.length; i++) if (array[i] === element) return true; return false; } // biome-ignore lint/suspicious/noExplicitAny: ok any in this case static enumValue(type, name) { return type[name[0].toUpperCase() + name.slice(1)]; } }; var DebugUtils = class { static logBones(skeleton) { for (let i = 0; i < skeleton.bones.length; i++) { const bone = skeleton.bones[i].appliedPose; console.log(`${bone.bone.data.name}, ${bone.a}, ${bone.b}, ${bone.c}, ${bone.d}, ${bone.worldX}, ${bone.worldY}`); } } }; var Pool = class { items = []; instantiator; constructor(instantiator) { this.instantiator = instantiator; } obtain() { return this.items.length > 0 ? this.items.pop() : this.instantiator(); } free(item) { item.reset?.(); this.items.push(item); } freeAll(items) { for (let i = 0; i < items.length; i++) this.free(items[i]); } clear() { this.items.length = 0; } }; var Vector2 = class { constructor(x = 0, y = 0) { this.x = x; this.y = y; } set(x, y) { this.x = x; this.y = y; return this; } length() { const x = this.x; const y = this.y; return Math.sqrt(x * x + y * y); } normalize() { const len = this.length(); if (len !== 0) { this.x /= len; this.y /= len; } return this; } }; var TimeKeeper = class { maxDelta = 0.064; framesPerSecond = 0; delta = 0; totalTime = 0; lastTime = Date.now() / 1e3; frameCount = 0; frameTime = 0; update() { const now = Date.now() / 1e3; 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; } } }; var WindowedMean = class { values; addedValues = 0; lastValue = 0; mean = 0; dirty = true; constructor(windowSize = 32) { this.values = new Array(windowSize); } hasEnoughData() { return this.addedValues >= this.values.length; } addValue(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; } getMean() { if (this.hasEnoughData()) { if (this.dirty) { let mean = 0; for (let i = 0; i < this.values.length; i++) mean += this.values[i]; this.mean = mean / this.values.length; this.dirty = false; } return this.mean; } return 0; } }; // spine-core/src/Texture.ts var Texture = class { _image; constructor(image) { this._image = image; } getImage() { return this._image; } }; var TextureFilter = /* @__PURE__ */ ((TextureFilter2) => { TextureFilter2[TextureFilter2["Nearest"] = 9728] = "Nearest"; TextureFilter2[TextureFilter2["Linear"] = 9729] = "Linear"; TextureFilter2[TextureFilter2["MipMap"] = 9987] = "MipMap"; TextureFilter2[TextureFilter2["MipMapNearestNearest"] = 9984] = "MipMapNearestNearest"; TextureFilter2[TextureFilter2["MipMapLinearNearest"] = 9985] = "MipMapLinearNearest"; TextureFilter2[TextureFilter2["MipMapNearestLinear"] = 9986] = "MipMapNearestLinear"; TextureFilter2[TextureFilter2["MipMapLinearLinear"] = 9987] = "MipMapLinearLinear"; return TextureFilter2; })(TextureFilter || {}); var TextureWrap = /* @__PURE__ */ ((TextureWrap2) => { TextureWrap2[TextureWrap2["MirroredRepeat"] = 33648] = "MirroredRepeat"; TextureWrap2[TextureWrap2["ClampToEdge"] = 33071] = "ClampToEdge"; TextureWrap2[TextureWrap2["Repeat"] = 10497] = "Repeat"; return TextureWrap2; })(TextureWrap || {}); var TextureRegion = class { texture; u = 0; v = 0; u2 = 0; v2 = 0; width = 0; height = 0; degrees = 0; offsetX = 0; offsetY = 0; originalWidth = 0; originalHeight = 0; }; var FakeTexture = class extends Texture { setFilters(minFilter, magFilter) { } setWraps(uWrap, vWrap) { } dispose() { } }; // spine-core/src/TextureAtlas.ts var TextureAtlas = class { pages = []; regions = []; constructor(atlasText) { const reader = new TextureAtlasReader(atlasText); const entry = new Array(4); const pageFields = {}; pageFields.size = (page2) => { page2.width = parseInt(entry[1]); page2.height = parseInt(entry[2]); }; pageFields.format = () => { }; pageFields.filter = (page2) => { page2.minFilter = Utils.enumValue(TextureFilter, entry[1]); page2.magFilter = Utils.enumValue(TextureFilter, entry[2]); }; pageFields.repeat = (page2) => { if (entry[1].indexOf("x") !== -1) page2.uWrap = 10497 /* Repeat */; if (entry[1].indexOf("y") !== -1) page2.vWrap = 10497 /* Repeat */; }; pageFields.pma = (page2) => { page2.pma = entry[1] === "true"; }; var regionFields = {}; regionFields.xy = (region) => { region.x = parseInt(entry[1]); region.y = parseInt(entry[2]); }; regionFields.size = (region) => { region.width = parseInt(entry[1]); region.height = parseInt(entry[2]); }; regionFields.bounds = (region) => { region.x = parseInt(entry[1]); region.y = parseInt(entry[2]); region.width = parseInt(entry[3]); region.height = parseInt(entry[4]); }; regionFields.offset = (region) => { region.offsetX = parseInt(entry[1]); region.offsetY = parseInt(entry[2]); }; regionFields.orig = (region) => { region.originalWidth = parseInt(entry[1]); region.originalHeight = parseInt(entry[2]); }; regionFields.offsets = (region) => { region.offsetX = parseInt(entry[1]); region.offsetY = parseInt(entry[2]); region.originalWidth = parseInt(entry[3]); region.originalHeight = parseInt(entry[4]); }; regionFields.rotate = (region) => { const value = entry[1]; if (value === "true") region.degrees = 90; else if (value !== "false") region.degrees = parseInt(value); }; regionFields.index = (region) => { region.index = parseInt(entry[1]); }; let line = reader.readLine(); while (line && line.trim().length === 0) line = reader.readLine(); while (true) { if (!line || line.trim().length === 0) break; if (reader.readEntry(entry, line) === 0) break; line = reader.readLine(); } let page = null; let names = null; let values = null; while (true) { if (line === null) break; if (line.trim().length === 0) { page = null; line = reader.readLine(); } else if (!page) { page = new TextureAtlasPage(line.trim()); while (true) { if (reader.readEntry(entry, line = reader.readLine()) === 0) break; const field = pageFields[entry[0]]; if (field) field(page); } this.pages.push(page); } else { const region = new TextureAtlasRegion(page, line); while (true) { const count = reader.readEntry(entry, line = reader.readLine()); if (count === 0) break; const field = regionFields[entry[0]]; if (field) field(region); else { if (!names) names = []; if (!values) values = []; names.push(entry[0]); const entryValues = []; for (let i = 0; i < count; i++) entryValues.push(parseInt(entry[i + 1])); values.push(entryValues); } } if (region.originalWidth === 0 && region.originalHeight === 0) { region.originalWidth = region.width; region.originalHeight = region.height; } if (names && names.length > 0 && values && values.length > 0) { region.names = names; region.values = values; names = null; values = null; } region.u = region.x / page.width; region.v = region.y / page.height; if (region.degrees === 90) { region.u2 = (region.x + region.height) / page.width; region.v2 = (region.y + region.width) / page.height; } else { region.u2 = (region.x + region.width) / page.width; region.v2 = (region.y + region.height) / page.height; } this.regions.push(region); } } } findRegion(name) { for (let i = 0; i < this.regions.length; i++) { if (this.regions[i].name === name) { return this.regions[i]; } } return null; } setTextures(assetManager, pathPrefix = "") { for (const page of this.pages) page.setTexture(assetManager.get(pathPrefix + page.name)); } dispose() { for (let i = 0; i < this.pages.length; i++) { this.pages[i].texture?.dispose(); } } }; var TextureAtlasReader = class { lines; index = 0; constructor(text) { this.lines = text.split(/\r\n|\r|\n/); } readLine() { if (this.index >= this.lines.length) return null; return this.lines[this.index++]; } readEntry(entry, line) { if (!line) return 0; line = line.trim(); if (line.length === 0) return 0; const colon = line.indexOf(":"); if (colon === -1) return 0; entry[0] = line.substr(0, colon).trim(); for (let i = 1, lastMatch = colon + 1; ; i++) { const comma = line.indexOf(",", lastMatch); if (comma === -1) { entry[i] = line.substr(lastMatch).trim(); return i; } entry[i] = line.substr(lastMatch, comma - lastMatch).trim(); lastMatch = comma + 1; if (i === 4) return 4; } } }; var TextureAtlasPage = class { name; minFilter = 9728 /* Nearest */; magFilter = 9728 /* Nearest */; uWrap = 33071 /* ClampToEdge */; vWrap = 33071 /* ClampToEdge */; texture = null; width = 0; height = 0; pma = false; regions = []; constructor(name) { this.name = name; } setTexture(texture) { this.texture = texture; texture.setFilters(this.minFilter, this.magFilter); texture.setWraps(this.uWrap, this.vWrap); for (const region of this.regions) region.texture = texture; } }; var TextureAtlasRegion = class extends TextureRegion { page; name; x = 0; y = 0; offsetX = 0; offsetY = 0; originalWidth = 0; originalHeight = 0; index = 0; degrees = 0; names = null; values = null; constructor(page, name) { super(); this.page = page; this.name = name; page.regions.push(this); } }; // spine-core/src/attachments/Attachment.ts var Attachment = class _Attachment { static empty = []; name; /** Timelines for the timeline attachment are also applied to this attachment. * @return May be null if no attachment-specific timelines should be applied. */ timelineAttachment; /** Slots that can have attachments whose {@link timelineAttachment} is this attachment. */ timelineSlots = _Attachment.empty; constructor(name) { if (!name) throw new Error("name cannot be null."); this.name = name; this.timelineAttachment = this; } /** Returns true if the {@code slotIndex} or any {@link timelineSlots} have an attachment whose {@link timelineAttachment} is * this attachment. * @param slots The {@link Skeleton.slots}. * @param slotIndex The timeline's primary slot index. */ isTimelineActive(slots, slotIndex, appliedPose) { let slot = slots[slotIndex]; if (slot.bone.isActive()) { const other = (appliedPose ? slot.getAppliedPose() : slot.getPose()).getAttachment(); if (other != null && other.timelineAttachment === this) return true; } for (let i = 0, n = this.timelineSlots.length; i < n; i++) { slot = slots[this.timelineSlots[i]]; if (!slot.bone.isActive()) continue; const other = (appliedPose ? slot.getAppliedPose() : slot.getPose()).getAttachment(); if (other != null && other.timelineAttachment === this) return true; } return false; } }; var VertexAttachment = class _VertexAttachment extends Attachment { static nextID = 0; /** The unique ID for this attachment. */ id = _VertexAttachment.nextID++; /** The bones that affect the {@link vertices}. The entries are, for each vertex, the number of bones affecting the vertex * followed by that many bone indices, which is {@link Skeleton.getBones} index. Null if this attachment has no weights. */ bones = null; /** The vertex positions in the bone's coordinate system. For a non-weighted attachment, the values are `x,y` * entries for each vertex. For a weighted attachment, the values are `x,y,weight` triplets for each bone affecting * each vertex. */ vertices = []; /** The maximum number of world vertex values that can be output by * {@link computeWorldVertices} using the `count` parameter. */ worldVerticesLength = 0; constructor(name) { super(name); } /** Transforms the attachment's local {@link vertices} to world coordinates. If {@link SlotPose.getDeform} is not empty, it * is used to deform the vertices. * * See World transforms in the Spine * Runtimes Guide. * @param start The index of the first {@link vertices} value to transform. Each vertex has 2 values, x and y. * @param count The number of world vertex values to output. Must be <= {@link worldVerticesLength} - `start`. * @param worldVertices The output world vertices. Must have a length >= `offset` + `count` * * `stride` / 2. * @param offset The `worldVertices` index to begin writing values. * @param stride The number of `worldVertices` entries between the value pairs written. */ computeWorldVertices(skeleton, slot, start, count, worldVertices, offset, stride) { count = offset + (count >> 1) * stride; const deformArray = slot.appliedPose.deform; let vertices = this.vertices; const bones = this.bones; if (!bones) { if (deformArray.length > 0) vertices = deformArray; const bone = slot.bone.appliedPose; const x = bone.worldX; const y = bone.worldY; const a = bone.a, b = bone.b, c = bone.c, d = bone.d; for (let v2 = start, w = offset; w < count; v2 += 2, w += stride) { const vx = vertices[v2], vy = vertices[v2 + 1]; worldVertices[w] = vx * a + vy * b + x; worldVertices[w + 1] = vx * c + vy * d + y; } return; } let v = 0, skip = 0; for (let i = 0; i < start; i += 2) { const n = bones[v]; v += n + 1; skip += n; } const skeletonBones = skeleton.bones; if (deformArray.length === 0) { for (let w = offset, b = skip * 3; w < count; w += stride) { let wx = 0, wy = 0; let n = bones[v++]; n += v; for (; v < n; v++, b += 3) { const bone = skeletonBones[bones[v]].appliedPose; const 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 { const deform = deformArray; for (let w = offset, b = skip * 3, f = skip << 1; w < count; w += stride) { let wx = 0, wy = 0; let n = bones[v++]; n += v; for (; v < n; v++, b += 3, f += 2) { const bone = skeletonBones[bones[v]].appliedPose; const 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; } } } /** Does not copy id (generated) or name (set on construction). **/ copyTo(attachment) { if (this.bones) { attachment.bones = []; Utils.arrayCopy(this.bones, 0, attachment.bones, 0, this.bones.length); } else attachment.bones = null; if (this.vertices) { attachment.vertices = Utils.newFloatArray(this.vertices.length); Utils.arrayCopy(this.vertices, 0, attachment.vertices, 0, this.vertices.length); } attachment.worldVerticesLength = this.worldVerticesLength; attachment.timelineAttachment = this.timelineAttachment; attachment.timelineSlots = this.timelineSlots; } }; // spine-core/src/attachments/MeshAttachment.ts var MeshAttachment = class _MeshAttachment extends VertexAttachment { sequence; /** The UV pair for each vertex, normalized within the texture region. */ regionUVs = []; /** Triplets of vertex indices which describe the mesh's triangulation. */ triangles = []; /** The number of entries at the beginning of {@link vertices} that make up the mesh hull. */ hullLength = 0; /** The name of the texture region for this attachment. */ path; /** The color to tint the mesh. */ color = new Color(1, 1, 1, 1); sourceMesh = null; /** Vertex index pairs describing edges for controlling triangulation, or null if nonessential data was not exported. Mesh * triangles do not never cross edges. Triangulation is not performed at runtime. */ edges = []; /** The width of the mesh's image. Available only when nonessential data was exported. */ width = 0; /** The height of the mesh's image. Available only when nonessential data was exported. */ height = 0; tempColor = new Color(0, 0, 0, 0); constructor(name, sequence) { super(name); this.sequence = sequence; } copy() { if (this.sourceMesh) return this.newLinkedMesh(); const copy = new _MeshAttachment(this.name, this.sequence.copy()); copy.path = this.path; copy.color.setFromColor(this.color); this.copyTo(copy); copy.regionUVs = []; Utils.arrayCopy(this.regionUVs, 0, copy.regionUVs, 0, this.regionUVs.length); copy.triangles = []; Utils.arrayCopy(this.triangles, 0, copy.triangles, 0, this.triangles.length); copy.hullLength = this.hullLength; if (this.edges) { copy.edges = []; Utils.arrayCopy(this.edges, 0, copy.edges, 0, this.edges.length); } copy.width = this.width; copy.height = this.height; return copy; } updateSequence() { this.sequence.update(this); } /** The source mesh if this is a linked mesh, else null. A linked mesh shares the {@link bones}, {@link vertices}, * {@link regionUVs}, {@link triangles}, {@link hullLength}, {@link edges}, {@link width}, and {@link height} with the * source mesh, but may have a different {@link name} or {@link path}, and therefore a different texture region. */ getSourceMesh() { return this.sourceMesh; } setSourceMesh(sourceMesh) { this.sourceMesh = sourceMesh; if (sourceMesh) { this.bones = sourceMesh.bones; this.vertices = sourceMesh.vertices; this.worldVerticesLength = sourceMesh.worldVerticesLength; this.regionUVs = sourceMesh.regionUVs; this.triangles = sourceMesh.triangles; this.hullLength = sourceMesh.hullLength; this.worldVerticesLength = sourceMesh.worldVerticesLength; this.edges = sourceMesh.edges; this.width = sourceMesh.width; this.height = sourceMesh.height; } } /** Returns a new mesh with the {@link sourceMesh} set to this mesh's source mesh, if any, else to this mesh. **/ newLinkedMesh() { const copy = new _MeshAttachment(this.name, this.sequence.copy()); copy.timelineAttachment = this.timelineAttachment; copy.path = this.path; copy.color.setFromColor(this.color); copy.setSourceMesh(this.sourceMesh ? this.sourceMesh : this); copy.updateSequence(); return copy; } /** Computes {@link Sequence.getUVs | UVs} for a mesh attachment. * @param uvs Output array for the computed UVs, same length as regionUVs. */ static computeUVs(region, regionUVs, uvs) { if (!region) throw new Error("Region not set."); const n = uvs.length; let u = region.u, v = region.v, width = 0, height = 0; if (region instanceof TextureAtlasRegion) { const page = region.page; const textureWidth = page.width, textureHeight = page.height; switch (region.degrees) { case 90: u -= (region.originalHeight - region.offsetY - region.height) / textureWidth; v -= (region.originalWidth - region.offsetX - region.width) / textureHeight; width = region.originalHeight / textureWidth; height = region.originalWidth / textureHeight; for (let i = 0; i < n; i += 2) { uvs[i] = u + regionUVs[i + 1] * width; uvs[i + 1] = v + (1 - regionUVs[i]) * height; } return; case 180: u -= (region.originalWidth - region.offsetX - region.width) / textureWidth; v -= region.offsetY / textureHeight; width = region.originalWidth / textureWidth; height = region.originalHeight / textureHeight; for (let i = 0; i < n; i += 2) { uvs[i] = u + (1 - regionUVs[i]) * width; uvs[i + 1] = v + (1 - regionUVs[i + 1]) * height; } return; case 270: u -= region.offsetY / textureWidth; v -= region.offsetX / textureHeight; width = region.originalHeight / textureWidth; height = region.originalWidth / textureHeight; for (let i = 0; i < n; i += 2) { uvs[i] = u + (1 - regionUVs[i + 1]) * width; uvs[i + 1] = v + regionUVs[i] * height; } return; default: u -= region.offsetX / textureWidth; v -= (region.originalHeight - region.offsetY - region.height) / textureHeight; width = region.originalWidth / textureWidth; height = region.originalHeight / textureHeight; } } else if (!region) { u = v = 0; width = height = 1; } else { width = region.u2 - u; height = region.v2 - v; } for (let i = 0; i < n; i += 2) { uvs[i] = u + regionUVs[i] * width; uvs[i + 1] = v + regionUVs[i + 1] * height; } } }; // spine-core/src/attachments/RegionAttachment.ts var RegionAttachment = class _RegionAttachment extends Attachment { sequence; /** The local x translation. */ x = 0; /** The local y translation. */ y = 0; /** The local scaleX. */ scaleX = 1; /** The local scaleY. */ scaleY = 1; /** The local rotation in degrees, counter clockwise. */ rotation = 0; /** The width of the region attachment in Spine. */ width = 0; /** The height of the region attachment in Spine. */ height = 0; /** The name of the texture region for this attachment. */ path; /** The color to tint the region attachment. */ color = new Color(1, 1, 1, 1); tempColor = new Color(1, 1, 1, 1); constructor(name, sequence) { super(name); this.sequence = sequence; } copy() { const copy = new _RegionAttachment(this.name, this.sequence.copy()); copy.path = this.path; copy.x = this.x; copy.y = this.y; copy.scaleX = this.scaleX; copy.scaleY = this.scaleY; copy.rotation = this.rotation; copy.width = this.width; copy.height = this.height; copy.color.setFromColor(this.color); return copy; } /** Transforms the attachment's four vertices to world coordinates. * * See World transforms in the Spine * Runtimes Guide. * @param worldVertices The output world vertices. Must have a length >= `offset` + 8. * @param offset The `worldVertices` index to begin writing values. * @param stride The number of `worldVertices` entries between the value pairs written. */ computeWorldVertices(slot, vertexOffsets, worldVertices, offset, stride) { const bone = slot.bone.appliedPose; const x = bone.worldX, y = bone.worldY; const a = bone.a, b = bone.b, c = bone.c, d = bone.d; let offsetX = vertexOffsets[0]; let offsetY = vertexOffsets[1]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; offset += stride; offsetX = vertexOffsets[2]; offsetY = vertexOffsets[3]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; offset += stride; offsetX = vertexOffsets[4]; offsetY = vertexOffsets[5]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; offset += stride; offsetX = vertexOffsets[6]; offsetY = vertexOffsets[7]; worldVertices[offset] = offsetX * a + offsetY * b + x; worldVertices[offset + 1] = offsetX * c + offsetY * d + y; } getOffsets(pose) { return this.sequence.offsets[this.sequence.resolveIndex(pose)]; } updateSequence() { this.sequence.update(this); } /** Computes {@link Sequence.getUVs | UVs} and {@link Sequence.getOffsets | offsets} for a region attachment. * @param uvs Output array for the computed UVs, length of 8. * @param offset Output array for the computed vertex offsets, length of 8. */ static computeUVs(region, x, y, scaleX, scaleY, rotation, width, height, offset, uvs) { if (!region) throw new Error("Region not set."); const regionScaleX = width / region.originalWidth * scaleX; const regionScaleY = height / region.originalHeight * scaleY; const localX = -width / 2 * scaleX + region.offsetX * regionScaleX; const localY = -height / 2 * scaleY + region.offsetY * regionScaleY; const localX2 = localX + region.width * regionScaleX; const localY2 = localY + region.height * regionScaleY; const radians = rotation * MathUtils.degRad; const cos = Math.cos(radians); const sin = Math.sin(radians); const localXCos = localX * cos + x; const localXSin = localX * sin; const localYCos = localY * cos + y; const localYSin = localY * sin; const localX2Cos = localX2 * cos + x; const localX2Sin = localX2 * sin; const localY2Cos = localY2 * cos + y; const localY2Sin = localY2 * sin; offset[0] = localXCos - localYSin; offset[1] = localYCos + localXSin; offset[2] = localXCos - localY2Sin; offset[3] = localY2Cos + localXSin; offset[4] = localX2Cos - localY2Sin; offset[5] = localY2Cos + localX2Sin; offset[6] = localX2Cos - localYSin; offset[7] = localYCos + localX2Sin; if (region == null) { uvs[0] = 0; uvs[1] = 0; uvs[2] = 0; uvs[3] = 1; uvs[4] = 1; uvs[5] = 1; uvs[6] = 1; uvs[7] = 0; } else { uvs[1] = region.v2; uvs[2] = region.u; uvs[5] = region.v; uvs[6] = region.u2; if (region.degrees === 90) { uvs[0] = region.u2; uvs[3] = region.v2; uvs[4] = region.u; uvs[7] = region.v; } else { uvs[0] = region.u; uvs[3] = region.v; uvs[4] = region.u2; uvs[7] = region.v2; } } } static X1 = 0; static Y1 = 1; static C1R = 2; static C1G = 3; static C1B = 4; static C1A = 5; static U1 = 6; static V1 = 7; static X2 = 8; static Y2 = 9; static C2R = 10; static C2G = 11; static C2B = 12; static C2A = 13; static U2 = 14; static V2 = 15; static X3 = 16; static Y3 = 17; static C3R = 18; static C3G = 19; static C3B = 20; static C3A = 21; static U3 = 22; static V3 = 23; static X4 = 24; static Y4 = 25; static C4R = 26; static C4G = 27; static C4B = 28; static C4A = 29; static U4 = 30; static V4 = 31; }; // spine-core/src/attachments/Sequence.ts var Sequence = class _Sequence { static _nextID = 0; id = _Sequence.nextID(); /** The list of texture regions this sequence will display. */ regions; pathSuffix; uvs; /** Returns vertex offsets from the center of a {@link RegionAttachment}. Invalid to call for a {@link MeshAttachment}. */ offsets; /** The starting number for the numeric {@link getPath | path} suffix. */ start = 0; /** The minimum number of digits in the numeric {@link getPath | path} suffix, for zero padding. 0 for no zero * padding. */ digits = 0; /** The index of the region to show for the setup pose. */ setupIndex = 0; /** @param count The number of texture regions this sequence will display. * @param pathSuffix If true, the {@link getPath | path} has a numeric suffix. If false, all regions will use the * same path, so `count` should be 1. */ constructor(count, pathSuffix) { this.regions = new Array(count); this.pathSuffix = pathSuffix; } copy() { const regionCount = this.regions.length; const copy = new _Sequence(regionCount, this.pathSuffix); Utils.arrayCopy(this.regions, 0, copy.regions, 0, regionCount); copy.start = this.start; copy.digits = this.digits; copy.setupIndex = this.setupIndex; if (this.uvs != null) { const length = this.uvs[0].length; copy.uvs = []; for (let i = 0; i < regionCount; i++) { copy.uvs[i] = Utils.newFloatArray(length); Utils.arrayCopy(this.uvs[i], 0, copy.uvs[i], 0, length); } } if (this.offsets != null) { copy.offsets = []; for (let i = 0; i < regionCount; i++) { copy.offsets[i] = []; Utils.arrayCopy(this.offsets[i], 0, copy.offsets[i], 0, 8); } } return copy; } /** Computes UVs and offsets for the specified attachment. Must be called if the regions or attachment properties are * changed. */ update(attachment) { const regionCount = this.regions.length; if (attachment instanceof RegionAttachment) { this.uvs = []; this.offsets = []; for (let i = 0; i < regionCount; i++) { this.uvs[i] = Utils.newFloatArray(8); this.offsets[i] = []; RegionAttachment.computeUVs( this.regions[i], attachment.x, attachment.y, attachment.scaleX, attachment.scaleY, attachment.rotation, attachment.width, attachment.height, this.offsets[i], this.uvs[i] ); } } else if (attachment instanceof MeshAttachment) { const regionUVs = attachment.regionUVs; this.uvs = []; this.offsets = void 0; for (let i = 0; i < regionCount; i++) { this.uvs[i] = Utils.newFloatArray(regionUVs.length); MeshAttachment.computeUVs(this.regions[i], regionUVs, this.uvs[i]); } } } /** Returns the {@link regions} index for the {@link SlotPose.getSequenceIndex}. */ resolveIndex(pose) { let index = pose.sequenceIndex; if (index === -1) index = this.setupIndex; if (index >= this.regions.length) index = this.regions.length - 1; return index; } /** Returns the UVs for the specified index. {@link regions Regions} must be populated and {@link update} called * before calling this method. */ getUVs(index) { return this.uvs[index]; } /** Returns true if the {@link getPath | path} has a numeric suffix. */ hasPathSuffix() { return this.pathSuffix; } /** Returns the specified base path with an optional numeric suffix for the specified index. */ getPath(basePath, index) { if (!this.pathSuffix) return basePath; let result = basePath; const frame = (this.start + index).toString(); for (let i = this.digits - frame.length; i > 0; i--) result += "0"; result += frame; return result; } static nextID() { return _Sequence._nextID++; } }; var SequenceMode = /* @__PURE__ */ ((SequenceMode2) => { SequenceMode2[SequenceMode2["hold"] = 0] = "hold"; SequenceMode2[SequenceMode2["once"] = 1] = "once"; SequenceMode2[SequenceMode2["loop"] = 2] = "loop"; SequenceMode2[SequenceMode2["pingpong"] = 3] = "pingpong"; SequenceMode2[SequenceMode2["onceReverse"] = 4] = "onceReverse"; SequenceMode2[SequenceMode2["loopReverse"] = 5] = "loopReverse"; SequenceMode2[SequenceMode2["pingpongReverse"] = 6] = "pingpongReverse"; return SequenceMode2; })(SequenceMode || {}); var SequenceModeValues = [ 0 /* hold */, 1 /* once */, 2 /* loop */, 3 /* pingpong */, 4 /* onceReverse */, 5 /* loopReverse */, 6 /* pingpongReverse */ ]; // spine-core/src/Animation.ts var Animation = class { /** The animation's name, unique across all animations in the skeleton. * * See {@link SkeletonData.findAnimation}. */ name; /** The duration of the animation in seconds, which is usually the highest time of all frames in the timelines. The duration is * used to know when the animation has completed and, for animations that repeat, when it should loop back to the start. */ timelines = []; timelineIds; /** {@link Skeleton.getBones} indices that this animation's timelines modify. * * See {@link BoneTimeline.bones}. */ bones; // Nonessential. /** The color of the animation as it was in Spine, or a default color if nonessential data was not exported. */ color = new Color(1, 1, 1, 1); /** The duration of the animation in seconds, which is usually the highest time of all frames in the timeline. The duration is * used to know when it has completed and when it should loop back to the start. */ duration; constructor(name, timelines, duration) { if (!name) throw new Error("name cannot be null."); this.name = name; this.duration = duration; this.timelineIds = new StringSet(); this.bones = []; this.setTimelines(timelines); } setTimelines(timelines) { if (!timelines) throw new Error("timelines cannot be null."); this.timelines = timelines; const n = timelines.length; this.timelineIds.clear(); this.bones.length = 0; const boneSet = /* @__PURE__ */ new Set(); const items = timelines; for (let i = 0; i < n; i++) { const timeline = items[i]; this.timelineIds.addAll(timeline.propertyIds); if (isBoneTimeline(timeline) && boneSet.add(timeline.boneIndex)) this.bones.push(timeline.boneIndex); } } /** Returns true if this animation contains a timeline with any of the specified property IDs. * * See {@link Timeline.propertyIds}. */ hasTimeline(ids) { for (let i = 0; i < ids.length; i++) if (this.timelineIds.contains(ids[i])) return true; return false; } /** Applies the animation's timelines to the specified skeleton. * * See {@link Timeline.apply} and * Applying Animations in the Spine Runtimes * Guide. * @param skeleton The skeleton the animation is applied to. This provides access to the bones, slots, and other skeleton * components the timelines may change. * @param lastTime The last time in seconds this animation was applied. Some timelines trigger only at discrete times, in which * case all keys are triggered between `lastTime` (exclusive) and `time` (inclusive). Pass -1 * the first time an animation is applied to ensure frame 0 is triggered. * @param time The time in seconds the skeleton is being posed for. Timelines find the frame before and after this time and * interpolate between the frame values. * @param loop True if `time` beyond the {@link duration} repeats the animation, else the last frame is used. * @param events If any events are fired, they are added to this list. Pass null to ignore fired events or if no timelines fire * events. * @param alpha 0 applies setup or current values (depending on `from`), 1 uses timeline values, and intermediate * values interpolate between them. Adjusting `alpha` over time can mix an animation in or out. * @param from Controls how `alpha` and `add` mix from current or setup pose values to timeline values. * @param add If true, for timelines that support it, their values are added to the setup or current values (depending on * `from`). * @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions. * @param appliedPose True to modify {@link Posed.appliedPose}, else {@link Posed.pose} is modified. */ apply(skeleton, lastTime, time, loop, events, alpha, from, add, out, appliedPose) { if (!skeleton) throw new Error("skeleton cannot be null."); if (loop && this.duration !== 0) { time %= this.duration; if (lastTime > 0) lastTime %= this.duration; } const timelines = this.timelines; for (let i = 0, n = timelines.length; i < n; i++) timelines[i].apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose); } }; var MixFrom = /* @__PURE__ */ ((MixFrom2) => { MixFrom2[MixFrom2["current"] = 0] = "current"; MixFrom2[MixFrom2["setup"] = 1] = "setup"; MixFrom2[MixFrom2["first"] = 2] = "first"; return MixFrom2; })(MixFrom || {}); var Property = /* @__PURE__ */ ((Property2) => { Property2[Property2["rotate"] = 0] = "rotate"; Property2[Property2["x"] = 1] = "x"; Property2[Property2["y"] = 2] = "y"; Property2[Property2["scaleX"] = 3] = "scaleX"; Property2[Property2["scaleY"] = 4] = "scaleY"; Property2[Property2["shearX"] = 5] = "shearX"; Property2[Property2["shearY"] = 6] = "shearY"; Property2[Property2["inherit"] = 7] = "inherit"; Property2[Property2["rgb"] = 8] = "rgb"; Property2[Property2["alpha"] = 9] = "alpha"; Property2[Property2["rgb2"] = 10] = "rgb2"; Property2[Property2["attachment"] = 11] = "attachment"; Property2[Property2["deform"] = 12] = "deform"; Property2[Property2["event"] = 13] = "event"; Property2[Property2["drawOrder"] = 14] = "drawOrder"; Property2[Property2["drawOrderFolder"] = 15] = "drawOrderFolder"; Property2[Property2["ikConstraint"] = 16] = "ikConstraint"; Property2[Property2["transformConstraint"] = 17] = "transformConstraint"; Property2[Property2["pathConstraintPosition"] = 18] = "pathConstraintPosition"; Property2[Property2["pathConstraintSpacing"] = 19] = "pathConstraintSpacing"; Property2[Property2["pathConstraintMix"] = 20] = "pathConstraintMix"; Property2[Property2["physicsConstraintInertia"] = 21] = "physicsConstraintInertia"; Property2[Property2["physicsConstraintStrength"] = 22] = "physicsConstraintStrength"; Property2[Property2["physicsConstraintDamping"] = 23] = "physicsConstraintDamping"; Property2[Property2["physicsConstraintMass"] = 24] = "physicsConstraintMass"; Property2[Property2["physicsConstraintWind"] = 25] = "physicsConstraintWind"; Property2[Property2["physicsConstraintGravity"] = 26] = "physicsConstraintGravity"; Property2[Property2["physicsConstraintMix"] = 27] = "physicsConstraintMix"; Property2[Property2["physicsConstraintReset"] = 28] = "physicsConstraintReset"; Property2[Property2["sequence"] = 29] = "sequence"; Property2[Property2["sliderTime"] = 30] = "sliderTime"; Property2[Property2["sliderMix"] = 31] = "sliderMix"; return Property2; })(Property || {}); var Timeline = class { propertyIds; frames; /** True if this timeline supports being applied additively. * * See the `add` parameter in {@link Timeline.apply}. */ additive = false; /** True if this timeline sets values instantaneously and does not support interpolation between frames. */ instant = false; constructor(frameCount, ...propertyIds) { this.propertyIds = propertyIds; this.frames = Utils.newFloatArray(frameCount * this.getFrameEntries()); } getPropertyIds() { return this.propertyIds; } /** The number of values stored per frame. */ getFrameEntries() { return 1; } /** The number of frames in this timeline. */ getFrameCount() { return this.frames.length / this.getFrameEntries(); } /** The duration of the timeline in seconds, which is usually the highest time of all frames in the timeline. */ getDuration() { return this.frames[this.frames.length - this.getFrameEntries()]; } /** Linear search using the specified stride (default 1). * @param time Must be >= the first value in `frames`. * @return The index of the first value <= `time`. */ static search(frames, time, step = 1) { const n = frames.length; for (let i = step; i < n; i += step) if (frames[i] > time) return i - step; return n - step; } }; function isSlotTimeline(obj) { return typeof obj === "object" && obj !== null && typeof obj.slotIndex === "number"; } var CurveTimeline = class extends Timeline { curves; // type, x, y, ... constructor(frameCount, bezierCount, ...propertyIds) { super(frameCount, ...propertyIds); this.curves = Utils.newFloatArray( frameCount + bezierCount * 18 /*BEZIER_SIZE*/ ); this.curves[frameCount - 1] = 1; } /** Sets the specified key frame to linear interpolation. */ setLinear(frame) { this.curves[frame] = 0; } /** Sets the specified key frame to stepped interpolation. */ setStepped(frame) { this.curves[frame] = 1; } /** Shrinks the storage for Bezier curves, for use when `bezierCount` (specified in the constructor) was larger * than the actual number of Bezier curves. */ shrink(bezierCount) { const size = this.getFrameCount() + bezierCount * 18; if (this.curves.length > size) { const newCurves = Utils.newFloatArray(size); Utils.arrayCopy(this.curves, 0, newCurves, 0, size); this.curves = newCurves; } } /** Stores the segments for the specified Bezier curve. For timelines that modify multiple values, there may be more than * one curve per frame. * @param bezier The ordinal of this Bezier curve for this timeline, between 0 and `bezierCount - 1` (specified * in the constructor), inclusive. * @param frame Between 0 and `frameCount - 1`, inclusive. * @param value The index of the value for this frame that this curve is used for. * @param time1 The time for the first key. * @param value1 The value for the first key. * @param cx1 The time for the first Bezier handle. * @param cy1 The value for the first Bezier handle. * @param cx2 The time of the second Bezier handle. * @param cy2 The value for the second Bezier handle. * @param time2 The time for the second key. * @param value2 The value for the second key. */ setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2) { const curves = this.curves; let i = this.getFrameCount() + bezier * 18; if (value === 0) curves[frame] = 2 + i; const tmpx = (time1 - cx1 * 2 + cx2) * 0.03, tmpy = (value1 - cy1 * 2 + cy2) * 0.03; const dddx = ((cx1 - cx2) * 3 - time1 + time2) * 6e-3, dddy = ((cy1 - cy2) * 3 - value1 + value2) * 6e-3; let ddx = tmpx * 2 + dddx, ddy = tmpy * 2 + dddy; let dx = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy = (cy1 - value1) * 0.3 + tmpy + dddy * 0.16666667; let x = time1 + dx, y = value1 + dy; for (let n = i + 18; i < n; i += 2) { curves[i] = x; curves[i + 1] = y; dx += ddx; dy += ddy; ddx += dddx; ddy += dddy; x += dx; y += dy; } } /** Returns the Bezier interpolated value for the specified time. * @param frameIndex The index into {@link frames} for the values of the frame before `time`. * @param valueOffset The offset from `frameIndex` to the value this curve is used for. * @param i The index of the Bezier segments. See {@link getCurveType}. */ getBezierValue(time, frameIndex, valueOffset, i) { const curves = this.curves; if (curves[i] > time) { const x2 = this.frames[frameIndex], y2 = this.frames[frameIndex + valueOffset]; return y2 + (time - x2) / (curves[i] - x2) * (curves[i + 1] - y2); } const n = i + 18; for (i += 2; i < n; i += 2) { if (curves[i] >= time) { const x2 = curves[i - 2], y2 = curves[i - 1]; return y2 + (time - x2) / (curves[i] - x2) * (curves[i + 1] - y2); } } frameIndex += this.getFrameEntries(); const x = curves[n - 2], y = curves[n - 1]; return y + (time - x) / (this.frames[frameIndex] - x) * (this.frames[frameIndex + valueOffset] - y); } }; var CurveTimeline1 = class _CurveTimeline1 extends CurveTimeline { constructor(frameCount, bezierCount, propertyId) { super(frameCount, bezierCount, propertyId); } getFrameEntries() { return 2; } /** Sets the time and value for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. */ setFrame(frame, time, value) { frame <<= 1; this.frames[frame] = time; this.frames[ frame + 1 /*VALUE*/ ] = value; } /** Returns the interpolated value for the specified time. */ getCurveValue(time) { const frames = this.frames; let i = frames.length - 2; for (let ii = 2; ii <= i; ii += 2) { if (frames[ii] > time) { i = ii - 2; break; } } const curveType = this.curves[i >> 1]; switch (curveType) { case 0: { const before = frames[i], value = frames[ i + 1 /*VALUE*/ ]; return value + (time - before) / (frames[ i + 2 /*ENTRIES*/ ] - before) * (frames[ i + 2 + 1 /*VALUE*/ ] - value); } case 1: return frames[ i + 1 /*VALUE*/ ]; } return this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); } /** Returns the interpolated value for properties relative to the setup value. The timeline value is added to the setup * value, rather than replacing it. * * See {@link Timeline.apply}. * @param current The current value for the property. * @param setup The setup value for the property. */ getRelativeValue(time, alpha, from, add, current, setup) { if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup); const value = this.getCurveValue(time); return from === 1 /* setup */ ? setup + value * alpha : current + (add ? value : value + setup - current) * alpha; } getAbsoluteValue(time, alpha, from, add, current, setup, value) { if (value === void 0) return this.getAbsoluteValue1(time, alpha, from, add, current, setup); else return this.getAbsoluteValue2(time, alpha, from, add, current, setup, value); } getAbsoluteValue1(time, alpha, from, add, current, setup) { if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup); const value = this.getCurveValue(time); return from === 1 /* setup */ ? setup + (add ? value : value - setup) * alpha : current + (add ? value : value - current) * alpha; } getAbsoluteValue2(time, alpha, from, add, current, setup, value) { if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup); return from === 1 /* setup */ ? setup + (add ? value : value - setup) * alpha : current + (add ? value : value - current) * alpha; } /** Returns the interpolated value for scale properties. The timeline and setup values are multiplied and sign adjusted. * * See {@link Timeline.apply}. * @param current The current value for the property. * @param setup The setup value for the property. */ getScaleValue(time, alpha, from, add, out, current, setup) { if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup); const value = this.getCurveValue(time) * setup; if (alpha === 1 && !add) return value; let base = from === 1 /* setup */ ? setup : current; if (add) return base + (value - setup) * alpha; if (out) return base + (Math.abs(value) * Math.sign(base) - base) * alpha; base = Math.abs(base) * Math.sign(value); return base + (value - base) * alpha; } static beforeFirstKey(from, alpha, current, setup) { switch (from) { case 1 /* setup */: return setup; case 2 /* first */: return current + (setup - current) * alpha; case 0 /* current */: return current; } } }; function isBoneTimeline(obj) { return typeof obj === "object" && obj !== null && typeof obj.boneIndex === "number"; } var BoneTimeline1 = class extends CurveTimeline1 { boneIndex; constructor(frameCount, bezierCount, boneIndex, property) { super(frameCount, bezierCount, `${property}|${boneIndex}`); this.boneIndex = boneIndex; this.additive = true; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const bone = skeleton.bones[this.boneIndex]; if (bone.active) this.apply1(appliedPose ? bone.appliedPose : bone.pose, bone.data.setupPose, time, alpha, from, add, out); } }; var BoneTimeline2 = class extends CurveTimeline { boneIndex; /** @param bezierCount The maximum number of Bezier curves. See {@link shrink}. * @param propertyIds Unique identifiers for the properties the timeline modifies. */ constructor(frameCount, bezierCount, boneIndex, property1, property2) { super(frameCount, bezierCount, `${property1}|${boneIndex}`, `${property2}|${boneIndex}`); this.boneIndex = boneIndex; this.additive = true; } getFrameEntries() { return 3; } /** Sets the time and values for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. */ setFrame(frame, time, value1, value2) { frame *= 3; this.frames[frame] = time; this.frames[ frame + 1 /*VALUE1*/ ] = value1; this.frames[ frame + 2 /*VALUE2*/ ] = value2; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const bone = skeleton.bones[this.boneIndex]; if (bone.active) this.apply1(appliedPose ? bone.appliedPose : bone.pose, bone.data.setupPose, time, alpha, from, add, out); } }; var RotateTimeline = class extends BoneTimeline1 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 0 /* rotate */); } apply1(pose, setup, time, alpha, from, add, out) { pose.rotation = this.getRelativeValue(time, alpha, from, add, pose.rotation, setup.rotation); } }; var TranslateTimeline = class extends BoneTimeline2 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 1 /* x */, 2 /* y */); } apply1(pose, setup, time, alpha, from, add, out) { const frames = this.frames; if (time < frames[0]) { switch (from) { case 1 /* setup */: pose.x = setup.x; pose.y = setup.y; break; case 2 /* first */: pose.x += (setup.x - pose.x) * alpha; pose.y += (setup.y - pose.y) * alpha; break; } return; } let x = 0, y = 0; const i = Timeline.search( frames, time, 3 /*ENTRIES*/ ); const curveType = this.curves[ i / 3 /*ENTRIES*/ ]; switch (curveType) { case 0: { const before = frames[i]; x = frames[ i + 1 /*VALUE1*/ ]; y = frames[ i + 2 /*VALUE2*/ ]; const t = (time - before) / (frames[ i + 3 /*ENTRIES*/ ] - before); x += (frames[ i + 3 + 1 /*VALUE1*/ ] - x) * t; y += (frames[ i + 3 + 2 /*VALUE2*/ ] - y) * t; break; } case 1: x = frames[ i + 1 /*VALUE1*/ ]; y = frames[ i + 2 /*VALUE2*/ ]; break; default: x = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); y = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); } if (from === 1 /* setup */) { pose.x = setup.x + x * alpha; pose.y = setup.y + y * alpha; } else if (add) { pose.x += x * alpha; pose.y += y * alpha; } else { pose.x += (setup.x + x - pose.x) * alpha; pose.y += (setup.y + y - pose.y) * alpha; } } }; var TranslateXTimeline = class extends BoneTimeline1 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 1 /* x */); } apply1(pose, setup, time, alpha, from, add, out) { pose.x = this.getRelativeValue(time, alpha, from, add, pose.x, setup.x); } }; var TranslateYTimeline = class extends BoneTimeline1 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 2 /* y */); } apply1(pose, setup, time, alpha, from, add, out) { pose.y = this.getRelativeValue(time, alpha, from, add, pose.y, setup.y); } }; var ScaleTimeline = class extends BoneTimeline2 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 3 /* scaleX */, 4 /* scaleY */); } apply1(pose, setup, time, alpha, from, add, out) { const frames = this.frames; if (time < frames[0]) { switch (from) { case 1 /* setup */: pose.scaleX = setup.scaleX; pose.scaleY = setup.scaleY; break; case 2 /* first */: pose.scaleX += (setup.scaleX - pose.scaleX) * alpha; pose.scaleY += (setup.scaleY - pose.scaleY) * alpha; break; } return; } let x, y; const i = Timeline.search( frames, time, 3 /*ENTRIES*/ ); const curveType = this.curves[ i / 3 /*ENTRIES*/ ]; switch (curveType) { case 0: { const before = frames[i]; x = frames[ i + 1 /*VALUE1*/ ]; y = frames[ i + 2 /*VALUE2*/ ]; const t = (time - before) / (frames[ i + 3 /*ENTRIES*/ ] - before); x += (frames[ i + 3 + 1 /*VALUE1*/ ] - x) * t; y += (frames[ i + 3 + 2 /*VALUE2*/ ] - y) * t; break; } case 1: x = frames[ i + 1 /*VALUE1*/ ]; y = frames[ i + 2 /*VALUE2*/ ]; break; default: x = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); y = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); } x *= setup.scaleX; y *= setup.scaleY; if (alpha === 1 && !add) { pose.scaleX = x; pose.scaleY = y; } else { let bx = 0, by = 0; if (from === 1 /* setup */) { bx = setup.scaleX; by = setup.scaleY; } else { bx = pose.scaleX; by = pose.scaleY; } if (add) { pose.scaleX = bx + (x - setup.scaleX) * alpha; pose.scaleY = by + (y - setup.scaleY) * alpha; } else if (out) { pose.scaleX = bx + (Math.abs(x) * Math.sign(bx) - bx) * alpha; pose.scaleY = by + (Math.abs(y) * Math.sign(by) - by) * alpha; } else { bx = Math.abs(bx) * Math.sign(x); by = Math.abs(by) * Math.sign(y); pose.scaleX = bx + (x - bx) * alpha; pose.scaleY = by + (y - by) * alpha; } } } }; var ScaleXTimeline = class extends BoneTimeline1 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 3 /* scaleX */); } apply1(pose, setup, time, alpha, from, add, out) { pose.scaleX = this.getScaleValue(time, alpha, from, add, out, pose.scaleX, setup.scaleX); } }; var ScaleYTimeline = class extends BoneTimeline1 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 4 /* scaleY */); } apply1(pose, setup, time, alpha, from, add, out) { pose.scaleY = this.getScaleValue(time, alpha, from, add, out, pose.scaleY, setup.scaleY); } }; var ShearTimeline = class extends BoneTimeline2 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 5 /* shearX */, 6 /* shearY */); } apply1(pose, setup, time, alpha, from, add, out) { const frames = this.frames; if (time < frames[0]) { switch (from) { case 1 /* setup */: pose.shearX = setup.shearX; pose.shearY = setup.shearY; break; case 2 /* first */: pose.shearX += (setup.shearX - pose.shearX) * alpha; pose.shearY += (setup.shearY - pose.shearY) * alpha; break; } return; } let x = 0, y = 0; const i = Timeline.search( frames, time, 3 /*ENTRIES*/ ); const curveType = this.curves[ i / 3 /*ENTRIES*/ ]; switch (curveType) { case 0: { const before = frames[i]; x = frames[ i + 1 /*VALUE1*/ ]; y = frames[ i + 2 /*VALUE2*/ ]; const t = (time - before) / (frames[ i + 3 /*ENTRIES*/ ] - before); x += (frames[ i + 3 + 1 /*VALUE1*/ ] - x) * t; y += (frames[ i + 3 + 2 /*VALUE2*/ ] - y) * t; break; } case 1: x = frames[ i + 1 /*VALUE1*/ ]; y = frames[ i + 2 /*VALUE2*/ ]; break; default: x = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); y = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); } if (from === 1 /* setup */) { pose.shearX = setup.shearX + x * alpha; pose.shearY = setup.shearY + y * alpha; } else if (add) { pose.shearX += x * alpha; pose.shearY += y * alpha; } else { pose.shearX += (setup.shearX + x - pose.shearX) * alpha; pose.shearY += (setup.shearY + y - pose.shearY) * alpha; } } }; var ShearXTimeline = class extends BoneTimeline1 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 5 /* shearX */); } apply1(pose, setup, time, alpha, from, add, out) { pose.shearX = this.getRelativeValue(time, alpha, from, add, pose.shearX, setup.shearX); } }; var ShearYTimeline = class extends BoneTimeline1 { constructor(frameCount, bezierCount, boneIndex) { super(frameCount, bezierCount, boneIndex, 6 /* shearY */); } apply1(pose, setup, time, alpha, from, add, out) { pose.shearY = this.getRelativeValue(time, alpha, from, add, pose.shearY, setup.shearY); } }; var InheritTimeline = class extends Timeline { boneIndex; constructor(frameCount, boneIndex) { super(frameCount, `${7 /* inherit */}|${boneIndex}`); this.boneIndex = boneIndex; this.instant = true; } getFrameEntries() { return 2; } /** Sets the inherit transform mode for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. */ setFrame(frame, time, inherit) { frame *= 2; this.frames[frame] = time; this.frames[ frame + 1 /*INHERIT*/ ] = inherit; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const bone = skeleton.bones[this.boneIndex]; if (!bone.active) return; const pose = appliedPose ? bone.appliedPose : bone.pose; if (out) { if (from !== 0 /* current */) pose.inherit = bone.data.setupPose.inherit; } else { const frames = this.frames; if (time < frames[0]) { if (from !== 0 /* current */) pose.inherit = bone.data.setupPose.inherit; } else pose.inherit = this.frames[ Timeline.search( frames, time, 2 /*ENTRIES*/ ) + 1 /*INHERIT*/ ]; } } }; var SlotCurveTimeline = class extends CurveTimeline { slotIndex; constructor(frameCount, bezierCount, slotIndex, ...propertyIds) { super(frameCount, bezierCount, ...propertyIds); this.slotIndex = slotIndex; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const slot = skeleton.slots[this.slotIndex]; if (slot.bone.active) this.apply1(slot, appliedPose ? slot.appliedPose : slot.pose, time, alpha, from, add); } }; var RGBATimeline = class extends SlotCurveTimeline { constructor(frameCount, bezierCount, slotIndex) { super( frameCount, bezierCount, slotIndex, // `${8 /* rgb */}|${slotIndex}`, // `${9 /* alpha */}|${slotIndex}` ); } getFrameEntries() { return 5; } /** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */ setFrame(frame, time, r, g, b, a) { frame *= 5; this.frames[frame] = time; this.frames[ frame + 1 /*R*/ ] = r; this.frames[ frame + 2 /*G*/ ] = g; this.frames[ frame + 3 /*B*/ ] = b; this.frames[ frame + 4 /*A*/ ] = a; } apply1(slot, pose, time, alpha, from, add) { const color = pose.color; const frames = this.frames; if (time < frames[0]) { const setup = slot.data.setupPose.color; switch (from) { case 1 /* setup */: color.setFromColor(setup); break; case 2 /* first */: color.add( (setup.r - color.r) * alpha, (setup.g - color.g) * alpha, (setup.b - color.b) * alpha, (setup.a - color.a) * alpha ); break; } return; } let r = 0, g = 0, b = 0, a = 0; const i = Timeline.search( frames, time, 5 /*ENTRIES*/ ); const curveType = this.curves[ i / 5 /*ENTRIES*/ ]; switch (curveType) { case 0: { const before = frames[i]; r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; a = frames[ i + 4 /*A*/ ]; const t = (time - before) / (frames[ i + 5 /*ENTRIES*/ ] - before); r += (frames[ i + 5 + 1 /*R*/ ] - r) * t; g += (frames[ i + 5 + 2 /*G*/ ] - g) * t; b += (frames[ i + 5 + 3 /*B*/ ] - b) * t; a += (frames[ i + 5 + 4 /*A*/ ] - a) * t; break; } case 1: r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; a = frames[ i + 4 /*A*/ ]; break; default: r = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); g = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); b = this.getBezierValue( time, i, 3, curveType + 18 * 2 - 2 /*BEZIER*/ ); a = this.getBezierValue( time, i, 4, curveType + 18 * 3 - 2 /*BEZIER*/ ); } if (alpha === 1) color.set(r, g, b, a); else { if (from === 1 /* setup */) { const setup = slot.data.setupPose.color; color.set( setup.r + (r - setup.r) * alpha, setup.g + (g - setup.g) * alpha, setup.b + (b - setup.b) * alpha, setup.a + (a - setup.a) * alpha ); } else color.add((r - color.r) * alpha, (g - color.g) * alpha, (b - color.b) * alpha, (a - color.a) * alpha); } } }; var RGBTimeline = class extends SlotCurveTimeline { constructor(frameCount, bezierCount, slotIndex) { super(frameCount, bezierCount, slotIndex, `${8 /* rgb */}|${slotIndex}`); } getFrameEntries() { return 4; } /** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */ setFrame(frame, time, r, g, b) { frame <<= 2; this.frames[frame] = time; this.frames[ frame + 1 /*R*/ ] = r; this.frames[ frame + 2 /*G*/ ] = g; this.frames[ frame + 3 /*B*/ ] = b; } apply1(slot, pose, time, alpha, from, add) { const color = pose.color; let r = 0, g = 0, b = 0; const frames = this.frames; if (time < frames[0]) { const setup = slot.data.setupPose.color; switch (from) { case 1 /* setup */: { color.r = setup.r; color.g = setup.g; color.b = setup.b; break; } case 2 /* first */: { color.r += (setup.r - color.r) * alpha; color.g += (setup.g - color.g) * alpha; color.b += (setup.b - color.b) * alpha; break; } } return; } const i = Timeline.search( frames, time, 4 /*ENTRIES*/ ); const curveType = this.curves[i >> 2]; switch (curveType) { case 0: { const before = frames[i]; r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; const t = (time - before) / (frames[ i + 4 /*ENTRIES*/ ] - before); r += (frames[ i + 4 + 1 /*R*/ ] - r) * t; g += (frames[ i + 4 + 2 /*G*/ ] - g) * t; b += (frames[ i + 4 + 3 /*B*/ ] - b) * t; break; } case 1: r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; break; default: r = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); g = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); b = this.getBezierValue( time, i, 3, curveType + 18 * 2 - 2 /*BEZIER*/ ); } if (alpha !== 1) { if (from === 1 /* setup */) { const setup = slot.data.setupPose.color; r = setup.r + (r - setup.r) * alpha; g = setup.g + (g - setup.g) * alpha; b = setup.b + (b - setup.b) * alpha; } else { r = color.r + (r - color.r) * alpha; g = color.g + (g - color.g) * alpha; b = color.b + (b - color.b) * alpha; } } color.r = r < 0 ? 0 : r > 1 ? 1 : r; color.g = g < 0 ? 0 : g > 1 ? 1 : g; color.b = b < 0 ? 0 : b > 1 ? 1 : b; } }; var AlphaTimeline = class extends CurveTimeline1 { slotIndex = 0; constructor(frameCount, bezierCount, slotIndex) { super(frameCount, bezierCount, `${9 /* alpha */}|${slotIndex}`); this.slotIndex = slotIndex; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const slot = skeleton.slots[this.slotIndex]; if (!slot.bone.active) return; const color = (appliedPose ? slot.appliedPose : slot.pose).color; let a = 0; const frames = this.frames; if (time < frames[0]) { const setup = slot.data.setupPose.color.a; switch (from) { case 1 /* setup */: color.a = setup; break; case 2 /* first */: color.a += (setup - color.a) * alpha; break; } return; } a = this.getCurveValue(time); if (alpha !== 1) { if (from === 1 /* setup */) { const setup = slot.data.setupPose.color; a = setup.a + (a - setup.a) * alpha; } else a = color.a + (a - color.a) * alpha; } color.a = a < 0 ? 0 : a > 1 ? 1 : a; } }; var RGBA2Timeline = class extends SlotCurveTimeline { constructor(frameCount, bezierCount, slotIndex) { super( frameCount, bezierCount, slotIndex, // `${8 /* rgb */}|${slotIndex}`, // `${9 /* alpha */}|${slotIndex}`, // `${10 /* rgb2 */}|${slotIndex}` ); } getFrameEntries() { return 8; } /** Sets the time in seconds, light, and dark colors for the specified key frame. */ setFrame(frame, time, r, g, b, a, r2, g2, b2) { frame <<= 3; this.frames[frame] = time; this.frames[ frame + 1 /*R*/ ] = r; this.frames[ frame + 2 /*G*/ ] = g; this.frames[ frame + 3 /*B*/ ] = b; this.frames[ frame + 4 /*A*/ ] = a; this.frames[ frame + 5 /*R2*/ ] = r2; this.frames[ frame + 6 /*G2*/ ] = g2; this.frames[ frame + 7 /*B2*/ ] = b2; } apply1(slot, pose, time, alpha, from, add) { const light = pose.color, dark = pose.darkColor; let r2 = 0, g2 = 0, b2 = 0; const frames = this.frames; if (time < frames[0]) { const setup = slot.data.setupPose; const setupLight = setup.color, setupDark = setup.darkColor; switch (from) { case 1 /* setup */: { light.setFromColor(setupLight); dark.r = setupDark.r; dark.g = setupDark.g; dark.b = setupDark.b; break; } case 2 /* first */: { light.add( (setupLight.r - light.r) * alpha, (setupLight.g - light.g) * alpha, (setupLight.b - light.b) * alpha, (setupLight.a - light.a) * alpha ); dark.r += (setupDark.r - dark.r) * alpha; dark.g += (setupDark.g - dark.g) * alpha; dark.b += (setupDark.b - dark.b) * alpha; break; } } return; } let r = 0, g = 0, b = 0, a = 0; const i = Timeline.search( frames, time, 8 /*ENTRIES*/ ); const curveType = this.curves[i >> 3]; switch (curveType) { case 0: { const before = frames[i]; r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; a = frames[ i + 4 /*A*/ ]; r2 = frames[ i + 5 /*R2*/ ]; g2 = frames[ i + 6 /*G2*/ ]; b2 = frames[ i + 7 /*B2*/ ]; const t = (time - before) / (frames[ i + 8 /*ENTRIES*/ ] - before); r += (frames[ i + 8 + 1 /*R*/ ] - r) * t; g += (frames[ i + 8 + 2 /*G*/ ] - g) * t; b += (frames[ i + 8 + 3 /*B*/ ] - b) * t; a += (frames[ i + 8 + 4 /*A*/ ] - a) * t; r2 += (frames[ i + 8 + 5 /*R2*/ ] - r2) * t; g2 += (frames[ i + 8 + 6 /*G2*/ ] - g2) * t; b2 += (frames[ i + 8 + 7 /*B2*/ ] - b2) * t; break; } case 1: r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; a = frames[ i + 4 /*A*/ ]; r2 = frames[ i + 5 /*R2*/ ]; g2 = frames[ i + 6 /*G2*/ ]; b2 = frames[ i + 7 /*B2*/ ]; break; default: r = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); g = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); b = this.getBezierValue( time, i, 3, curveType + 18 * 2 - 2 /*BEZIER*/ ); a = this.getBezierValue( time, i, 4, curveType + 18 * 3 - 2 /*BEZIER*/ ); r2 = this.getBezierValue( time, i, 5, curveType + 18 * 4 - 2 /*BEZIER*/ ); g2 = this.getBezierValue( time, i, 6, curveType + 18 * 5 - 2 /*BEZIER*/ ); b2 = this.getBezierValue( time, i, 7, curveType + 18 * 6 - 2 /*BEZIER*/ ); } if (alpha === 1) light.set(r, g, b, a); else if (from === 1 /* setup */) { const setupPose = slot.data.setupPose; let setup = setupPose.color; light.set( setup.r + (r - setup.r) * alpha, setup.g + (g - setup.g) * alpha, setup.b + (b - setup.b) * alpha, setup.a + (a - setup.a) * alpha ); setup = setupPose.darkColor; r2 = setup.r + (r2 - setup.r) * alpha; g2 = setup.g + (g2 - setup.g) * alpha; b2 = setup.b + (b2 - setup.b) * alpha; } else { light.add((r - light.r) * alpha, (g - light.g) * alpha, (b - light.b) * alpha, (a - light.a) * alpha); r2 = dark.r + (r2 - dark.r) * alpha; g2 = dark.g + (g2 - dark.g) * alpha; b2 = dark.b + (b2 - dark.b) * alpha; } dark.r = r2 < 0 ? 0 : r2 > 1 ? 1 : r2; dark.g = g2 < 0 ? 0 : g2 > 1 ? 1 : g2; dark.b = b2 < 0 ? 0 : b2 > 1 ? 1 : b2; } }; var RGB2Timeline = class extends SlotCurveTimeline { constructor(frameCount, bezierCount, slotIndex) { super( frameCount, bezierCount, slotIndex, // `${8 /* rgb */}|${slotIndex}`, // `${10 /* rgb2 */}|${slotIndex}` ); } getFrameEntries() { return 7; } /** Sets the time in seconds, light, and dark colors for the specified key frame. */ setFrame(frame, time, r, g, b, r2, g2, b2) { frame *= 7; this.frames[frame] = time; this.frames[ frame + 1 /*R*/ ] = r; this.frames[ frame + 2 /*G*/ ] = g; this.frames[ frame + 3 /*B*/ ] = b; this.frames[ frame + 4 /*R2*/ ] = r2; this.frames[ frame + 5 /*G2*/ ] = g2; this.frames[ frame + 6 /*B2*/ ] = b2; } apply1(slot, pose, time, alpha, from, add) { const light = pose.color, dark = pose.darkColor; let r = 0, g = 0, b = 0, r2 = 0, g2 = 0, b2 = 0; const frames = this.frames; if (time < frames[0]) { const setup = slot.data.setupPose; const setupLight = setup.color, setupDark = setup.darkColor; switch (from) { case 1 /* setup */: light.r = setupLight.r; light.g = setupLight.g; light.b = setupLight.b; dark.r = setupDark.r; dark.g = setupDark.g; dark.b = setupDark.b; break; case 2 /* first */: light.r += (setupLight.r - light.r) * alpha; light.g += (setupLight.g - light.g) * alpha; light.b += (setupLight.b - light.b) * alpha; dark.r += (setupDark.r - dark.r) * alpha; dark.g += (setupDark.g - dark.g) * alpha; dark.b += (setupDark.b - dark.b) * alpha; break; } return; } const i = Timeline.search( frames, time, 7 /*ENTRIES*/ ); const curveType = this.curves[ i / 7 /*ENTRIES*/ ]; switch (curveType) { case 0: { const before = frames[i]; r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; r2 = frames[ i + 4 /*R2*/ ]; g2 = frames[ i + 5 /*G2*/ ]; b2 = frames[ i + 6 /*B2*/ ]; const t = (time - before) / (frames[ i + 7 /*ENTRIES*/ ] - before); r += (frames[ i + 7 + 1 /*R*/ ] - r) * t; g += (frames[ i + 7 + 2 /*G*/ ] - g) * t; b += (frames[ i + 7 + 3 /*B*/ ] - b) * t; r2 += (frames[ i + 7 + 4 /*R2*/ ] - r2) * t; g2 += (frames[ i + 7 + 5 /*G2*/ ] - g2) * t; b2 += (frames[ i + 7 + 6 /*B2*/ ] - b2) * t; break; } case 1: r = frames[ i + 1 /*R*/ ]; g = frames[ i + 2 /*G*/ ]; b = frames[ i + 3 /*B*/ ]; r2 = frames[ i + 4 /*R2*/ ]; g2 = frames[ i + 5 /*G2*/ ]; b2 = frames[ i + 6 /*B2*/ ]; break; default: r = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); g = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); b = this.getBezierValue( time, i, 3, curveType + 18 * 2 - 2 /*BEZIER*/ ); r2 = this.getBezierValue( time, i, 4, curveType + 18 * 3 - 2 /*BEZIER*/ ); g2 = this.getBezierValue( time, i, 5, curveType + 18 * 4 - 2 /*BEZIER*/ ); b2 = this.getBezierValue( time, i, 6, curveType + 18 * 5 - 2 /*BEZIER*/ ); } if (alpha !== 1) { if (from === 1 /* setup */) { const setupPose = slot.data.setupPose; let setup = setupPose.color; r = setup.r + (r - setup.r) * alpha; g = setup.g + (g - setup.g) * alpha; b = setup.b + (b - setup.b) * alpha; setup = setupPose.darkColor; r2 = setup.r + (r2 - setup.r) * alpha; g2 = setup.g + (g2 - setup.g) * alpha; b2 = setup.b + (b2 - setup.b) * alpha; } else { r = light.r + (r - light.r) * alpha; g = light.g + (g - light.g) * alpha; b = light.b + (b - light.b) * alpha; r2 = dark.r + (r2 - dark.r) * alpha; g2 = dark.g + (g2 - dark.g) * alpha; b2 = dark.b + (b2 - dark.b) * alpha; } } light.r = r < 0 ? 0 : r > 1 ? 1 : r; light.g = g < 0 ? 0 : g > 1 ? 1 : g; light.b = b < 0 ? 0 : b > 1 ? 1 : b; dark.r = r2 < 0 ? 0 : r2 > 1 ? 1 : r2; dark.g = g2 < 0 ? 0 : g2 > 1 ? 1 : g2; dark.b = b2 < 0 ? 0 : b2 > 1 ? 1 : b2; } }; var AttachmentTimeline = class extends Timeline { slotIndex = 0; /** The attachment name for each key frame. May contain null values to clear the attachment. */ attachmentNames; constructor(frameCount, slotIndex) { super(frameCount, `${11 /* attachment */}|${slotIndex}`); this.slotIndex = slotIndex; this.attachmentNames = new Array(frameCount); this.instant = true; } getFrameCount() { return this.frames.length; } /** Sets the time in seconds and the attachment name for the specified key frame. */ setFrame(frame, time, attachmentName) { this.frames[frame] = time; this.attachmentNames[frame] = attachmentName; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const slot = skeleton.slots[this.slotIndex]; if (!slot.bone.active) return; const pose = appliedPose ? slot.appliedPose : slot.pose; if (out || time < this.frames[0]) { if (from !== 0 /* current */) this.setAttachment(skeleton, pose, slot.data.attachmentName); } else this.setAttachment(skeleton, pose, this.attachmentNames[Timeline.search(this.frames, time)]); } setAttachment(skeleton, pose, attachmentName) { pose.setAttachment(!attachmentName ? null : skeleton.getAttachment(this.slotIndex, attachmentName)); } }; var DeformTimeline = class extends CurveTimeline { slotIndex; /** The attachment that will be deformed. * * See {@link VertexAttachment.getTimelineAttachment}. */ attachment; /** The vertices for each key frame. */ vertices; constructor(frameCount, bezierCount, slotIndex, attachment) { super(frameCount, bezierCount, `${12 /* deform */}|${slotIndex}|${attachment.id}`); this.slotIndex = slotIndex; this.attachment = attachment; this.vertices = new Array(frameCount); this.additive = true; } getFrameCount() { return this.frames.length; } /** Sets the time and vertices for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. * @param vertices Vertex positions for an unweighted VertexAttachment, or deform offsets if it has weights. */ setFrame(frame, time, vertices) { this.frames[frame] = time; this.vertices[frame] = vertices; } /** @param value1 Ignored (0 is used for a deform timeline). * @param value2 Ignored (1 is used for a deform timeline). */ setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2) { const curves = this.curves; let i = this.getFrameCount() + bezier * 18; if (value === 0) curves[frame] = 2 + i; const tmpx = (time1 - cx1 * 2 + cx2) * 0.03, tmpy = cy2 * 0.03 - cy1 * 0.06; const dddx = ((cx1 - cx2) * 3 - time1 + time2) * 6e-3, dddy = (cy1 - cy2 + 0.33333333) * 0.018; let ddx = tmpx * 2 + dddx, ddy = tmpy * 2 + dddy; let dx = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy = cy1 * 0.3 + tmpy + dddy * 0.16666667; let x = time1 + dx, y = dy; for (let n = i + 18; i < n; i += 2) { curves[i] = x; curves[i + 1] = y; dx += ddx; dy += ddy; ddx += dddx; ddy += dddy; x += dx; y += dy; } } getCurvePercent(time, frame) { const curves = this.curves; let i = curves[frame]; switch (i) { case 0: { const x2 = this.frames[frame]; return (time - x2) / (this.frames[frame + this.getFrameEntries()] - x2); } case 1: return 0; } i -= 2; if (curves[i] > time) { const x2 = this.frames[frame]; return curves[i + 1] * (time - x2) / (curves[i] - x2); } const n = i + 18; for (i += 2; i < n; i += 2) { if (curves[i] >= time) { const x2 = curves[i - 2], y2 = curves[i - 1]; return y2 + (time - x2) / (curves[i] - x2) * (curves[i + 1] - y2); } } const x = curves[n - 2], y = curves[n - 1]; return y + (1 - y) * (time - x) / (this.frames[frame + this.getFrameEntries()] - x); } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const slots = skeleton.slots; if (!this.attachment.isTimelineActive(slots, this.slotIndex, appliedPose)) return; const timelineSlots = this.attachment.timelineSlots; const frames = this.frames; if (time < frames[0]) { this.applyBeforeFirst(slots[this.slotIndex], appliedPose, alpha, from); for (const slotIndex of timelineSlots) this.applyBeforeFirst(slots[slotIndex], appliedPose, alpha, from); return; } let v1, v2; let percent; if (time >= frames[frames.length - 1]) { percent = 0; v1 = this.vertices[frames.length - 1]; v2 = null; } else { const frame = Timeline.search(frames, time); percent = this.getCurvePercent(time, frame); v1 = this.vertices[frame]; v2 = this.vertices[frame + 1]; } const vertexCount = this.vertices[0].length; this.applyToSlot(slots[this.slotIndex], appliedPose, v1, v2, percent, vertexCount, alpha, from, add); for (const slotIndex of timelineSlots) this.applyToSlot(slots[slotIndex], appliedPose, v1, v2, percent, vertexCount, alpha, from, add); } applyBeforeFirst(slot, appliedPose, alpha, from) { if (!slot.bone.active) return; const pose = appliedPose ? slot.appliedPose : slot.pose; if (pose.attachment == null || pose.attachment.timelineAttachment !== this.attachment) return; const deformArray = pose.deform; if (deformArray.length === 0) from = 1 /* setup */; switch (from) { case 1 /* setup */: deformArray.length = 0; break; case 2 /* first */: { if (alpha === 1) { deformArray.length = 0; return; } const vertexCount = this.vertices[0].length; deformArray.length = vertexCount; const deform = deformArray; const vertexAttachment = pose.attachment; if (vertexAttachment.bones === null) { const setupVertices = vertexAttachment.vertices; for (let i = 0; i < vertexCount; i++) deform[i] += (setupVertices[i] - deform[i]) * alpha; } else { alpha = 1 - alpha; for (let i = 0; i < vertexCount; i++) deform[i] *= alpha; } } } } applyToSlot(slot, appliedPose, v1, v2, percent, vertexCount, alpha, from, add) { if (!slot.bone.active) return; const pose = appliedPose ? slot.appliedPose : slot.pose; if (pose.attachment === null || pose.attachment.timelineAttachment !== this.attachment) return; const vertexAttachment = pose.attachment; const deform = pose.deform; if (deform.length === 0) from = 1 /* setup */; const fromSetup = from === 1 /* setup */; deform.length = vertexCount; if (v2 === null) { if (alpha === 1) { if (add && !fromSetup) { if (!vertexAttachment.bones) { const setupVertices = vertexAttachment.vertices; for (let i = 0; i < vertexCount; i++) deform[i] += v1[i] - setupVertices[i]; } else { for (let i = 0; i < vertexCount; i++) deform[i] += v1[i]; } } else Utils.arrayCopy(v1, 0, deform, 0, vertexCount); } else if (fromSetup) { if (!vertexAttachment.bones) { const setupVertices = vertexAttachment.vertices; for (let i = 0; i < vertexCount; i++) { const setup = setupVertices[i]; deform[i] = setup + (v1[i] - setup) * alpha; } } else { for (let i = 0; i < vertexCount; i++) deform[i] = v1[i] * alpha; } } else if (add) { if (!vertexAttachment.bones) { const setupVertices = vertexAttachment.vertices; for (let i = 0; i < vertexCount; i++) deform[i] += (v1[i] - setupVertices[i]) * alpha; } else { for (let i = 0; i < vertexCount; i++) deform[i] += v1[i] * alpha; } } else { for (let i = 0; i < vertexCount; i++) deform[i] += (v1[i] - deform[i]) * alpha; } } else { if (alpha === 1) { if (add && !fromSetup) { if (!vertexAttachment.bones) { const setupVertices = vertexAttachment.vertices; for (let i = 0; i < vertexCount; i++) { const prev = v1[i]; deform[i] += prev + (v2[i] - prev) * percent - setupVertices[i]; } } else { for (let i = 0; i < vertexCount; i++) { const prev = v1[i]; deform[i] += prev + (v2[i] - prev) * percent; } } } else if (percent === 0) Utils.arrayCopy(v1, 0, deform, 0, vertexCount); else { for (let i = 0; i < vertexCount; i++) { const prev = v1[i]; deform[i] = prev + (v2[i] - prev) * percent; } } } else if (fromSetup) { if (!vertexAttachment.bones) { const setupVertices = vertexAttachment.vertices; for (let i = 0; i < vertexCount; i++) { const prev = v1[i], setup = setupVertices[i]; deform[i] = setup + (prev + (v2[i] - prev) * percent - setup) * alpha; } } else { for (let i = 0; i < vertexCount; i++) { const prev = v1[i]; deform[i] = (prev + (v2[i] - prev) * percent) * alpha; } } } else if (add) { if (!vertexAttachment.bones) { const setupVertices = vertexAttachment.vertices; for (let i = 0; i < vertexCount; i++) { const prev = v1[i]; deform[i] += (prev + (v2[i] - prev) * percent - setupVertices[i]) * alpha; } } else { for (let i = 0; i < vertexCount; i++) { const prev = v1[i]; deform[i] += (prev + (v2[i] - prev) * percent) * alpha; } } } else { for (let i = 0; i < vertexCount; i++) { const prev = v1[i]; deform[i] += (prev + (v2[i] - prev) * percent - deform[i]) * alpha; } } } } }; var SequenceTimeline = class _SequenceTimeline extends Timeline { static ENTRIES = 3; static MODE = 1; static DELAY = 2; slotIndex; attachment; constructor(frameCount, slotIndex, attachment) { super(frameCount, `${29 /* sequence */}|${slotIndex}|${attachment.sequence.id}`); this.slotIndex = slotIndex; this.attachment = attachment; this.instant = true; } getFrameEntries() { return _SequenceTimeline.ENTRIES; } getSlotIndex() { return this.slotIndex; } /** The attachment for which the {@link SlotPose.sequenceIndex} will be set. * * See {@link VertexAttachment.timelineAttachment}. */ getAttachment() { return this.attachment; } /** Sets the time, mode, index, and frame time for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time Seconds between frames. */ setFrame(frame, time, mode, index, delay) { const frames = this.frames; frame *= _SequenceTimeline.ENTRIES; frames[frame] = time; frames[frame + _SequenceTimeline.MODE] = mode | index << 4; frames[frame + _SequenceTimeline.DELAY] = delay; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const slots = skeleton.slots; if (!this.attachment.isTimelineActive(slots, this.slotIndex, appliedPose)) return; const timelineSlots = this.attachment.timelineSlots; const frames = this.frames; if (out || time < frames[0]) { if (from !== 0 /* current */) { this.setupPose(slots[this.slotIndex], appliedPose); for (const slotIndex of timelineSlots) this.setupPose(slots[slotIndex], appliedPose); } return; } const i = Timeline.search(frames, time, _SequenceTimeline.ENTRIES); const before = frames[i]; const modeAndIndex = frames[i + _SequenceTimeline.MODE]; const delay = frames[i + _SequenceTimeline.DELAY]; this.applyToSlot(slots[this.slotIndex], appliedPose, time, before, modeAndIndex, delay); for (const slotIndex of timelineSlots) this.applyToSlot(slots[slotIndex], appliedPose, time, before, modeAndIndex, delay); } setupPose(slot, appliedPose) { if (!slot.bone.active) return; const pose = appliedPose ? slot.appliedPose : slot.pose; if (pose.attachment === null || pose.attachment.timelineAttachment !== this.attachment) return; pose.sequenceIndex = -1; } applyToSlot(slot, appliedPose, time, before, modeAndIndex, delay) { if (!slot.bone.active) return; const pose = appliedPose ? slot.appliedPose : slot.pose; if (pose.attachment === null || pose.attachment.timelineAttachment !== this.attachment) return; let index = modeAndIndex >> 4, count = pose.attachment.sequence.regions.length; const mode = SequenceModeValues[modeAndIndex & 15]; if (mode !== 0 /* hold */) { index += (time - before) / delay + 1e-5 | 0; switch (mode) { case 1 /* once */: index = Math.min(count - 1, index); break; case 2 /* loop */: index %= count; break; case 3 /* pingpong */: { const n = (count << 1) - 2; index = n === 0 ? 0 : index % n; if (index >= count) index = n - index; break; } case 4 /* onceReverse */: index = Math.max(count - 1 - index, 0); break; case 5 /* loopReverse */: index = count - 1 - index % count; break; case 6 /* pingpongReverse */: { const n = (count << 1) - 2; index = n === 0 ? 0 : (index + count - 1) % n; if (index >= count) index = n - index; } } } pose.sequenceIndex = index; } }; var EventTimeline = class _EventTimeline extends Timeline { static propertyIds = [`${13 /* event */}`]; /** The event for each key frame. */ events; constructor(frameCount) { super(frameCount, ..._EventTimeline.propertyIds); this.events = new Array(frameCount); this.instant = true; } getFrameCount() { return this.frames.length; } /** Sets the time in seconds and the event for the specified key frame. */ setFrame(frame, event) { this.frames[frame] = event.time; this.events[frame] = event; } /** Fires events for frames > `lastTime` and <= `time`. */ apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { if (!firedEvents) return; const frames = this.frames; const frameCount = this.frames.length; if (lastTime > time) { this.apply(null, lastTime, Number.MAX_VALUE, firedEvents, 0, from, false, false, false); lastTime = -1; } else if (lastTime >= frames[frameCount - 1]) return; if (time < frames[0]) return; let i = 0; if (lastTime < frames[0]) i = 0; else { i = Timeline.search(frames, lastTime) + 1; const frameTime = frames[i]; while (i > 0) { if (frames[i - 1] !== frameTime) break; i--; } } for (; i < frameCount && time >= frames[i]; i++) firedEvents.push(this.events[i]); } }; var DrawOrderTimeline = class _DrawOrderTimeline extends Timeline { static propertyID = `${14 /* drawOrder */}`; static propertyIds = [_DrawOrderTimeline.propertyID]; /** The draw order for each key frame. See {@link setFrame}. */ drawOrders; constructor(frameCount) { super(frameCount, ..._DrawOrderTimeline.propertyIds); this.drawOrders = new Array(frameCount); this.instant = true; } getFrameCount() { return this.frames.length; } /** Sets the time in seconds and the draw order for the specified key frame. * @param drawOrder Ordered {@link Skeleton.slots} indices, or null to use setup pose * draw order. */ setFrame(frame, time, drawOrder) { this.frames[frame] = time; this.drawOrders[frame] = drawOrder; } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const pose = appliedPose ? skeleton.drawOrder.appliedPose : skeleton.drawOrder.pose; const setup = skeleton.slots; if (out || time < this.frames[0]) { if (from !== 0 /* current */) Utils.arrayCopy(setup, 0, pose, 0, skeleton.slots.length); return; } const order = this.drawOrders[Timeline.search(this.frames, time)]; if (!order) Utils.arrayCopy(setup, 0, pose, 0, skeleton.slots.length); else { for (let i = 0, n = order.length; i < n; i++) pose[i] = setup[order[i]]; } } }; var DrawOrderFolderTimeline = class _DrawOrderFolderTimeline extends Timeline { static propertyID = `${15 /* drawOrderFolder */}`; slots; inFolder; drawOrders; /** @param slots {@link Skeleton.slots} indices controlled by this timeline, in setup order. * @param slotCount The maximum number of slots in the skeleton. */ constructor(frameCount, slots, slotCount) { super(frameCount, ..._DrawOrderFolderTimeline.propertyIds(slots)); this.slots = slots; this.drawOrders = new Array(frameCount); this.inFolder = new Array(slotCount); for (const i of slots) this.inFolder[i] = true; this.instant = true; } static propertyIds(slots) { const n = slots.length; const ids = new Array(n); for (let i = 0; i < n; i++) ids[i] = `${_DrawOrderFolderTimeline.propertyID}|${slots[i]}`; return ids; } getFrameCount() { return this.frames.length; } /** The {@link Skeleton.getSlots} indices that this timeline affects, in setup order. */ getSlots() { return this.slots; } /** The draw order for each frame. See {@link setFrame}. */ getDrawOrders() { return this.drawOrders; } /** Sets the time and draw order for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. * @param drawOrder Ordered {@link getSlots} indices, or null to use setup pose order. */ setFrame(frame, time, drawOrder) { this.frames[frame] = time; this.drawOrders[frame] = drawOrder; } apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) { const pose = appliedPose ? skeleton.drawOrder.appliedPose : skeleton.drawOrder.pose; const setup = skeleton.slots; if (out || time < this.frames[0]) { if (from !== 0 /* current */) this.setup(pose, setup); } else { const order = this.drawOrders[Timeline.search(this.frames, time)]; if (!order) this.setup(pose, setup); else { const inFolder = this.inFolder; const slots = this.slots; for (let i = 0, found = 0, done = slots.length; ; i++) { if (inFolder[pose[i].data.index]) { pose[i] = setup[slots[order[found]]]; if (++found === done) break; } } } } } setup(pose, setup) { const { inFolder, slots } = this; for (let i = 0, found = 0, done = slots.length; ; i++) { if (inFolder[pose[i].data.index]) { pose[i] = setup[slots[found]]; if (++found === done) break; } } } }; function isConstraintTimeline(obj) { return typeof obj === "object" && obj !== null && typeof obj.constraintIndex === "number"; } var IkConstraintTimeline = class extends CurveTimeline { constraintIndex = 0; constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, `${16 /* ikConstraint */}|${constraintIndex}`); this.constraintIndex = constraintIndex; } getFrameEntries() { return 6; } /** Sets the time, mix, softness, bend direction, compress, and stretch for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. * @param bendDirection 1 or -1. */ setFrame(frame, time, mix, softness, bendDirection, compress, stretch) { frame *= 6; this.frames[frame] = time; this.frames[ frame + 1 /*MIX*/ ] = mix; this.frames[ frame + 2 /*SOFTNESS*/ ] = softness; this.frames[ frame + 3 /*BEND_DIRECTION*/ ] = bendDirection; this.frames[ frame + 4 /*COMPRESS*/ ] = compress ? 1 : 0; this.frames[ frame + 5 /*STRETCH*/ ] = stretch ? 1 : 0; } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const constraint = skeleton.constraints[this.constraintIndex]; if (!constraint.active) return; const pose = appliedPose ? constraint.appliedPose : constraint.pose; const frames = this.frames; if (time < frames[0]) { const setup = constraint.data.setupPose; switch (from) { case 1 /* setup */: { pose.mix = setup.mix; pose.softness = setup.softness; pose.bendDirection = setup.bendDirection; pose.compress = setup.compress; pose.stretch = setup.stretch; break; } case 2 /* first */: { pose.mix += (setup.mix - pose.mix) * alpha; pose.softness += (setup.softness - pose.softness) * alpha; pose.bendDirection = setup.bendDirection; pose.compress = setup.compress; pose.stretch = setup.stretch; break; } } return; } let mix = 0, softness = 0; const i = Timeline.search( frames, time, 6 /*ENTRIES*/ ); const curveType = this.curves[ i / 6 /*ENTRIES*/ ]; switch (curveType) { case 0: { const before = frames[i]; mix = frames[ i + 1 /*MIX*/ ]; softness = frames[ i + 2 /*SOFTNESS*/ ]; const t = (time - before) / (frames[ i + 6 /*ENTRIES*/ ] - before); mix += (frames[ i + 6 + 1 /*MIX*/ ] - mix) * t; softness += (frames[ i + 6 + 2 /*SOFTNESS*/ ] - softness) * t; break; } case 1: mix = frames[ i + 1 /*MIX*/ ]; softness = frames[ i + 2 /*SOFTNESS*/ ]; break; default: mix = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); softness = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); } const base = from === 1 /* setup */ ? constraint.data.setupPose : pose; pose.mix = base.mix + (mix - base.mix) * alpha; pose.softness = base.softness + (softness - base.softness) * alpha; if (out) { if (from === 1 /* setup */) { pose.bendDirection = base.bendDirection; pose.compress = base.compress; pose.stretch = base.stretch; } } else { pose.bendDirection = frames[ i + 3 /*BEND_DIRECTION*/ ]; pose.compress = frames[ i + 4 /*COMPRESS*/ ] !== 0; pose.stretch = frames[ i + 5 /*STRETCH*/ ] !== 0; } } }; var TransformConstraintTimeline = class extends CurveTimeline { /** The index of the transform constraint slot in {@link Skeleton.transformConstraints} that will be changed. */ constraintIndex = 0; constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, `${17 /* transformConstraint */}|${constraintIndex}`); this.constraintIndex = constraintIndex; this.additive = true; } getFrameEntries() { return 7; } /** Sets the time, rotate mix, translate mix, scale mix, and shear mix for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. */ setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY) { const frames = this.frames; frame *= 7; frames[frame] = time; frames[ frame + 1 /*ROTATE*/ ] = mixRotate; frames[ frame + 2 /*X*/ ] = mixX; frames[ frame + 3 /*Y*/ ] = mixY; frames[ frame + 4 /*SCALEX*/ ] = mixScaleX; frames[ frame + 5 /*SCALEY*/ ] = mixScaleY; frames[ frame + 6 /*SHEARY*/ ] = mixShearY; } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const constraint = skeleton.constraints[this.constraintIndex]; if (!constraint.active) return; const pose = appliedPose ? constraint.appliedPose : constraint.pose; const frames = this.frames; if (time < frames[0]) { const setup = constraint.data.setupPose; switch (from) { case 1 /* setup */: { pose.mixRotate = setup.mixRotate; pose.mixX = setup.mixX; pose.mixY = setup.mixY; pose.mixScaleX = setup.mixScaleX; pose.mixScaleY = setup.mixScaleY; pose.mixShearY = setup.mixShearY; break; } case 2 /* first */: { pose.mixRotate += (setup.mixRotate - pose.mixRotate) * alpha; pose.mixX += (setup.mixX - pose.mixX) * alpha; pose.mixY += (setup.mixY - pose.mixY) * alpha; pose.mixScaleX += (setup.mixScaleX - pose.mixScaleX) * alpha; pose.mixScaleY += (setup.mixScaleY - pose.mixScaleY) * alpha; pose.mixShearY += (setup.mixShearY - pose.mixShearY) * alpha; break; } } return; } let rotate, x, y, scaleX, scaleY, shearY; const i = Timeline.search( frames, time, 7 /*ENTRIES*/ ); const curveType = this.curves[ i / 7 /*ENTRIES*/ ]; switch (curveType) { case 0: { const before = frames[i]; rotate = frames[ i + 1 /*ROTATE*/ ]; x = frames[ i + 2 /*X*/ ]; y = frames[ i + 3 /*Y*/ ]; scaleX = frames[ i + 4 /*SCALEX*/ ]; scaleY = frames[ i + 5 /*SCALEY*/ ]; shearY = frames[ i + 6 /*SHEARY*/ ]; const t = (time - before) / (frames[ i + 7 /*ENTRIES*/ ] - before); rotate += (frames[ i + 7 + 1 /*ROTATE*/ ] - rotate) * t; x += (frames[ i + 7 + 2 /*X*/ ] - x) * t; y += (frames[ i + 7 + 3 /*Y*/ ] - y) * t; scaleX += (frames[ i + 7 + 4 /*SCALEX*/ ] - scaleX) * t; scaleY += (frames[ i + 7 + 5 /*SCALEY*/ ] - scaleY) * t; shearY += (frames[ i + 7 + 6 /*SHEARY*/ ] - shearY) * t; break; } case 1: rotate = frames[ i + 1 /*ROTATE*/ ]; x = frames[ i + 2 /*X*/ ]; y = frames[ i + 3 /*Y*/ ]; scaleX = frames[ i + 4 /*SCALEX*/ ]; scaleY = frames[ i + 5 /*SCALEY*/ ]; shearY = frames[ i + 6 /*SHEARY*/ ]; break; default: rotate = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); x = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); y = this.getBezierValue( time, i, 3, curveType + 18 * 2 - 2 /*BEZIER*/ ); scaleX = this.getBezierValue( time, i, 4, curveType + 18 * 3 - 2 /*BEZIER*/ ); scaleY = this.getBezierValue( time, i, 5, curveType + 18 * 4 - 2 /*BEZIER*/ ); shearY = this.getBezierValue( time, i, 6, curveType + 18 * 5 - 2 /*BEZIER*/ ); } const base = from === 1 /* setup */ ? constraint.data.setupPose : pose; if (add) { pose.mixRotate = base.mixRotate + rotate * alpha; pose.mixX = base.mixX + x * alpha; pose.mixY = base.mixY + y * alpha; pose.mixScaleX = base.mixScaleX + scaleX * alpha; pose.mixScaleY = base.mixScaleY + scaleY * alpha; pose.mixShearY = base.mixShearY + shearY * alpha; } else { pose.mixRotate = base.mixRotate + (rotate - base.mixRotate) * alpha; pose.mixX = base.mixX + (x - base.mixX) * alpha; pose.mixY = base.mixY + (y - base.mixY) * alpha; pose.mixScaleX = base.mixScaleX + (scaleX - base.mixScaleX) * alpha; pose.mixScaleY = base.mixScaleY + (scaleY - base.mixScaleY) * alpha; pose.mixShearY = base.mixShearY + (shearY - base.mixShearY) * alpha; } } }; var ConstraintTimeline1 = class extends CurveTimeline1 { constraintIndex; constructor(frameCount, bezierCount, constraintIndex, property) { super(frameCount, bezierCount, `${property}|${constraintIndex}`); this.constraintIndex = constraintIndex; } }; var PathConstraintPositionTimeline = class extends ConstraintTimeline1 { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 18 /* pathConstraintPosition */); this.additive = true; } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const constraint = skeleton.constraints[this.constraintIndex]; if (constraint.active) { const pose = appliedPose ? constraint.appliedPose : constraint.pose; pose.position = this.getAbsoluteValue(time, alpha, from, add, pose.position, constraint.data.setupPose.position); } } }; var PathConstraintSpacingTimeline = class extends ConstraintTimeline1 { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 19 /* pathConstraintSpacing */); } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const constraint = skeleton.constraints[this.constraintIndex]; if (constraint.active) { const pose = appliedPose ? constraint.appliedPose : constraint.pose; pose.spacing = this.getAbsoluteValue( time, alpha, from, false, pose.spacing, constraint.data.setupPose.spacing ); } } }; var PathConstraintMixTimeline = class extends CurveTimeline { constraintIndex; constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, `${20 /* pathConstraintMix */}|${constraintIndex}`); this.constraintIndex = constraintIndex; } getFrameEntries() { return 4; } /** Sets the time and color for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. * @param time The frame time in seconds. */ setFrame(frame, time, mixRotate, mixX, mixY) { const frames = this.frames; frame <<= 2; frames[frame] = time; frames[ frame + 1 /*ROTATE*/ ] = mixRotate; frames[ frame + 2 /*X*/ ] = mixX; frames[ frame + 3 /*Y*/ ] = mixY; } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const constraint = skeleton.constraints[this.constraintIndex]; if (!constraint.active) return; const pose = appliedPose ? constraint.appliedPose : constraint.pose; const frames = this.frames; if (time < frames[0]) { const setup = constraint.data.setupPose; switch (from) { case 1 /* setup */: { pose.mixRotate = setup.mixRotate; pose.mixX = setup.mixX; pose.mixY = setup.mixY; break; } case 2 /* first */: { pose.mixRotate += (setup.mixRotate - pose.mixRotate) * alpha; pose.mixX += (setup.mixX - pose.mixX) * alpha; pose.mixY += (setup.mixY - pose.mixY) * alpha; break; } } return; } let rotate, x, y; const i = Timeline.search( frames, time, 4 /*ENTRIES*/ ); const curveType = this.curves[i >> 2]; switch (curveType) { case 0: { const before = frames[i]; rotate = frames[ i + 1 /*ROTATE*/ ]; x = frames[ i + 2 /*X*/ ]; y = frames[ i + 3 /*Y*/ ]; const t = (time - before) / (frames[ i + 4 /*ENTRIES*/ ] - before); rotate += (frames[ i + 4 + 1 /*ROTATE*/ ] - rotate) * t; x += (frames[ i + 4 + 2 /*X*/ ] - x) * t; y += (frames[ i + 4 + 3 /*Y*/ ] - y) * t; break; } case 1: rotate = frames[ i + 1 /*ROTATE*/ ]; x = frames[ i + 2 /*X*/ ]; y = frames[ i + 3 /*Y*/ ]; break; default: rotate = this.getBezierValue( time, i, 1, curveType - 2 /*BEZIER*/ ); x = this.getBezierValue( time, i, 2, curveType + 18 - 2 /*BEZIER*/ ); y = this.getBezierValue( time, i, 3, curveType + 18 * 2 - 2 /*BEZIER*/ ); } const base = from === 1 /* setup */ ? constraint.data.setupPose : pose; if (add) { pose.mixRotate = base.mixRotate + rotate * alpha; pose.mixX = base.mixX + x * alpha; pose.mixY = base.mixY + y * alpha; } else { pose.mixRotate = base.mixRotate + (rotate - base.mixRotate) * alpha; pose.mixX = base.mixX + (x - base.mixX) * alpha; pose.mixY = base.mixY + (y - base.mixY) * alpha; } } }; var PhysicsConstraintTimeline = class extends ConstraintTimeline1 { /** @param constraintIndex -1 for all physics constraints in the skeleton. */ constructor(frameCount, bezierCount, constraintIndex, property) { super(frameCount, bezierCount, constraintIndex, property); } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { if (add && !this.additive) add = false; if (this.constraintIndex === -1) { const value = time >= this.frames[0] ? this.getCurveValue(time) : 0; const constraints = skeleton.physics; for (const constraint of constraints) { if (constraint.active && this.global(constraint.data)) { const pose = appliedPose ? constraint.appliedPose : constraint.pose; this.set(pose, this.getAbsoluteValue(time, alpha, from, add, this.get(pose), this.get(constraint.data.setupPose), value)); } } } else { const constraint = skeleton.constraints[this.constraintIndex]; if (constraint.active) { const pose = appliedPose ? constraint.appliedPose : constraint.pose; this.set(pose, this.getAbsoluteValue(time, alpha, from, add, this.get(pose), this.get(constraint.data.setupPose))); } } } }; var PhysicsConstraintInertiaTimeline = class extends PhysicsConstraintTimeline { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 21 /* physicsConstraintInertia */); } get(pose) { return pose.inertia; } set(pose, value) { pose.inertia = value; } global(constraint) { return constraint.inertiaGlobal; } }; var PhysicsConstraintStrengthTimeline = class extends PhysicsConstraintTimeline { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 22 /* physicsConstraintStrength */); } get(pose) { return pose.strength; } set(pose, value) { pose.strength = value; } global(constraint) { return constraint.strengthGlobal; } }; var PhysicsConstraintDampingTimeline = class extends PhysicsConstraintTimeline { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 23 /* physicsConstraintDamping */); } get(pose) { return pose.damping; } set(pose, value) { pose.damping = value; } global(constraint) { return constraint.dampingGlobal; } }; var PhysicsConstraintMassTimeline = class extends PhysicsConstraintTimeline { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 24 /* physicsConstraintMass */); } get(pose) { return 1 / pose.massInverse; } set(pose, value) { pose.massInverse = 1 / value; } global(constraint) { return constraint.massGlobal; } }; var PhysicsConstraintWindTimeline = class extends PhysicsConstraintTimeline { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 25 /* physicsConstraintWind */); this.additive = true; } get(pose) { return pose.wind; } set(pose, value) { pose.wind = value; } global(constraint) { return constraint.windGlobal; } }; var PhysicsConstraintGravityTimeline = class extends PhysicsConstraintTimeline { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 26 /* physicsConstraintGravity */); this.additive = true; } get(pose) { return pose.gravity; } set(pose, value) { pose.gravity = value; } global(constraint) { return constraint.gravityGlobal; } }; var PhysicsConstraintMixTimeline = class extends PhysicsConstraintTimeline { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 27 /* physicsConstraintMix */); } get(pose) { return pose.mix; } set(pose, value) { pose.mix = value; } global(constraint) { return constraint.mixGlobal; } }; var PhysicsConstraintResetTimeline = class _PhysicsConstraintResetTimeline extends Timeline { static propertyIds = [28 /* physicsConstraintReset */.toString()]; /** The index of the physics constraint in {@link Skeleton.contraints} that will be reset when this timeline is * applied, or -1 if all physics constraints in the skeleton will be reset. */ constraintIndex; /** @param constraintIndex -1 for all physics constraints in the skeleton. */ constructor(frameCount, constraintIndex) { super(frameCount, ..._PhysicsConstraintResetTimeline.propertyIds); this.constraintIndex = constraintIndex; this.instant = true; } getFrameCount() { return this.frames.length; } /** Sets the time for the specified frame. * @param frame Between 0 and `frameCount`, inclusive. */ setFrame(frame, time) { this.frames[frame] = time; } /** Resets the physics constraint when frames > `lastTime` and <= `time`. */ apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { let constraint; if (this.constraintIndex !== -1) { constraint = skeleton.constraints[this.constraintIndex]; if (!constraint.active) return; } const frames = this.frames; if (lastTime > time) { this.apply(skeleton, lastTime, Number.MAX_VALUE, [], alpha, from, false, false, false); lastTime = -1; } else if (lastTime >= frames[frames.length - 1]) return; if (time < frames[0]) return; if (lastTime < frames[0] || time >= frames[Timeline.search(frames, lastTime) + 1]) { if (constraint != null) constraint.reset(skeleton); else { for (const constraint2 of skeleton.physics) { if (constraint2.active) constraint2.reset(skeleton); } } } } }; var SliderTimeline = class extends ConstraintTimeline1 { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 30 /* sliderTime */); } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const constraint = skeleton.constraints[this.constraintIndex]; if (constraint.active) { const pose = appliedPose ? constraint.appliedPose : constraint.pose; pose.time = this.getAbsoluteValue(time, alpha, from, add, pose.time, constraint.data.setupPose.time); } } }; var SliderMixTimeline = class extends ConstraintTimeline1 { constructor(frameCount, bezierCount, constraintIndex) { super(frameCount, bezierCount, constraintIndex, 31 /* sliderMix */); this.additive = true; } apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) { const constraint = skeleton.constraints[this.constraintIndex]; if (constraint.active) { const pose = appliedPose ? constraint.appliedPose : constraint.pose; pose.mix = this.getAbsoluteValue(time, alpha, from, add, pose.mix, constraint.data.setupPose.mix); } } }; // spine-core/src/AnimationState.ts var AnimationState = class _AnimationState { static emptyAnimation = new Animation("", [], 0); /** The AnimationStateData to look up mix durations. */ data; /** The list of tracks that have had animations. May contain null entries for tracks that currently have no animation. */ tracks = []; /** Multiplier for the delta time when the animation state is updated, causing time for all animations and mixes to play slower * or faster. Defaults to 1. * * See {@link TrackEntry.timeScale} to affect a single animation. */ timeScale = 1; unkeyedState = 0; events = []; listeners = []; queue = new EventQueue(this); propertyIds = /* @__PURE__ */ new Map(); animationsChanged = false; trackEntryPool = new Pool(() => new TrackEntry()); constructor(data) { this.data = data; } /** Increments each track entry {@link TrackEntry.trackTime}, setting queued animations as current if needed. */ update(delta) { delta *= this.timeScale; const tracks = this.tracks; for (let i = 0, n = tracks.length; i < n; i++) { const current = tracks[i]; if (!current) continue; current.animationLast = current.nextAnimationLast; current.trackLast = current.nextTrackLast; let currentDelta = delta * current.timeScale; if (current.delay > 0) { current.delay -= currentDelta; if (current.delay > 0) continue; currentDelta = -current.delay; current.delay = 0; } let next = current.next; if (next) { const 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.setTrack(i, next, true); while (next.mixingFrom) { next.mixTime += delta; next = next.mixingFrom; } continue; } } else if (current.trackLast >= current.trackEnd && !current.mixingFrom) { tracks[i] = null; this.queue.end(current); this.clearNext(current); continue; } if (current.mixingFrom && this.updateMixingFrom(current, delta)) { let from = current.mixingFrom; current.mixingFrom = null; if (from) from.mixingTo = null; while (from) { this.queue.end(from); from = from.mixingFrom; } } current.trackTime += currentDelta; } this.queue.drain(); } /** Returns true when all mixing from entries are complete. */ updateMixingFrom(to, delta) { const from = to.mixingFrom; if (!from) return true; const finished = this.updateMixingFrom(from, delta); from.animationLast = from.nextAnimationLast; from.trackLast = from.nextTrackLast; if (to.nextTrackLast !== -1 && to.mixTime >= to.mixDuration) { if (from.totalAlpha === 0 || to.mixDuration === 0) { to.mixingFrom = from.mixingFrom; if (from.mixingFrom != null) from.mixingFrom.mixingTo = to; if (from.totalAlpha === 0) { for (let next = to; next.mixingTo != null; next = next.mixingTo) next.keepHold = true; } this.queue.end(from); } return finished; } from.trackTime += delta * from.timeScale; to.mixTime += delta; return false; } /** Poses the skeleton using the track entry animations. The animation state is not changed, so can be applied to multiple * skeletons to pose them identically. * @returns True if any animations were applied. */ apply(skeleton) { if (!skeleton) throw new Error("skeleton cannot be null."); if (this.animationsChanged) this._animationsChanged(); const events = this.events; const tracks = this.tracks; let applied = false; for (let i = 0, n = tracks.length; i < n; i++) { const current = tracks[i]; if (!current || current.delay > 0) continue; applied = true; let alpha = current.alpha; if (current.mixingFrom) alpha *= this.applyMixingFrom(current, skeleton); else if (current.trackTime >= current.trackEnd && !current.next) alpha = 0; let animationLast = current.animationLast, animationTime = current.getAnimationTime(), applyTime = animationTime; let applyEvents = events; if (current.reverse) { applyTime = current.animation.duration - applyTime; applyEvents = null; } const timelines = current.animation.timelines; const timelineCount = timelines.length; if (i === 0 && alpha === 1) { for (let ii = 0; ii < timelineCount; ii++) { Utils.webkit602BugfixHelper(alpha); const timeline = timelines[ii]; if (timeline instanceof AttachmentTimeline) this.applyAttachmentTimeline(timeline, skeleton, applyTime, 1 /* setup */, true); else timeline.apply(skeleton, animationLast, applyTime, applyEvents, alpha, 1 /* setup */, false, false, false); } } else { const timelineMode = current.timelineMode; const retainAttachments = alpha >= current.alphaAttachmentThreshold; const add = current.additive, shortestRotation = add || current.shortestRotation; const firstFrame = !shortestRotation && current.timelinesRotation.length !== timelineCount << 1; if (firstFrame) current.timelinesRotation.length = timelineCount << 1; for (let ii = 0; ii < timelineCount; ii++) { const timeline = timelines[ii]; const from = timelineMode[ii] & MODE; if (!shortestRotation && timeline instanceof RotateTimeline) { this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, from, current.timelinesRotation, ii << 1, firstFrame); } else if (timeline instanceof AttachmentTimeline) { this.applyAttachmentTimeline(timeline, skeleton, applyTime, from, retainAttachments); } else { Utils.webkit602BugfixHelper(alpha); timeline.apply(skeleton, animationLast, applyTime, applyEvents, alpha, from, add, false, false); } } } if (current.reverse) this.eventsReverse(current, animationLast, animationTime); this.queueEvents(current, animationTime); events.length = 0; current.nextAnimationLast = animationTime; current.nextTrackLast = current.trackTime; } const setupState = this.unkeyedState + ATTACH_SETUP; const slots = skeleton.slots; for (let i = 0, n = skeleton.slots.length; i < n; i++) { const slot = slots[i]; if (slot.attachmentState === setupState) { const attachmentName = slot.data.attachmentName; slot.pose.setAttachment(!attachmentName ? null : skeleton.getAttachment(slot.data.index, attachmentName)); } } this.unkeyedState += 2; this.queue.drain(); return applied; } applyMixingFrom(to, skeleton) { const from = to.mixingFrom; const fromMix = from.mixingFrom !== null ? this.applyMixingFrom(from, skeleton) : 1; const mix = to.mix(); const a = from.alpha * fromMix, keep = 1 - mix * to.alpha; const alphaMix = a * (1 - mix), alphaHold = keep > 0 ? alphaMix / keep : a; const timelines = from.animation.timelines; const timelineCount = timelines.length; const timelineMode = from.timelineMode; const timelineHoldMix = from.timelineHoldMix; const retainAttachments = mix < from.mixAttachmentThreshold, drawOrder = mix < from.mixDrawOrderThreshold; const add = from.additive, shortestRotation = add || from.shortestRotation; const firstFrame = !shortestRotation && from.timelinesRotation.length !== timelineCount << 1; if (firstFrame) from.timelinesRotation.length = timelineCount << 1; const timelinesRotation = from.timelinesRotation; let animationLast = from.animationLast, animationTime = from.getAnimationTime(), applyTime = animationTime; let events = null; if (from.reverse) applyTime = from.animation.duration - applyTime; else if (mix < from.eventThreshold) events = this.events; from.totalAlpha = 0; for (let i = 0; i < timelineCount; i++) { const timeline = timelines[i]; const mode = timelineMode[i]; const mixFrom = mode & MODE; let alpha = 0; if ((mode & HOLD) !== 0) { const holdMix = timelineHoldMix[i]; alpha = holdMix == null ? alphaHold : alphaHold * (1 - holdMix.mix()); } else { if (!drawOrder && timeline instanceof DrawOrderTimeline && mixFrom === 0 /* current */) continue; alpha = alphaMix; } from.totalAlpha += alpha; if (!shortestRotation && timeline instanceof RotateTimeline) { this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, mixFrom, timelinesRotation, i << 1, firstFrame); } else if (timeline instanceof AttachmentTimeline) this.applyAttachmentTimeline( timeline, skeleton, applyTime, mixFrom, retainAttachments && alpha >= from.alphaAttachmentThreshold ); else { const out = !drawOrder || !(timeline instanceof DrawOrderTimeline) || mixFrom === 0 /* current */; timeline.apply(skeleton, animationLast, applyTime, events, alpha, mixFrom, add, out, false); } } if (from.reverse && mix < from.eventThreshold) this.eventsReverse(from, animationLast, animationTime); if (to.mixDuration > 0) this.queueEvents(from, animationTime); this.events.length = 0; from.nextAnimationLast = animationTime; from.nextTrackLast = from.trackTime; return mix; } /** Applies the attachment timeline and sets {@link Slot.attachmentState}. * @param retain True if the attachment remains after apply, false if temporary for deform timelines. */ applyAttachmentTimeline(timeline, skeleton, time, from, retain) { const slot = skeleton.slots[timeline.slotIndex]; if (!slot.bone.active) return; if (!retain && slot.attachmentState === this.unkeyedState + ATTACH_RETAIN) return; let setup = time < timeline.frames[0]; let name = null; if (!setup) { name = timeline.attachmentNames[Timeline.search(timeline.frames, time)]; setup = !retain && name == null; } if (setup) { if (from === 0 /* current */) return; name = slot.data.attachmentName; } slot.pose.setAttachment(name == null ? null : skeleton.getAttachment(slot.data.index, name)); if (retain) slot.attachmentState = this.unkeyedState + ATTACH_RETAIN; else if (!setup) slot.attachmentState = this.unkeyedState + ATTACH_SETUP; } /** Applies the rotate timeline, mixing with the current pose while keeping the same rotation direction chosen as the shortest * the first time the mixing was applied. */ applyRotateTimeline(timeline, skeleton, time, alpha, from, timelinesRotation, i, firstFrame) { if (firstFrame) timelinesRotation[i] = 0; if (alpha === 1) { timeline.apply(skeleton, 0, time, null, 1, from, false, false, false); return; } const bone = skeleton.bones[timeline.boneIndex]; if (!bone.active) return; const pose = bone.pose, setup = bone.data.setupPose; const frames = timeline.frames; let r1, r2; if (time < frames[0]) { switch (from) { case 1 /* setup */: { pose.rotation = setup.rotation; return; } case 0 /* current */: { return; } } r1 = pose.rotation; r2 = setup.rotation; } else { r1 = from === 1 /* setup */ ? setup.rotation : pose.rotation; r2 = setup.rotation + timeline.getCurveValue(time); } let total = 0, diff = r2 - r1; diff -= Math.ceil(diff / 360 - 0.5) * 360; if (diff === 0) { total = timelinesRotation[i]; } else { let lastTotal = 0, lastDiff = 0; if (firstFrame) { lastTotal = 0; lastDiff = diff; } else { lastTotal = timelinesRotation[i]; lastDiff = timelinesRotation[i + 1]; } const loops = lastTotal - lastTotal % 360; total = diff + loops; let current = diff >= 0, dir = lastTotal >= 0; if (Math.abs(lastDiff) <= 90 && MathUtils.signum(lastDiff) !== MathUtils.signum(diff)) { if (Math.abs(lastTotal - loops) > 180) { total += 360 * MathUtils.signum(lastTotal); dir = current; } else if (loops !== 0) total -= 360 * MathUtils.signum(lastTotal); else dir = current; } if (dir !== current) total += 360 * MathUtils.signum(lastTotal); timelinesRotation[i] = total; } timelinesRotation[i + 1] = diff; pose.rotation = r1 + total * alpha; } queueEvents(entry, animationTime) { const animationStart = entry.animationStart, animationEnd = entry.animationEnd, duration = animationEnd - animationStart; const reverse = entry.reverse; let split = entry.trackLast % duration; if (reverse) split = duration - split; const events = this.events; let i = 0, n = events.length; for (; i < n; i++) { const event = events[i]; if (event.time < split !== reverse) break; if (event.time >= animationStart && event.time <= animationEnd) this.queue.event(entry, event); } let complete = false; if (entry.loop) { if (duration === 0) complete = true; else { const cycles = Math.floor(entry.trackTime / duration); complete = cycles > 0 && cycles > Math.floor(entry.trackLast / duration); } } else complete = animationTime >= animationEnd && entry.animationLast < animationEnd; if (complete) this.queue.complete(entry); for (; i < n; i++) { const event = events[i]; if (event.time >= animationStart && event.time <= animationEnd) this.queue.event(entry, event); } } eventsReverse(entry, animationLast, animationTime) { const duration = entry.animation.duration, from = duration - animationLast, to = duration - animationTime; const timelines = entry.animation.timelines; for (let i = 0, n = entry.animation.timelines.length; i < n; i++) { const eventTimeline = timelines[i]; if (!(eventTimeline instanceof EventTimeline)) continue; const timelineEvents = eventTimeline.events; const frames = eventTimeline.frames; const frameCount = frames.length; if (from >= to) { for (let ii = 0; ii < frameCount; ii++) { if (frames[ii] < to) continue; if (frames[ii] >= from) break; this.events.push(timelineEvents[ii]); } } else { for (let ii2 = 0; ii2 < frameCount; ii2++) { if (frames[ii2] >= from) break; this.events.push(timelineEvents[ii2]); } let ii = 0; for (; ii < frameCount; ii++) if (frames[ii] >= to) break; for (; ii < frameCount; ii++) this.events.push(timelineEvents[ii]); } } } /** Removes all animations from all tracks, leaving skeletons in their current pose. * * Usually you want to use {@link setEmptyAnimations} to mix the skeletons back to the setup pose, rather than leaving * them in their current pose. */ clearTracks() { const oldDrainDisabled = this.queue.drainDisabled; this.queue.drainDisabled = true; for (let i = 0, n = this.tracks.length; i < n; i++) this.clearTrack(i); this.tracks.length = 0; this.queue.drainDisabled = oldDrainDisabled; this.queue.drain(); } /** Removes all animations from the track, leaving skeletons in their current pose. * * Usually you want to use {@link setEmptyAnimation} to mix the skeletons back to the setup pose, rather than * leaving them in their current pose. */ clearTrack(trackIndex) { if (trackIndex < 0) throw new Error("trackIndex must be >= 0."); if (trackIndex >= this.tracks.length) return; const current = this.tracks[trackIndex]; if (!current) return; this.queue.end(current); this.clearNext(current); let entry = current; while (true) { const from = entry.mixingFrom; if (!from) break; this.queue.end(from); entry.mixingFrom = null; entry.mixingTo = null; entry = from; } this.tracks[current.trackIndex] = null; this.queue.drain(); } setTrack(index, current, interrupt) { const from = this.expandToIndex(index); this.tracks[index] = current; current.previous = null; if (from) { from.next = null; if (interrupt) this.queue.interrupt(from); current.mixingFrom = from; from.mixingTo = current; current.mixTime = 0; from.timelinesRotation.length = 0; } this.queue.start(current); } setAnimation(trackIndex, animationNameOrAnimation, loop = false) { if (typeof animationNameOrAnimation === "string") return this.setAnimation1(trackIndex, animationNameOrAnimation, loop); return this.setAnimation2(trackIndex, animationNameOrAnimation, loop); } setAnimation1(trackIndex, animationName, loop = false) { const animation = this.data.skeletonData.findAnimation(animationName); if (!animation) throw new Error(`Animation not found: ${animationName}`); return this.setAnimation2(trackIndex, animation, loop); } /** Sets the current animation for a track, discarding any queued animations. * * If the formerly current track entry is for the same animation and was never applied to a skeleton, it is replaced (not mixed * from). * @param loop If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its * duration. In either case {@link TrackEntry.getTrackEnd} determines when the track is cleared. * @return A track entry to allow further customization of animation playback. References to the track entry must not be kept * after the {@link AnimationStateListener.dispose} event occurs. */ setAnimation2(trackIndex, animation, loop = false) { if (trackIndex < 0) throw new Error("trackIndex must be >= 0."); if (!animation) throw new Error("animation cannot be null."); let interrupt = true; let current = this.expandToIndex(trackIndex); if (current) { if (current.nextTrackLast === -1 && current.animation === animation) { this.tracks[trackIndex] = current.mixingFrom; this.queue.interrupt(current); this.queue.end(current); this.clearNext(current); current = current.mixingFrom; interrupt = false; } else this.clearNext(current); } const entry = this.trackEntry(trackIndex, animation, loop, current); this.setTrack(trackIndex, entry, interrupt); this.queue.drain(); return entry; } addAnimation(trackIndex, animationNameOrAnimation, loop = false, delay = 0) { if (typeof animationNameOrAnimation === "string") return this.addAnimation1(trackIndex, animationNameOrAnimation, loop, delay); return this.addAnimation2(trackIndex, animationNameOrAnimation, loop, delay); } addAnimation1(trackIndex, animationName, loop = false, delay = 0) { const animation = this.data.skeletonData.findAnimation(animationName); if (!animation) throw new Error(`Animation not found: ${animationName}`); return this.addAnimation2(trackIndex, animation, loop, delay); } addAnimation2(trackIndex, animation, loop = false, delay = 0) { if (trackIndex < 0) throw new Error("trackIndex must be >= 0."); if (!animation) throw new Error("animation cannot be null."); let last = this.expandToIndex(trackIndex); if (last) { while (last.next) last = last.next; } const entry = this.trackEntry(trackIndex, animation, loop, last); if (!last) { this.setTrack(trackIndex, entry, true); this.queue.drain(); if (delay < 0) delay = 0; } else { last.next = entry; entry.previous = last; if (delay <= 0) delay = Math.max(delay + last.getTrackComplete() - entry.mixDuration, 0); } entry.delay = delay; return entry; } /** Sets an empty animation for a track, discarding any queued animations, and sets the track entry's * {@link TrackEntry.mixduration}. An empty animation has no timelines and serves as a placeholder for mixing in or out. * * Mixing out is done by setting an empty animation with a mix duration using either {@link setEmptyAnimation}, * {@link setEmptyAnimations}, or {@link addEmptyAnimation}. Mixing to an empty animation causes * the previous animation to be applied less and less over the mix duration. Properties keyed in the previous animation * transition to the value from lower tracks or to the setup pose value if no lower tracks key the property. A mix duration of * 0 still needs to be applied one more time to mix out, so the properties it was animating are reverted. * * Mixing in is done by first setting an empty animation, then adding an animation using * {@link addAnimation} with the desired delay (an empty animation has a duration of 0) and on * the returned track entry, set the {@link TrackEntry.setMixDuration}. Mixing from an empty animation causes the new * animation to be applied more and more over the mix duration. Properties keyed in the new animation transition from the value * from lower tracks or from the setup pose value if no lower tracks key the property to the value keyed in the new animation. * * See Empty animations in the Spine * Runtimes Guide. */ setEmptyAnimation(trackIndex, mixDuration = 0) { const entry = this.setAnimation(trackIndex, _AnimationState.emptyAnimation, false); entry.mixDuration = mixDuration; entry.trackEnd = mixDuration; return entry; } /** Adds an empty animation to be played after the current or last queued animation for a track, and sets the track entry's * {@link TrackEntry.mixDuration}. If the track has no entries, it is equivalent to calling * {@link setEmptyAnimation}. * * See {@link setEmptyAnimation} and * Empty animations in the Spine Runtimes * Guide. * @param delay If > 0, sets {@link TrackEntry.delay}. If <= 0, the delay set is the duration of the previous track entry minus * any mix duration plus the specified `delay` (ie the mix ends at (when `delay` = 0) or before * (when `delay` < 0) the previous track entry duration). If the previous entry is looping, its next loop * completion is used instead of its duration. * @return A track entry to allow further customization of animation playback. References to the track entry must not be kept * after the {@link AnimationStateListener.dispose} event occurs. */ addEmptyAnimation(trackIndex, mixDuration = 0, delay = 0) { const entry = this.addAnimation(trackIndex, _AnimationState.emptyAnimation, false, delay); if (delay <= 0) entry.delay = Math.max(entry.delay + entry.mixDuration - mixDuration, 0); entry.mixDuration = mixDuration; entry.trackEnd = mixDuration; return entry; } /** Sets an empty animation for every track, discarding any queued animations, and mixes to it over the specified mix duration. * * See Empty animations in the Spine * Runtimes Guide. */ setEmptyAnimations(mixDuration = 0) { const oldDrainDisabled = this.queue.drainDisabled; this.queue.drainDisabled = true; for (let i = 0, n = this.tracks.length; i < n; i++) { const current = this.tracks[i]; if (current) this.setEmptyAnimation(current.trackIndex, mixDuration); } this.queue.drainDisabled = oldDrainDisabled; this.queue.drain(); } expandToIndex(index) { if (index < this.tracks.length) return this.tracks[index]; Utils.ensureArrayCapacity(this.tracks, index + 1, null); this.tracks.length = index + 1; return null; } /** @param last May be null. */ trackEntry(trackIndex, animation, loop, last) { const entry = this.trackEntryPool.obtain(); entry.reset(); entry.trackIndex = trackIndex; entry.animation = animation; entry.loop = loop; entry.additive = false; entry.reverse = false; entry.shortestRotation = false; entry.eventThreshold = 0; entry.alphaAttachmentThreshold = 0; entry.mixAttachmentThreshold = 0; entry.mixDrawOrderThreshold = 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.mixTime = 0; entry.mixDuration = !last ? 0 : this.data.getMix(last.animation, animation); entry.totalAlpha = 0; entry.keepHold = false; return entry; } /** Removes {@link TrackEntry.next} and all entries after it for the specified entry. */ clearNext(entry) { let next = entry.next; while (next) { this.queue.dispose(next); next = next.next; } entry.next = null; } _animationsChanged() { this.animationsChanged = false; const tracks = this.tracks; for (let i = 0, n = tracks.length; i < n; i++) { const track = tracks[i]; if (!track) continue; let entry = track; while (entry.mixingFrom) entry = entry.mixingFrom; do { this.computeHold(entry, track); entry = entry.mixingTo; } while (entry); } this.propertyIds.clear(); } computeHold(entry, track) { const timelines = entry.animation.timelines; const timelinesCount = entry.animation.timelines.length; const timelineMode = entry.timelineMode; timelineMode.length = timelinesCount; const timelineHoldMix = entry.timelineHoldMix; timelineHoldMix.length = 0; const add = entry.additive, keepHold = entry.keepHold; const to = entry.mixingTo; for (let i = 0; i < timelinesCount; i++) { const timeline = timelines[i]; const ids = timeline.propertyIds; const from = this.from(track, timeline, ids); if (add && timeline.additive) { timelineMode[i] = from; continue; } let mode; if (to === null || timeline.instant || to.additive && timeline.additive || !to.animation?.hasTimeline(ids)) mode = from; else { mode = from | HOLD; for (let next = to.mixingTo; next != null; next = next.mixingTo) { if (next.additive && timeline.additive || !next.animation?.hasTimeline(ids)) { if (next.mixDuration > 0) timelineHoldMix[i] = next; break; } } } if (keepHold) mode = mode & ~HOLD | timelineMode[i] & HOLD; timelineMode[i] = mode; } } from(track, timeline, ids) { const propertyIds = this.propertyIds; let from = SETUP; for (let i = 0, n = ids.length; i < n; i++) { const owner = propertyIds.get(ids[i]); if (owner === void 0) { propertyIds.set(ids[i], track); } else { if (owner !== track) { while (++i < n) if (!propertyIds.has(ids[i])) propertyIds.set(ids[i], track); return CURRENT; } from = FIRST; } } if (timeline instanceof DrawOrderFolderTimeline) { const first = propertyIds.get(DrawOrderTimeline.propertyID); if (first != null) return first !== track ? CURRENT : FIRST; } return from; } /** Returns the track entry for the animation currently playing on the track, or null if no animation is currently playing. */ getTrack(trackIndex) { if (trackIndex < 0) throw new Error("trackIndex must be >= 0."); if (trackIndex >= this.tracks.length) return null; return this.tracks[trackIndex]; } /** Adds a listener to receive events for all track entries. */ addListener(listener) { if (!listener) throw new Error("listener cannot be null."); this.listeners.push(listener); } /** Removes the listener added with {@link addListener}. */ removeListener(listener) { const index = this.listeners.indexOf(listener); if (index >= 0) this.listeners.splice(index, 1); } /** Removes all listeners added with {@link addListener}. */ clearListeners() { this.listeners.length = 0; } /** Discards all listener notifications that have not yet been delivered. This can be useful to call from an * {@link AnimationStateListener} when it is known that further notifications that may have been already queued for delivery * are not wanted because new animations are being set. */ clearListenerNotifications() { this.queue.clear(); } }; var TrackEntry = class { /** The animation to apply for this track entry. */ animation = null; previous = null; /** The animation queued to start after this animation, or null. `next` makes up a linked list. */ next = null; /** The track entry for the previous animation when mixing to this animation, or null if no mixing is currently occurring. * When mixing from multiple animations, `mixingFrom` makes up a doubly linked list. */ mixingFrom = null; /** The track entry for the next animation when mixing from this animation, or null if no mixing is currently occurring. * When mixing to multiple animations, `mixingTo` makes up a doubly linked list. */ mixingTo = null; /** The listener for events generated by this track entry, or null. * * A track entry returned from {@link AnimationState.setAnimation} is already the current animation * for the track, so the callback for listener {@link AnimationStateListener.start} will not be called. */ listener = null; /** The index of the track where this track entry is either current or queued. * * See {@link AnimationState.getTrack}. */ trackIndex = 0; /** If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its * duration. */ loop = false; /** When true, timelines in this animation that support additive have their values added to the setup or current pose values * instead of replacing them. Additive can be set for a new track entry only before {@link AnimationState.apply} * is next called. */ additive = false; /** If true, the animation will be applied in reverse. */ reverse = false; /** If true, mixing rotation between tracks always uses the shortest rotation direction. If the rotation is animated, the * shortest rotation direction may change during the mix. * * If false, the shortest rotation direction is remembered when the mix starts and the same direction is used for the rest * of the mix. Defaults to false. * * See {@link resetRotationDirections}. */ shortestRotation = false; keepHold = false; /** When the interpolated mix percentage is less than the `eventThreshold` , event timelines are applied while * this animation is being mixed out. Defaults to 0, so event timelines are not applied while this animation is being mixed * out. */ eventThreshold = 0; /** When the interpolated mix percentage is less than the `mixAttachmentThreshold`, attachment timelines are * applied while this animation is being mixed out. Defaults to 0, so attachment timelines are not applied while this * animation is being mixed out. */ mixAttachmentThreshold = 0; /** When the computed alpha is greater than `alphaAttachmentThreshold`, attachment timelines are applied. The * computed alpha includes {@link alpha} and the interpolated mix percentage. Defaults to 0, so attachment timelines are * always applied. */ alphaAttachmentThreshold = 0; /** When the interpolated mix percentage is less than the `mixAttachmentThreshold`, attachment timelines are * applied while this animation is being mixed out. Defaults to 0, so attachment timelines are not applied while this * animation is being mixed out. */ mixDrawOrderThreshold = 0; /** The time in seconds for the first frame of this animation, both initially and after looping. Defaults to 0. * * When setting `animationStart` time, {@link animationLast} can be set to the same value to avoid firing events * from the start of the animation. */ animationStart = 0; /** The time in seconds for the last frame of this animation. Past this time, non-looping animations hold the pose at this * time while looping animations will loop back to {@link animationStart}. Defaults to the {@link Animation.duration}. */ animationEnd = 0; /** The time in seconds this animation was last applied. Some timelines use this for one-time triggers. For example, when * this animation is applied, event timelines will fire all events between the `animationLast` time (exclusive) * and `animationTime` (inclusive). Defaults to -1 to ensure triggers on frame 0 happen the first time this * animation is applied. */ animationLast = 0; nextAnimationLast = 0; /** Seconds to postpone playing the animation. Must be >= 0. When this track entry is the current track entry, * `delay` postpones incrementing the {@link trackTime}. When this track entry is queued, `delay` is * the time from the start of the previous animation to when this track entry will become the current track entry (ie when * the previous track entry {@link trackTime} >= this track entry's `delay`). * * {@link timeScale} affects the delay. * * When passing `delay` <= 0 to {@link AnimationState.addAnimation} this * `delay` is set using a mix duration from {@link AnimationStateData}. To change the {@link mixDuration} * afterward, use {@link setMixDuration} so this `delay` is adjusted. */ delay = 0; /** The time in seconds this track entry has been the current track entry, starting at 0 and increasing forever. Compare to * {@link getAnimationTime}, which is always between {@link animationStart} and {@link animationEnd}. * * The track time can be set to start the animation at a time other than 0, without affecting looping. When doing so, * {@link animationLast} can be set to the same value to avoid firing events from the start of the animation. * * To set the time an animation starts and loops, use {@link animationStart} and {@link animationEnd}. */ trackTime = 0; trackLast = 0; nextTrackLast = 0; /** The track time in seconds when this animation will be removed from the track. Defaults to the highest possible float * value, meaning the animation will be applied until a new animation is set or the track is cleared. If the track end time * is reached, no other animations are queued for playback, and mixing from any previous animations is complete, then the * properties keyed by the animation are set to the setup pose and the track is cleared. * * Usually you want to use {@link AnimationState.addEmptyAnimation} rather than have the animation * abruptly cease being applied, leaving the current pose. */ trackEnd = 0; /** Multiplier for the delta time when this track entry is updated, causing time for this animation to pass slower or * faster. Defaults to 1. * * Values < 0 are not supported. To play an animation in reverse, use {@link reverse}. * * {@link mixTime} is not affected by track entry time scale, so {@link mixDuration} may need to be adjusted to match the * animation speed. * * When using {@link AnimationState.addAnimation} with a `delay` <= 0, the * {@link delay} is set using the mix duration from {@link AnimationState.data}, assuming time scale to be 1. If the time * scale is not 1, the delay may need to be adjusted. * * See {@link AnimationState.timeScale} to affect all animations. */ timeScale = 0; /** Values < 1 mix this animation with the skeleton's current pose (either the setup pose or the pose from lower tracks). * Defaults to 1, which overwrites the skeleton's current pose with this animation. * * Alpha should be 1 on track 0. * * See {@link getAlphaAttachmentThreshold}. */ alpha = 0; /** Seconds elapsed from 0 to the {@link mixDuration} when mixing from the previous animation to this animation. May * be slightly more than `mixDuration` when the mix is complete. */ mixTime = 0; /** Seconds for mixing from the previous animation to this animation. Defaults to the value provided by * {@link AnimationStateData.getMix} based on the animation before this animation (if any). * * A mix duration of 0 still needs to be applied one more time to mix out, so the the properties it was animating are * reverted. A mix duration of 0 can be set at any time to end the mix on the next * {@link AnimationState.update | update}. * * The `mixDuration` can be set manually rather than use the value from * {@link AnimationStateData.getMix}. In that case, the `mixDuration` can be set for a new * track entry only before {@link AnimationState.update} is next called. * * When using {@link AnimationState.addAnimation} with a `delay` <= 0, the * {@link getDelay} is set using the mix duration from {@link AnimationState.data}. If `mixDuration` is set * afterward, the delay needs to be adjusted: * * 
   * entry.mixDuration = 0.25;

   * entry.delay = entry.previous.getTrackComplete() - entry.mixDuration + 0;
   *
* * Alternatively, use {@link setMixDuration} to set both the mix duration and recompute the delay:
* * 
    entry.setMixDuration(0.25f, 0); // mixDuration, delay
   *
*/ mixDuration = 0; totalAlpha = 0; mixInterpolation = Interpolation.linear; /** Sets both {@link getMixDuration} and {@link getDelay}. * @param delay If > 0, sets {@link getDelay}. If <= 0, the delay set is the duration of the previous track entry minus * the specified mix duration plus the specified `delay` (ie the mix ends at (when `delay` = * 0) or before (when `delay` < 0) the previous track entry duration). If the previous entry is * looping, its next loop completion is used instead of its duration. */ setMixDuration(mixDuration, delay) { this.mixDuration = mixDuration; if (delay !== void 0) { if (delay <= 0) delay = this.previous == null ? 0 : Math.max(delay + this.previous.getTrackComplete() - mixDuration, 0); this.delay = delay; } } /** The interpolation to apply to the mix percentage ({@link mixTime} / {@link mixDuration}) when mixing from the previous * animation to this animation. Defaults to linear. */ setMixInterpolation(mixInterpolation) { if (!mixInterpolation) throw new Error("mixInterpolation cannot be null."); this.mixInterpolation = mixInterpolation; } mix() { if (this.mixDuration === 0) return 1; let mix = this.mixTime / this.mixDuration; if (mix >= 1) return 1; if (this.mixInterpolation === Interpolation.linear) return mix; mix = this.mixInterpolation.apply(mix); if (mix < 0) return 0; if (mix > 1) return 1; return mix; } /** For each timeline: * - Bits 0-1: MixFrom. * - Bit 2, HOLD: 0 = mix out using alphaMix, 1 = apply full alpha to prevent dipping. Timeline is first on its track to * set the property and the next entry (mixingTo) also sets it. When held, timelineHoldMix's mix controls how the hold fades * out (for 3+ entry chains where the chain eventually stops setting the property). */ timelineMode = []; timelineHoldMix = []; timelinesRotation = []; reset() { this.next = null; this.previous = null; this.mixingFrom = null; this.mixingTo = null; this.mixInterpolation = Interpolation.linear; this.animation = null; this.listener = null; this.timelineMode.length = 0; this.timelineHoldMix.length = 0; this.timelinesRotation.length = 0; } /** Uses {@link trackTime} to compute the `animationTime`, which is always between {@link animationStart} and * {@link animationEnd}. When `trackTime` is 0, `animationTime` is equal to the * `animationStart` time. */ getAnimationTime() { if (!this.loop) return Math.min(this.trackTime + this.animationStart, this.animationEnd); const duration = this.animationEnd - this.animationStart; if (duration === 0) return this.animationStart; return this.trackTime % duration + this.animationStart; } setAnimationLast(animationLast) { this.animationLast = animationLast; this.nextAnimationLast = animationLast; } /** Returns true if at least one loop has been completed. * * See {@link AnimationStateListener.complete}. */ isComplete() { return this.trackTime >= this.animationEnd - this.animationStart; } /** When {@link shortestRotation} is false, this clears the directions for mixing this entry's rotation. This can be useful * to avoid bones rotating the long way around when using {@link getAlpha} and starting animations on other tracks. * * Mixing involves finding a rotation between two others. There are two possible solutions: the short or the long way * around. When the two rotations change over time, which direction is the short or long way can also change. If the short * way was always chosen, bones flip to the other side when that direction became the long way. TrackEntry chooses the short * way the first time it is applied and remembers that direction. Resetting that direction makes it choose a new short way * on the next apply. */ resetRotationDirections() { this.timelinesRotation.length = 0; } /** If this track entry is non-looping, this is the track time in seconds when {@link animationEnd} is reached, or the * current {@link trackTime} if it has already been reached. * * If this track entry is looping, this is the track time when this animation will reach its next {@link animationEnd} (the * next loop completion). */ getTrackComplete() { const duration = this.animationEnd - this.animationStart; if (duration !== 0) { if (this.loop) return duration * (1 + (this.trackTime / duration | 0)); if (this.trackTime < duration) return duration; } return this.trackTime; } /** Returns true if this track entry has been applied at least once. * * See {@link AnimationState.apply}. */ wasApplied() { return this.nextTrackLast !== -1; } /** Returns true if there is a {@link next} track entry and it will become the current track entry during the next * {@link AnimationState.update}. */ isNextReady() { return this.next != null && this.nextTrackLast - this.next.delay >= 0; } }; var EventQueue = class { objects = []; drainDisabled = false; animState; constructor(animState) { this.animState = animState; } start(entry) { this.objects.push(0 /* start */); this.objects.push(entry); this.animState.animationsChanged = true; } interrupt(entry) { this.objects.push(1 /* interrupt */); this.objects.push(entry); } end(entry) { this.objects.push(2 /* end */); this.objects.push(entry); this.animState.animationsChanged = true; } dispose(entry) { this.objects.push(3 /* dispose */); this.objects.push(entry); } complete(entry) { this.objects.push(4 /* complete */); this.objects.push(entry); } event(entry, event) { this.objects.push(5 /* event */); this.objects.push(entry); this.objects.push(event); } drain() { if (this.drainDisabled) return; this.drainDisabled = true; for (let i = 0; i < this.objects.length; i += 2) { const objects = this.objects; const type = objects[i]; const entry = objects[i + 1]; const listeners = this.animState.listeners.slice(); switch (type) { case 0 /* start */: if (entry.listener?.start) entry.listener.start(entry); for (let ii = 0; ii < listeners.length; ii++) { const listener = listeners[ii]; if (listener.start) listener.start(entry); } break; case 1 /* interrupt */: if (entry.listener?.interrupt) entry.listener.interrupt(entry); for (let ii = 0; ii < listeners.length; ii++) { const listener = listeners[ii]; if (listener.interrupt) listener.interrupt(entry); } break; // biome-ignore lint/suspicious/noFallthroughSwitchClause: reference runtime does fall through case 2 /* end */: if (entry.listener?.end) entry.listener.end(entry); for (let ii = 0; ii < listeners.length; ii++) { const listener = listeners[ii]; if (listener.end) listener.end(entry); } // Fall through. case 3 /* dispose */: if (entry.listener?.dispose) entry.listener.dispose(entry); for (let ii = 0; ii < listeners.length; ii++) { const listener = listeners[ii]; if (listener.dispose) listener.dispose(entry); } this.animState.trackEntryPool.free(entry); break; case 4 /* complete */: if (entry.listener?.complete) entry.listener.complete(entry); for (let ii = 0; ii < listeners.length; ii++) { const listener = listeners[ii]; if (listener.complete) listener.complete(entry); } break; case 5 /* event */: { const event = objects[i++ + 2]; if (entry.listener?.event) entry.listener.event(entry, event); for (let ii = 0; ii < listeners.length; ii++) { const listener = listeners[ii]; if (listener.event) listener.event(entry, event); } break; } } } this.clear(); this.drainDisabled = false; } clear() { this.objects.length = 0; } }; var EventType = /* @__PURE__ */ ((EventType2) => { EventType2[EventType2["start"] = 0] = "start"; EventType2[EventType2["interrupt"] = 1] = "interrupt"; EventType2[EventType2["end"] = 2] = "end"; EventType2[EventType2["dispose"] = 3] = "dispose"; EventType2[EventType2["complete"] = 4] = "complete"; EventType2[EventType2["event"] = 5] = "event"; return EventType2; })(EventType || {}); var AnimationStateAdapter = class { start(entry) { } interrupt(entry) { } end(entry) { } dispose(entry) { } complete(entry) { } event(entry, event) { } }; var CURRENT = 0; var SETUP = 1; var FIRST = 2; var MODE = 3; var HOLD = 4; var ATTACH_SETUP = 1; var ATTACH_RETAIN = 2; // spine-core/src/AnimationStateData.ts var AnimationStateData = class { /** The SkeletonData to look up animations when they are specified by name. */ skeletonData; animationToMixTime = {}; /** The mix duration to use when no mix duration has been defined between two animations. */ defaultMix = 0; constructor(skeletonData) { if (!skeletonData) throw new Error("skeletonData cannot be null."); this.skeletonData = skeletonData; } setMix(from, to, duration) { if (typeof from === "string") return this.setMix1(from, to, duration); return this.setMix2(from, to, duration); } setMix1(fromName, toName, duration) { const from = this.skeletonData.findAnimation(fromName); if (!from) throw new Error(`Animation not found: ${fromName}`); const to = this.skeletonData.findAnimation(toName); if (!to) throw new Error(`Animation not found: ${toName}`); this.setMix2(from, to, duration); } setMix2(from, to, duration) { if (!from) throw new Error("from cannot be null."); if (!to) throw new Error("to cannot be null."); const key = `${from.name}.${to.name}`; this.animationToMixTime[key] = duration; } /** Returns the mix duration to use when changing from the specified animation to the other on the same track, or the * {@link defaultMix} if no mix duration has been set. */ getMix(from, to) { const key = `${from.name}.${to.name}`; const value = this.animationToMixTime[key]; return value === void 0 ? this.defaultMix : value; } }; // spine-core/src/AssetManagerBase.ts var AssetManagerBase = class { constructor(textureLoader, pathPrefix = "", downloader = new Downloader(), cache = new AssetCache()) { this.textureLoader = textureLoader; this.pathPrefix = pathPrefix; this.downloader = downloader; this.cache = cache; } errors = {}; toLoad = 0; loaded = 0; texturePmaInfo = {}; start(path) { this.toLoad++; return this.pathPrefix + path; } success(callback, path, asset) { this.toLoad--; this.loaded++; this.cache.assets[path] = asset; this.cache.assetsRefCount[path] = (this.cache.assetsRefCount[path] || 0) + 1; if (callback) callback(path, asset); } error(callback, path, message) { this.toLoad--; this.loaded++; this.errors[path] = message; if (callback) callback(path, message); } loadAll() { const promise = new Promise((resolve, reject) => { const check = () => { if (this.isLoadingComplete()) { if (this.hasErrors()) reject(this.errors); else resolve(this); return; } requestAnimationFrame(check); }; requestAnimationFrame(check); }); return promise; } setRawDataURI(path, data) { this.downloader.rawDataUris[this.pathPrefix + path] = data; } loadBinary(path, success = () => { }, error = () => { }) { path = this.start(path); if (this.reuseAssets(path, success, error)) return; this.cache.assetsLoaded[path] = new Promise((resolve, reject) => { this.downloader.downloadBinary(path, (data) => { this.success(success, path, data); resolve(data); }, (status, responseText) => { const errorMsg = `Couldn't load binary ${path}: status ${status}, ${responseText}`; this.error(error, path, errorMsg); reject(errorMsg); }); }); } loadText(path, success = () => { }, error = () => { }) { path = this.start(path); this.downloader.downloadText(path, (data) => { this.success(success, path, data); }, (status, responseText) => { this.error(error, path, `Couldn't load text ${path}: status ${status}, ${responseText}`); }); } loadJson(path, success = () => { }, error = () => { }) { path = this.start(path); if (this.reuseAssets(path, success, error)) return; this.cache.assetsLoaded[path] = new Promise((resolve, reject) => { this.downloader.downloadJson(path, (data) => { this.success(success, path, data); resolve(data); }, (status, responseText) => { const errorMsg = `Couldn't load JSON ${path}: status ${status}, ${responseText}`; this.error(error, path, errorMsg); reject(errorMsg); }); }); } reuseAssets(path, success = () => { }, error = () => { }) { const loadedStatus = this.cache.getAsset(path); const alreadyExistsOrLoading = loadedStatus !== void 0; if (alreadyExistsOrLoading) { this.cache.assetsLoaded[path] = loadedStatus.then((data) => { data = data instanceof Image || data instanceof ImageBitmap ? this.textureLoader(data) : data; this.success(success, path, data); return data; }).catch((errorMsg) => { this.error(error, path, errorMsg); return void 0; }); } return alreadyExistsOrLoading; } loadTexture(path, success = () => { }, error = () => { }) { path = this.start(path); if (this.reuseAssets(path, success, error)) return; const pma = this.texturePmaInfo[path]; this.cache.assetsLoaded[path] = new Promise((resolve, reject) => { const isBrowser = !!(typeof window !== "undefined" && typeof navigator !== "undefined" && window.document); const isWebWorker = !isBrowser; if (isWebWorker) { fetch(path, { mode: "cors" }).then((response) => { if (response.ok) return response.blob(); const errorMsg = `Couldn't load image: ${path}`; this.error(error, path, `Couldn't load image: ${path}`); reject(errorMsg); }).then((blob) => { return blob ? createImageBitmap(blob, { premultiplyAlpha: "none", colorSpaceConversion: "none" }) : null; }).then((bitmap) => { if (bitmap) { const texture = this.createTexture(path, pma, bitmap); this.success(success, path, texture); resolve(texture); } ; }); } else { const image = new Image(); image.crossOrigin = "anonymous"; image.onload = () => { const texture = this.createTexture(path, pma, image); this.success(success, path, texture); resolve(texture); }; image.onerror = () => { const errorMsg = `Couldn't load image: ${path}`; this.error(error, path, errorMsg); reject(errorMsg); }; if (this.downloader.rawDataUris[path]) path = this.downloader.rawDataUris[path]; image.src = path; } }); } loadTextureAtlas(path, success = () => { }, error = () => { }, fileAlias) { const index = path.lastIndexOf("/"); const parent = index >= 0 ? path.substring(0, index + 1) : ""; path = this.start(path); if (this.reuseAssets(path, success, error)) return; this.cache.assetsLoaded[path] = new Promise((resolve, reject) => { this.downloader.downloadText(path, (atlasText) => { try { const atlas = this.createTextureAtlas(atlasText, parent, path, fileAlias); let toLoad = atlas.pages.length, abort = false; if (toLoad === 0) { this.success(success, path, atlas); resolve(atlas); return; } for (const page of atlas.pages) { this.loadTexture( this.texturePath(parent, page.name, fileAlias), (imagePath, texture) => { if (!abort) { page.setTexture(texture); if (--toLoad === 0) { this.success(success, path, atlas); resolve(atlas); } } }, (imagePath, message) => { if (!abort) { const errorMsg = `Couldn't load texture ${path} page image: ${imagePath}`; this.error(error, path, errorMsg); reject(errorMsg); } abort = true; } ); } } catch (e) { const errorMsg = `Couldn't parse texture atlas ${path}: ${e.message}`; this.error(error, path, errorMsg); reject(errorMsg); } }, (status, responseText) => { const errorMsg = `Couldn't load texture atlas ${path}: status ${status}, ${responseText}`; this.error(error, path, errorMsg); reject(errorMsg); }); }); } loadTextureAtlasButNoTextures(path, success = () => { }, error = () => { }) { const index = path.lastIndexOf("/"); const parent = index >= 0 ? path.substring(0, index + 1) : ""; path = this.start(path); if (this.reuseAssets(path, success, error)) return; this.cache.assetsLoaded[path] = new Promise((resolve, reject) => { this.downloader.downloadText(path, (atlasText) => { try { const atlas = this.createTextureAtlas(atlasText, parent, path); this.success(success, path, atlas); resolve(atlas); } catch (e) { const errorMsg = `Couldn't parse texture atlas ${path}: ${e.message}`; this.error(error, path, errorMsg); reject(errorMsg); } }, (status, responseText) => { const errorMsg = `Couldn't load texture atlas ${path}: status ${status}, ${responseText}`; this.error(error, path, errorMsg); reject(errorMsg); }); }); } async loadBinaryAsync(path) { return new Promise((resolve, reject) => { this.loadBinary( path, (_, binary) => resolve(binary), (_, message) => reject(message) ); }); } async loadJsonAsync(path) { return new Promise((resolve, reject) => { this.loadJson( path, (_, object) => resolve(object), (_, message) => reject(message) ); }); } async loadTextureAsync(path) { return new Promise((resolve, reject) => { this.loadTexture( path, (_, texture) => resolve(texture), (_, message) => reject(message) ); }); } async loadTextureAtlasAsync(path) { return new Promise((resolve, reject) => { this.loadTextureAtlas( path, (_, atlas) => resolve(atlas), (_, message) => reject(message) ); }); } async loadTextureAtlasButNoTexturesAsync(path) { return new Promise((resolve, reject) => { this.loadTextureAtlasButNoTextures( path, (_, atlas) => resolve(atlas), (_, message) => reject(message) ); }); } setCache(cache) { this.cache = cache; } get(path) { return this.cache.assets[this.pathPrefix + path]; } require(path) { path = this.pathPrefix + path; const asset = this.cache.assets[path]; if (asset) return asset; const error = this.errors[path]; throw Error(`Asset not found: ${path}${error ? ` ${error}` : ""}`); } remove(path) { path = this.pathPrefix + path; const asset = this.cache.assets[path]; if (asset.dispose) asset.dispose(); delete this.cache.assets[path]; delete this.cache.assetsRefCount[path]; delete this.cache.assetsLoaded[path]; return asset; } removeAll() { for (const path in this.cache.assets) { const asset = this.cache.assets[path]; if (asset.dispose) asset.dispose(); } this.cache.assets = {}; this.cache.assetsLoaded = {}; this.cache.assetsRefCount = {}; } isLoadingComplete() { return this.toLoad === 0; } getToLoad() { return this.toLoad; } getLoaded() { return this.loaded; } dispose() { this.removeAll(); } // dispose asset only if it's not used by others disposeAsset(path) { const asset = this.cache.assets[path]; if (asset instanceof TextureAtlas) { asset.dispose(); return; } this.disposeAssetInternal(path); } hasErrors() { return Object.keys(this.errors).length > 0; } getErrors() { return this.errors; } disposeAssetInternal(path) { if (this.cache.assetsRefCount[path] > 0 && --this.cache.assetsRefCount[path] === 0) { return this.remove(path); } } createTextureAtlas(atlasText, parentPath, path, fileAlias) { const atlas = new TextureAtlas(atlasText); atlas.dispose = () => { if (this.cache.assetsRefCount[path] <= 0) return; this.disposeAssetInternal(path); for (const page of atlas.pages) { page.texture?.dispose(); } }; for (const page of atlas.pages) { const texturePath = this.texturePath(parentPath, page.name, fileAlias); this.texturePmaInfo[this.pathPrefix + texturePath] = page.pma; } return atlas; } createTexture(path, pma, image) { const texture = this.textureLoader(image, pma); const textureDispose = texture.dispose.bind(texture); texture.dispose = () => { if (this.disposeAssetInternal(path)) textureDispose(); }; return texture; } texturePath(parentPath, pageName, fileAlias) { if (!fileAlias) return parentPath + pageName; return fileAlias[pageName]; } }; var AssetCache = class _AssetCache { assets = {}; assetsRefCount = {}; assetsLoaded = {}; static AVAILABLE_CACHES = /* @__PURE__ */ new Map(); static getCache(id) { const cache = _AssetCache.AVAILABLE_CACHES.get(id); if (cache) return cache; const newCache = new _AssetCache(); _AssetCache.AVAILABLE_CACHES.set(id, newCache); return newCache; } async addAsset(path, asset) { this.assetsLoaded[path] = Promise.resolve(asset); this.assets[path] = asset; return asset; } getAsset(path) { return this.assetsLoaded[path]; } }; var Downloader = class { callbacks = {}; rawDataUris = {}; dataUriToString(dataUri) { if (!dataUri.startsWith("data:")) { throw new Error("Not a data URI."); } let base64Idx = dataUri.indexOf("base64,"); if (base64Idx !== -1) { base64Idx += "base64,".length; return atob(dataUri.substr(base64Idx)); } else { return dataUri.substr(dataUri.indexOf(",") + 1); } } base64ToUint8Array(base64) { var binary_string = window.atob(base64); var len = binary_string.length; var bytes = new Uint8Array(len); for (let i = 0; i < len; i++) { bytes[i] = binary_string.charCodeAt(i); } return bytes; } dataUriToUint8Array(dataUri) { if (!dataUri.startsWith("data:")) { throw new Error("Not a data URI."); } let base64Idx = dataUri.indexOf("base64,"); if (base64Idx === -1) throw new Error("Not a binary data URI."); base64Idx += "base64,".length; return this.base64ToUint8Array(dataUri.substr(base64Idx)); } downloadText(url, success, error) { if (this.start(url, success, error)) return; const rawDataUri = this.rawDataUris[url]; if (rawDataUri && !rawDataUri.includes(".")) { try { this.finish(url, 200, this.dataUriToString(rawDataUri)); } catch (e) { this.finish(url, 400, JSON.stringify(e)); } return; } const request = new XMLHttpRequest(); request.overrideMimeType("text/html"); request.open("GET", rawDataUri ? rawDataUri : url, true); const done = () => { this.finish(url, request.status, request.responseText); }; request.onload = done; request.onerror = done; request.send(); } downloadJson(url, success, error) { this.downloadText(url, (data) => { success(JSON.parse(data)); }, error); } downloadBinary(url, success, error) { if (this.start(url, success, error)) return; const rawDataUri = this.rawDataUris[url]; if (rawDataUri && !rawDataUri.includes(".")) { try { this.finish(url, 200, this.dataUriToUint8Array(rawDataUri)); } catch (e) { this.finish(url, 400, JSON.stringify(e)); } return; } const request = new XMLHttpRequest(); request.open("GET", rawDataUri ? rawDataUri : url, true); request.responseType = "arraybuffer"; const onerror = () => { this.finish(url, request.status, request.response); }; request.onload = () => { if (request.status === 200 || request.status === 0) this.finish(url, 200, new Uint8Array(request.response)); else onerror(); }; request.onerror = onerror; request.send(); } start(url, success, error) { let callbacks = this.callbacks[url]; try { if (callbacks) return true; this.callbacks[url] = callbacks = []; } finally { callbacks.push(success, error); } } finish(url, status, data) { const callbacks = this.callbacks[url]; delete this.callbacks[url]; if (status === 200 || status === 0) { for (let i = 0, n = callbacks.length; i < n; i += 2) callbacks[i](data); } else { for (let i = 1, n = callbacks.length; i < n; i += 2) callbacks[i](status, data); } } }; // spine-core/src/attachments/BoundingBoxAttachment.ts var BoundingBoxAttachment = class _BoundingBoxAttachment extends VertexAttachment { color = new Color(1, 1, 1, 1); constructor(name) { super(name); } copy() { const copy = new _BoundingBoxAttachment(this.name); this.copyTo(copy); copy.color.setFromColor(this.color); return copy; } }; // spine-core/src/attachments/ClippingAttachment.ts var ClippingAttachment = class _ClippingAttachment extends VertexAttachment { /** Clipping is performed between the clipping attachment's slot and the end slot. If null, clipping is done until the end of * the skeleton's rendering. */ endSlot = null; /** When true the clipping polygon is treated as convex for more efficient clipping. If the polygon deforms to concave then the * convex hull is used. When false the clipping polygon can be concave and if so has an additional CPU cost. Inverse clipping * always uses convex. */ convex = false; /** When false, everything inside the clipping polygon is visible. When true, everything outside the clipping polygon is * visible and clipping is convex. */ inverse = false; // Nonessential. /** The color of the clipping polygon as it was in Spine. Available only when nonessential data was exported. Clipping polygons * are not usually rendered at runtime. */ color = new Color(0.2275, 0.2275, 0.8078, 1); // ce3a3aff constructor(name) { super(name); } copy() { const copy = new _ClippingAttachment(this.name); this.copyTo(copy); copy.endSlot = this.endSlot; copy.convex = this.convex; copy.inverse = this.inverse; copy.color.setFromColor(this.color); return copy; } }; // spine-core/src/attachments/PathAttachment.ts var PathAttachment = class _PathAttachment extends VertexAttachment { /** The lengths along the path in the setup pose from the start of the path to the end of each Bezier curve. */ lengths = []; /** If true, the start and end knots are connected. */ closed = false; /** If true, additional calculations are performed to make computing positions along the path more accurate so movement along * the path has a constant speed. */ constantSpeed = false; /** The color of the path as it was in Spine. Available only when nonessential data was exported. Paths are not usually * rendered at runtime. */ color = new Color(1, 1, 1, 1); constructor(name) { super(name); } copy() { const copy = new _PathAttachment(this.name); this.copyTo(copy); copy.lengths = []; Utils.arrayCopy(this.lengths, 0, copy.lengths, 0, this.lengths.length); copy.closed = this.closed; copy.constantSpeed = this.constantSpeed; copy.color.setFromColor(this.color); return copy; } }; // spine-core/src/attachments/PointAttachment.ts var PointAttachment = class _PointAttachment extends VertexAttachment { /** The local x position. */ x = 0; /** The local y position. */ y = 0; /** The local rotation in degrees, counter clockwise. */ rotation = 0; /** The color of the point attachment as it was in Spine. Available only when nonessential data was exported. Point attachments * are not usually rendered at runtime. */ color = new Color(0.38, 0.94, 0, 1); constructor(name) { super(name); } /** Computes the world position from the local position. */ computeWorldPosition(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; } /** Computes the world rotation from the local rotation. */ computeWorldRotation(bone) { const r = this.rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r); const x = cos * bone.a + sin * bone.b; const y = cos * bone.c + sin * bone.d; return MathUtils.atan2Deg(y, x); } copy() { const copy = new _PointAttachment(this.name); copy.x = this.x; copy.y = this.y; copy.rotation = this.rotation; copy.color.setFromColor(this.color); return copy; } }; // spine-core/src/AtlasAttachmentLoader.ts var AtlasAttachmentLoader = class { atlas; allowMissingRegions; constructor(atlas, allowMissingRegions = false) { this.atlas = atlas; this.allowMissingRegions = allowMissingRegions; } /** Sets each {@link Sequence.regions} by calling {@link findRegion} for each texture region using * {@link Sequence.getPath}. */ findRegions(name, basePath, sequence) { const regions = sequence.regions; for (let i = 0, n = regions.length; i < n; i++) regions[i] = this.findRegion(name, sequence.getPath(basePath, i)); } /** Looks for the region with the specified path. If not found and {@link allowMissingRegions} is false, an error is * raised. */ findRegion(name, path) { const region = this.atlas.findRegion(path); if (!region && !this.allowMissingRegions) throw new Error(`Region not found in atlas: ${path} (attachment: ${name})`); return region; } newRegionAttachment(skin, placeholder, name, path, sequence) { this.findRegions(name, path, sequence); return new RegionAttachment(name, sequence); } newMeshAttachment(skin, placeholder, name, path, sequence) { this.findRegions(name, path, sequence); return new MeshAttachment(name, sequence); } newBoundingBoxAttachment(skin, placeholder, name) { return new BoundingBoxAttachment(name); } newPathAttachment(skin, placeholder, name) { return new PathAttachment(name); } newPointAttachment(skin, placeholder, name) { return new PointAttachment(name); } newClippingAttachment(skin, placeholder, name) { return new ClippingAttachment(name); } }; // spine-core/src/PosedData.ts var PosedData = class { name; setupPose; /** When true, {@link Skeleton.updateWorldTransform} only updates this constraint if the {@link Skeleton.skin} * contains this constraint. * * See {@link Skin.constraints}. */ skinRequired = false; constructor(name, setupPose) { if (name == null) throw new Error("name cannot be null."); this.name = name; this.setupPose = setupPose; } }; // spine-core/src/BoneData.ts var BoneData = class _BoneData extends PosedData { /** The index of the bone in {@link Skeleton.bones}. */ index = 0; /** The parent bone, or null if this bone is the root. */ parent = null; /** The bone's length. */ length = 0; // Nonessential. /** The color of the bone as it was in Spine. Available only when nonessential data was exported. Bones are not usually * rendered at runtime. */ color = new Color(); /** The bone icon name as it was in Spine, or null if nonessential data was not exported. */ icon; /** The bone icon's display size scale, or 1 if nonessential data was not exported. */ iconSize = 1; /** The bone icon's display rotation in degrees, or 0 if nonessential data was not exported. */ iconRotation = 0; /** False if the bone was hidden in Spine and nonessential data was exported. Does not affect runtime rendering. */ visible = false; constructor(index, name, parent) { super(name, new BonePose()); if (index < 0) throw new Error("index must be >= 0."); if (!name) throw new Error("name cannot be null."); this.index = index; this.parent = parent; } copy(parent) { const copy = new _BoneData(this.index, this.name, parent); copy.length = this.length; copy.setupPose.set(this.setupPose); return copy; } }; var Inherit = /* @__PURE__ */ ((Inherit2) => { Inherit2[Inherit2["Normal"] = 0] = "Normal"; Inherit2[Inherit2["OnlyTranslation"] = 1] = "OnlyTranslation"; Inherit2[Inherit2["NoRotationOrReflection"] = 2] = "NoRotationOrReflection"; Inherit2[Inherit2["NoScale"] = 3] = "NoScale"; Inherit2[Inherit2["NoScaleOrReflection"] = 4] = "NoScaleOrReflection"; return Inherit2; })(Inherit || {}); // spine-core/src/BonePose.ts var BonePose = class { bone; /** The local x translation. */ x = 0; /** The local y translation. */ y = 0; /** The local rotation in degrees, counter clockwise. */ rotation = 0; /** The local scaleX. */ scaleX = 0; /** The local scaleY. */ scaleY = 0; /** The local shearX. */ shearX = 0; /** The local shearY. */ shearY = 0; inherit = 0 /* Normal */; /** The world transform `[a b][c d]` x-axis x component. */ a = 0; /** The world transform `[a b][c d]` y-axis x component. */ b = 0; /** The world transform `[a b][c d]` x-axis y component. */ c = 0; /** The world transform `[a b][c d]` y-axis y component. */ d = 0; /** The world X position. If changed, {@link updateLocalTransform} should be called. */ worldY = 0; /** The world Y position. If changed, {@link updateLocalTransform} should be called. */ worldX = 0; world = 0; local = 0; set(pose) { if (pose == null) throw new Error("pose cannot be null."); this.x = pose.x; this.y = pose.y; this.rotation = pose.rotation; this.scaleX = pose.scaleX; this.scaleY = pose.scaleY; this.shearX = pose.shearX; this.shearY = pose.shearY; this.inherit = pose.inherit; } setPosition(x, y) { this.x = x; this.y = y; } setScale(scaleOrX, scaleY) { this.scaleX = scaleOrX; this.scaleY = scaleY === void 0 ? scaleOrX : scaleY; } /** Determines how parent world transforms affect this bone. */ getInherit() { return this.inherit; } setInherit(inherit) { if (inherit == null) throw new Error("inherit cannot be null."); this.inherit = inherit; } /** Called by {@link Skeleton.updateCache} to compute the world transform, if needed. */ update(skeleton, physics) { if (this.world !== skeleton._update) this.updateWorldTransform(skeleton); } /** Computes the world transform using the parent bone's world transform and this applied local pose. Child bones are not * updated. * * See World transforms in the Spine * Runtimes Guide. */ updateWorldTransform(skeleton) { if (this.local === skeleton._update) this.updateLocalTransform(skeleton); else this.world = skeleton._update; const rotation = this.rotation; const scaleX = this.scaleX; const scaleY = this.scaleY; const shearX = this.shearX; const shearY = this.shearY; if (!this.bone.parent) { const sx = skeleton.scaleX, sy = skeleton.scaleY; const rx = (rotation + shearX) * MathUtils.degRad; const ry = (rotation + 90 + shearY) * MathUtils.degRad; this.a = Math.cos(rx) * scaleX * sx; this.b = Math.cos(ry) * scaleY * sx; this.c = Math.sin(rx) * scaleX * sy; this.d = Math.sin(ry) * scaleY * sy; this.worldX = this.x * sx + skeleton.x; this.worldY = this.y * sy + skeleton.y; return; } const parent = this.bone.parent.appliedPose; let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d; this.worldX = pa * this.x + pb * this.y + parent.worldX; this.worldY = pc * this.x + pd * this.y + parent.worldY; switch (this.inherit) { case 0 /* Normal */: { const rx = (rotation + shearX) * MathUtils.degRad; const ry = (rotation + 90 + shearY) * MathUtils.degRad; const la = Math.cos(rx) * scaleX; const lb = Math.cos(ry) * scaleY; const lc = Math.sin(rx) * scaleX; const ld = Math.sin(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; return; } case 1 /* OnlyTranslation */: { const sx = skeleton.scaleX, sy = skeleton.scaleY; const rx = (rotation + shearX) * MathUtils.degRad; const ry = (rotation + 90 + shearY) * MathUtils.degRad; this.a = Math.cos(rx) * scaleX * sx; this.b = Math.cos(ry) * scaleY * sx; this.c = Math.sin(rx) * scaleX * sy; this.d = Math.sin(ry) * scaleY * sy; break; } case 2 /* NoRotationOrReflection */: { const sx = skeleton.scaleX, sy = skeleton.scaleY, sxi = 1 / sx, syi = 1 / sy; pa *= sxi; pc *= syi; let s = pa * pa + pc * pc; let r = 0; if (s > MathUtils.epsilon2) { s = Math.abs(pa * pd * syi - pb * sxi * pc) / s; pb = pc * s; pd = pa * s; r = rotation - MathUtils.atan2Deg(pc, pa); } else { pa = 0; pc = 0; r = rotation - 90 + MathUtils.atan2Deg(pd, pb); } const rx = (r + shearX) * MathUtils.degRad; const ry = (r + shearY + 90) * MathUtils.degRad; const la = Math.cos(rx) * scaleX; const lb = Math.cos(ry) * scaleY; const lc = Math.sin(rx) * scaleX; const ld = Math.sin(ry) * scaleY; this.a = (pa * la - pb * lc) * sx; this.b = (pa * lb - pb * ld) * sx; this.c = (pc * la + pd * lc) * sy; this.d = (pc * lb + pd * ld) * sy; break; } case 3 /* NoScale */: case 4 /* NoScaleOrReflection */: { const sx = skeleton.scaleX, sy = skeleton.scaleY, sxi = 1 / sx, syi = 1 / sy; const r = rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r); let za = (pa * cos + pb * sin) * sxi; let zc = (pc * cos + pd * sin) * syi; const s = 1 / Math.sqrt(za * za + zc * zc); za *= s; zc *= s; let zb = -zc, zd = za; if (this.inherit === 3 /* NoScale */ && pa * pd - pb * pc < 0 !== (sx < 0 !== sy < 0)) { zb = -zb; zd = -zd; } const rx = shearX * MathUtils.degRad; const ry = (90 + shearY) * MathUtils.degRad; const la = Math.cos(rx) * scaleX; const lb = Math.cos(ry) * scaleY; const lc = Math.sin(rx) * scaleX; const ld = Math.sin(ry) * scaleY; this.a = (za * la + zb * lc) * sx; this.b = (za * lb + zb * ld) * sx; this.c = (zc * la + zd * lc) * sy; this.d = (zc * lb + zd * ld) * sy; break; } } } /** Computes the local transform values from the world transform. * * If the world transform is modified (by a constraint, {@link rotateWorld}, etc) then this method should be called so * the local transform matches the world transform. The local transform may be needed by other code (eg to apply another * constraint). * * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The local transform after * calling this method is equivalent to the local transform used to compute the world transform, but may not be identical. */ updateLocalTransform(skeleton) { this.local = 0; this.world = skeleton._update; const sx = skeleton.scaleX, sy = skeleton.scaleY; if (!this.bone.parent) { const sxi = 1 / sx, syi = 1 / sy; this.x = (this.worldX - skeleton.x) * sxi; this.y = (this.worldY - skeleton.y) * syi; this.set5(this.a * sxi, this.b * sxi, this.c * syi, this.d * syi, 0); return; } const parent = this.bone.parent.appliedPose; let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d; const pad = pa * pd - pb * pc, pid = 1 / (pa * pd - pb * pc); const ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid; const dx = this.worldX - parent.worldX, dy = this.worldY - parent.worldY; this.x = dx * ia - dy * ib; this.y = dy * id - dx * ic; switch (this.inherit) { case 0 /* Normal */: this.set5(ia * this.a - ib * this.c, ia * this.b - ib * this.d, id * this.c - ic * this.a, id * this.d - ic * this.b, 0); break; case 1 /* OnlyTranslation */: { const sxi = 1 / sx, syi = 1 / sy; this.set5(this.a * sxi, this.b * sxi, this.c * syi, this.d * syi, 0); break; } case 2 /* NoRotationOrReflection */: { const sxi = 1 / sx, syi = 1 / sy; pa *= sxi; pc *= syi; const wa = this.a * sxi, wb = this.b * sxi, wc = this.c * syi, wd = this.d * syi; const s = 1 / (pa * pa + pc * pc), det = 1 / Math.abs(pad * sxi * syi); this.set5( (pa * wa + pc * wc) * s, (pa * wb + pc * wd) * s, (pa * wc - pc * wa) * det, (pa * wd - pc * wb) * det, MathUtils.atan2Deg(pc, pa) ); break; } case 3 /* NoScale */: case 4 /* NoScaleOrReflection */: { const sxi = 1 / sx, syi = 1 / sy; const wa = this.a * sxi, wb = this.b * sxi, wc = this.c * syi, wd = this.d * syi; let tx = pd * this.a - pb * this.c, ty = pa * this.c - pc * this.a; if (pad < 0) { tx = -tx; ty = -ty; } let r = MathUtils.atan2Deg(ty, tx); this.rotation = r; r *= MathUtils.degRad; const cos = Math.cos(r), sin = Math.sin(r); let za = (pa * cos + pb * sin) * sxi; let zc = (pc * cos + pd * sin) * syi; const s = 1 / Math.sqrt(za * za + zc * zc); za *= s; zc *= s; const si = this.inherit === 3 /* NoScale */ && pad < 0 !== (sx < 0 !== sy < 0) ? -1 : 1; this.set4(za * wa + zc * wc, za * wb + zc * wd, (za * wc - zc * wa) * si, (za * wd - zc * wb) * si); } } } set4(ra, rb, rc, rd) { const x = ra * ra + rc * rc, y = rb * rb + rd * rd; if (x > MathUtils.epsilon2) { this.shearX = MathUtils.atan2Deg(rc, ra); this.scaleX = Math.sqrt(x); } else { this.shearX = 0; this.scaleX = 0; } this.scaleY = Math.sqrt(y); if (y > MathUtils.epsilon2) { this.shearY = MathUtils.atan2Deg(rd, rb); if (ra * rd - rb * rc < 0) { this.scaleY = -this.scaleY; this.shearY += 90; } else this.shearY -= 90; if (this.shearY > 180) this.shearY -= 360; else if (this.shearY <= -180) this.shearY += 360; } else this.shearY = 0; } set5(ra, rb, rc, rd, ro) { this.shearX = 0; const x = ra * ra + rc * rc, y = rb * rb + rd * rd; if (x > MathUtils.epsilon2) { const r = MathUtils.atan2Deg(rc, ra); this.rotation = r + ro; this.scaleX = Math.sqrt(x); this.scaleY = Math.sqrt(y); if (y > MathUtils.epsilon2) { this.shearY = MathUtils.atan2Deg(rd, rb); if (ra * rd - rb * rc < 0) { this.scaleY = -this.scaleY; this.shearY += 90 - r; } else this.shearY -= 90 + r; if (this.shearY > 180) this.shearY -= 360; else if (this.shearY <= -180) this.shearY += 360; } else this.shearY = 0; } else { this.scaleX = 0; this.scaleY = Math.sqrt(y); this.shearY = 0; this.rotation = y > MathUtils.epsilon2 ? MathUtils.atan2Deg(rd, rb) - 90 + ro : ro; } } /** If the world transform has been modified by constraints and the local transform no longer matches, * {@link updateLocalTransform} is called. Call this after {@link Skeleton.updateWorldTransform} before * using the applied local transform. */ validateLocalTransform(skeleton) { if (this.local === skeleton._update) this.updateLocalTransform(skeleton); } modifyLocal(skeleton) { if (this.local === skeleton._update) this.updateLocalTransform(skeleton); this.world = 0; this.resetWorld(skeleton, skeleton._update); } modifyWorld(skeleton) { const update = skeleton._update; this.local = update; this.world = update; this.resetWorld(skeleton, update); } resetWorld(skeleton, update) { const children = this.bone.children; for (let i = 0, n = children.length; i < n; i++) { const child = children[i].appliedPose; if (child.world === update) { if (child.local === update) child.updateLocalTransform(skeleton); child.world = 0; child.resetWorld(skeleton, update); } } } /** The world rotation for the X axis, calculated using {@link a} and {@link c}. This is the direction the bone is * pointing. */ getWorldRotationX() { return MathUtils.atan2Deg(this.c, this.a); } /** The world rotation for the Y axis, calculated using {@link b} and {@link d}. */ getWorldRotationY() { return MathUtils.atan2Deg(this.d, this.b); } /** The magnitude (always positive) of the world scale X, calculated using {@link a} and {@link c}. */ getWorldScaleX() { return Math.sqrt(this.a * this.a + this.c * this.c); } /** The magnitude (always positive) of the world scale Y, calculated using {@link b} and {@link d}. */ getWorldScaleY() { return Math.sqrt(this.b * this.b + this.d * this.d); } // public Matrix3 getWorldTransform (Matrix3 worldTransform) { // if (worldTransform == null) throw new IllegalArgumentException("worldTransform cannot be null."); // float[] val = worldTransform.val; // val[M00] = a; // val[M01] = b; // val[M10] = c; // val[M11] = d; // val[M02] = worldX; // val[M12] = worldY; // val[M20] = 0; // val[M21] = 0; // val[M22] = 1; // return worldTransform; // } /** Transforms a point from world coordinates to the bone's local coordinates. */ worldToLocal(world) { if (world == null) throw new Error("world cannot be null."); const det = this.a * this.d - this.b * this.c; const x = world.x - this.worldX, y = world.y - this.worldY; world.x = (x * this.d - y * this.b) / det; world.y = (y * this.a - x * this.c) / det; return world; } /** Transforms a point from the bone's local coordinates to world coordinates. */ localToWorld(local) { if (local == null) throw new Error("local cannot be null."); const 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; } /** Transforms a point from world coordinates to the parent bone's local coordinates. */ worldToParent(world) { if (world == null) throw new Error("world cannot be null."); return this.bone.parent == null ? world : this.bone.parent.appliedPose.worldToLocal(world); } /** Transforms a point from the parent bone's coordinates to world coordinates. */ parentToWorld(world) { if (world == null) throw new Error("world cannot be null."); return this.bone.parent == null ? world : this.bone.parent.appliedPose.localToWorld(world); } /** Transforms a world rotation to a local rotation. */ worldToLocalRotation(worldRotation) { worldRotation *= MathUtils.degRad; const sin = Math.sin(worldRotation), cos = Math.cos(worldRotation); return MathUtils.atan2Deg(this.a * sin - this.c * cos, this.d * cos - this.b * sin) + this.rotation - this.shearX; } /** Transforms a local rotation to a world rotation. */ localToWorldRotation(localRotation) { localRotation = (localRotation - this.rotation - this.shearX) * MathUtils.degRad; const sin = Math.sin(localRotation), cos = Math.cos(localRotation); return MathUtils.atan2Deg(cos * this.c + sin * this.d, cos * this.a + sin * this.b); } /** Rotates the world transform the specified amount. */ rotateWorld(degrees) { degrees *= MathUtils.degRad; const sin = Math.sin(degrees), cos = Math.cos(degrees); const ra = this.a, rb = this.b; this.a = cos * ra - sin * this.c; this.b = cos * rb - sin * this.d; this.c = sin * ra + cos * this.c; this.d = sin * rb + cos * this.d; } }; // spine-core/src/Posed.ts var Posed = class { /** The constraint's setup pose data. */ data; pose; constrainedPose; appliedPose; constructor(data, pose, constrainedPose) { if (data == null) throw new Error("data cannot be null."); this.data = data; this.pose = pose; this.constrainedPose = constrainedPose; this.appliedPose = pose; } /** Sets the unconstrained pose to the setup pose. */ setupPose() { this.pose.set(this.data.setupPose); } /** The setup pose data. May be shared with multiple instances. */ getData() { return this.data; } /** The unconstrained pose for this object, set by animations and application code. */ getPose() { return this.pose; } /** The pose to use for rendering. If no constraints modify this pose, this is the same as {@link pose}. Otherwise it is a * copy of {@link pose} modified by constraints. */ getAppliedPose() { return this.appliedPose; } /** Sets the applied pose to the unconstrained pose, for when no constraints will modify the pose. */ unconstrained() { this.appliedPose = this.pose; } /** Sets the applied pose to the constrained pose, in anticipation of the applied pose being modified by constraints. */ constrained() { this.appliedPose = this.constrainedPose; } /** Sets the constrained pose to the unconstrained pose, as a starting point for constraints to be applied. */ resetConstrained() { this.constrainedPose.set(this.pose); } }; // spine-core/src/PosedActive.ts var PosedActive = class extends Posed { active = false; constructor(data, pose, constrained) { super(data, pose, constrained); this.setupPose(); } /** Returns false when this constraint won't be updated by * {@link Skeleton.updateWorldTransform} because a skin is required and the * {@link Skeleton.skin active skin} does not contain this item. See {@link Skin.bones}, {@link Skin.constraints}, * {@link PosedData.skinRequired}, and {@link Skeleton.updateCache}. */ isActive() { return this.active; } }; // spine-core/src/Bone.ts var Bone = class _Bone extends PosedActive { /** The parent bone, or null if this is the root bone. */ parent = null; /** The immediate children of this bone. */ children = []; sorted = false; constructor(data, parent) { super(data, new BonePose(), new BonePose()); this.parent = parent; this.appliedPose.bone = this; this.constrainedPose.bone = this; } /** Copy constructor. Does not copy the {@link children} bones. */ copy(parent) { const copy = new _Bone(this.data, parent); copy.pose.set(this.pose); return copy; } }; // spine-core/src/Constraint.ts var Constraint = class extends PosedActive { constructor(data, pose, constrained) { super(data, pose, constrained); } isSourceActive() { return true; } }; // spine-core/src/DrawOrder.ts var DrawOrder = class { _setupPose; /** The unconstrained draw order, set by animations and application code. */ pose; constrainedPose; /** The constrained draw order for rendering. If no constraints modify the draw order, this is the same as {@link pose}. * Otherwise it is a copy of {@link pose} modified by constraints. */ appliedPose; constructor(setupPose) { this._setupPose = setupPose; this.pose = [...setupPose]; this.constrainedPose = []; this.appliedPose = this.pose; } /** Sets the unconstrained draw order to the setup pose order. */ setupPose() { this.pose.length = this._setupPose.length; Utils.arrayCopy(this._setupPose, 0, this.pose, 0, this._setupPose.length); } /** Sets the applied pose to the unconstrained pose, for when no constraints will modify the draw order. */ unconstrained() { this.appliedPose = this.pose; } /** Sets the applied pose to the constrained pose, in anticipation of the applied pose being modified by constraints. */ constrained() { this.appliedPose = this.constrainedPose; } /** Copies the unconstrained pose to the constrained pose, as a starting point for constraints to be applied. */ resetConstrained() { this.constrainedPose.length = this.pose.length; Utils.arrayCopy(this.pose, 0, this.constrainedPose, 0, this.pose.length); } }; // spine-core/src/ConstraintData.ts var ConstraintData = class extends PosedData { constructor(name, setup) { super(name, setup); } }; var ScaleYMode = /* @__PURE__ */ ((ScaleYMode2) => { ScaleYMode2[ScaleYMode2["None"] = 0] = "None"; ScaleYMode2[ScaleYMode2["Uniform"] = 1] = "Uniform"; ScaleYMode2[ScaleYMode2["Volume"] = 2] = "Volume"; return ScaleYMode2; })(ScaleYMode || {}); // spine-core/src/Event.ts var Event = class { /** The animation time this event was keyed, or -1 for the setup pose. */ time = 0; data; /** The integer payload for this event. */ intValue = 0; /** The float payload for this event. */ floatValue = 0; stringValue = null; /** If an audio path is set, the volume for the audio. */ volume = 0; /** If an audio path is set, the left/right balance for the audio. */ balance = 0; constructor(time, data) { if (!data) throw new Error("data cannot be null."); this.time = time; this.data = data; } }; // spine-core/src/EventData.ts var EventData = class { /** The name of the event, unique across all events in the skeleton. * * See {@link SkeletonData.findEvent}. */ name; _audioPath = null; /** Path to an audio file relative to the audio folder as defined in Spine. */ get audioPath() { return this._audioPath; } set audioPath(audioPath) { if (audioPath == null) throw new Error("audioPath cannot be null."); this._audioPath = audioPath; } /** The setup values that are shared by all events with this data. */ setupPose = new Event(-1, this); constructor(name) { this.name = name; } }; // spine-core/src/IkConstraintPose.ts var IkConstraintPose = class { /** For two bone IK, controls the bend direction of the IK bones, either 1 or -1. */ bendDirection = 0; /** For one bone IK, when true and the target is too close, the bone is scaled to reach it. */ compress = false; /** When true and the target is out of range, the parent bone is scaled to reach it. * * For two bone IK: 1) the child bone's local Y translation is set to 0, 2) stretch is not applied if {@link softness} is > 0, * and 3) if the parent bone has local nonuniform scale, stretch is not applied. */ stretch = false; /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. * * For two bone IK: if the parent bone has local nonuniform scale, the child bone's local Y translation is set to 0. */ mix = 0; /** For two bone IK, the target bone's distance from the maximum reach of the bones where rotation begins to slow. The bones * will not straighten completely until the target is this far out of range. */ softness = 0; set(pose) { this.mix = pose.mix; this.softness = pose.softness; this.bendDirection = pose.bendDirection; this.compress = pose.compress; this.stretch = pose.stretch; } }; // spine-core/src/IkConstraint.ts var IkConstraint = class _IkConstraint extends Constraint { /** The 1 or 2 bones that will be modified by this IK constraint. */ bones; /** The bone that is the IK target. */ target; constructor(data, skeleton) { super(data, new IkConstraintPose(), new IkConstraintPose()); if (!skeleton) throw new Error("skeleton cannot be null."); this.bones = []; for (const boneData of data.bones) this.bones.push(skeleton.bones[boneData.index].constrainedPose); this.target = skeleton.bones[data.target.index]; } copy(skeleton) { var copy = new _IkConstraint(this.data, skeleton); copy.pose.set(this.pose); return copy; } update(skeleton, physics) { const p = this.appliedPose; if (p.mix === 0) return; const target = this.target.appliedPose; const bones = this.bones; switch (bones.length) { case 1: _IkConstraint.apply(skeleton, bones[0], target.worldX, target.worldY, p.compress, p.stretch, this.data.scaleYMode, p.mix); break; case 2: _IkConstraint.apply( skeleton, bones[0], bones[1], target.worldX, target.worldY, p.bendDirection, p.stretch, this.data.scaleYMode, p.softness, p.mix ); break; } } sort(skeleton) { skeleton.sortBone(this.target); const parent = this.bones[0].bone; skeleton.sortBone(parent); skeleton._updateCache.push(this); parent.sorted = false; skeleton.sortReset(parent.children); skeleton.constrained(parent); if (this.bones.length > 1) skeleton.constrained(this.bones[1].bone); } isSourceActive() { return this.target.active; } static apply(skeleton, boneOrParent, targetXorChild, targetYOrTargetX, compressOrTargetY, stretchOrBendDir, scaleYModeOrStretch, mixOrScaleYMode, softness, mix) { if (typeof targetXorChild === "number") _IkConstraint.apply1(skeleton, boneOrParent, targetXorChild, targetYOrTargetX, compressOrTargetY, stretchOrBendDir, scaleYModeOrStretch, mixOrScaleYMode); else _IkConstraint.apply2( skeleton, boneOrParent, targetXorChild, targetYOrTargetX, compressOrTargetY, stretchOrBendDir, scaleYModeOrStretch, mixOrScaleYMode, softness, mix ); } static apply1(skeleton, bone, targetX, targetY, compress, stretch, scaleYMode, mix) { bone.modifyLocal(skeleton); const p = bone.bone.parent.appliedPose; let pa = p.a, pb = p.b, pc = p.c, pd = p.d; let rotationIK = -bone.shearX - bone.rotation, tx = 0, ty = 0; switch (bone.inherit) { case 1 /* OnlyTranslation */: tx = (targetX - bone.worldX) * MathUtils.signum(skeleton.scaleX); ty = (targetY - bone.worldY) * MathUtils.signum(skeleton.scaleY); break; // biome-ignore lint/suspicious/noFallthroughSwitchClause: reference runtime case 2 /* NoRotationOrReflection */: { const s = Math.abs(pa * pd - pb * pc) / Math.max(MathUtils.epsilon, pa * pa + pc * pc); const sa = pa / skeleton.scaleX; const sc = pc / skeleton.scaleY; pb = -sc * s * skeleton.scaleX; pd = sa * s * skeleton.scaleY; rotationIK += MathUtils.atan2Deg(sc, sa); } // Fall through default: { const x = targetX - p.worldX, y = targetY - p.worldY; const d = pa * pd - pb * pc; if (Math.abs(d) <= MathUtils.epsilon) { tx = 0; ty = 0; } else { tx = (x * pd - y * pb) / d - bone.x; ty = (y * pa - x * pc) / d - bone.y; } } } rotationIK += MathUtils.atan2Deg(ty, tx); if (bone.scaleX < 0) rotationIK += 180; if (rotationIK > 180) rotationIK -= 360; else if (rotationIK <= -180) rotationIK += 360; bone.rotation += rotationIK * mix; if (compress || stretch) { switch (bone.inherit) { case 3 /* NoScale */: case 4 /* NoScaleOrReflection */: tx = targetX - bone.worldX; ty = targetY - bone.worldY; } const b = bone.bone.data.length * bone.scaleX; if (b > MathUtils.epsilon) { const dd = tx * tx + ty * ty; if (compress && dd < b * b || stretch && dd > b * b) { const s = (Math.sqrt(dd) / b - 1) * mix + 1; bone.scaleX *= s; switch (scaleYMode) { case 1 /* Uniform */: bone.scaleY *= s; break; case 2 /* Volume */: bone.scaleY /= s < 0.7 ? 0.25 + 0.642857 * s : s; } } } } } /** Applies 2 bone IK. The target is specified in the world coordinate system. * @param child A direct descendant of the parent bone. */ static apply2(skeleton, parent, child, targetX, targetY, bendDir, stretch, scaleYMode, softness, mix) { if (parent.inherit !== 0 /* Normal */ || child.inherit !== 0 /* Normal */) return; parent.modifyLocal(skeleton); child.modifyLocal(skeleton); let px = parent.x, py = parent.y, psx = parent.scaleX, psy = parent.scaleY, csx = child.scaleX; let 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; let cwx = 0, cwy = 0, a = parent.a, b = parent.b, c = parent.c, d = parent.d; const u = Math.abs(psx - psy) <= MathUtils.epsilon; if (!u || stretch) { child.y = 0; cwx = a * child.x + parent.worldX; cwy = c * child.x + parent.worldY; } else { cwx = a * child.x + b * child.y + parent.worldX; cwy = c * child.x + d * child.y + parent.worldY; } const pp = parent.bone.parent.appliedPose; a = pp.a; b = pp.b; c = pp.c; d = pp.d; let id = a * d - b * c, x = cwx - pp.worldX, y = cwy - pp.worldY; id = Math.abs(id) <= MathUtils.epsilon ? 0 : 1 / id; const dx = (x * d - y * b) * id - px, dy = (y * a - x * c) * id - py; let l1 = Math.sqrt(dx * dx + dy * dy), l2 = child.bone.data.length * csx, a1, a2; if (l1 < MathUtils.epsilon) { _IkConstraint.apply(skeleton, parent, targetX, targetY, false, stretch, 0 /* None */, mix); child.rotation = 0; return; } x = targetX - pp.worldX; y = targetY - pp.worldY; let tx = (x * d - y * b) * id - px, ty = (y * a - x * c) * id - py; let dd = tx * tx + ty * ty; if (softness !== 0) { softness *= psx * (csx + 1) * 0.5; const td = Math.sqrt(dd), sd = td - l1 - l2 * psx + softness; if (sd > 0) { let p = Math.min(1, sd / (softness * 2)) - 1; p = (sd - softness * (1 - p * p)) / td; tx -= p * tx; ty -= p * ty; dd = tx * tx + ty * ty; } } outer: if (u) { l2 *= psx; let cos = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2); if (cos < -1) { cos = -1; a2 = Math.PI * bendDir; } else if (cos > 1) { cos = 1; a2 = 0; if (stretch) { a = (Math.sqrt(dd) / (l1 + l2) - 1) * mix + 1; parent.scaleX *= a; switch (scaleYMode) { case 1 /* Uniform */: parent.scaleY *= a; break; case 2 /* Volume */: parent.scaleY /= a < 0.7 ? 0.25 + 0.642857 * a : a; } } } else 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; const aa = a * a, bb = b * b, ta = Math.atan2(ty, tx); c = bb * l1 * l1 + aa * dd - aa * bb; const c1 = -2 * bb * l1, c2 = bb - aa; d = c1 * c1 - 4 * c2 * c; if (d >= 0) { let q = Math.sqrt(d); if (c1 < 0) q = -q; q = -(c1 + q) * 0.5; let r0 = q / c2, r1 = c / q; const r = Math.abs(r0) < Math.abs(r1) ? r0 : r1; r0 = dd - r * r; if (r0 >= 0) { y = Math.sqrt(r0) * bendDir; a1 = ta - Math.atan2(y, r); a2 = Math.atan2(y / psy, (r - l1) / psx); break outer; } } let minAngle = MathUtils.PI, minX = l1 - a, minDist = minX * minX, minY = 0; let 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) * 0.5) { a1 = ta - Math.atan2(minY * bendDir, minX); a2 = minAngle * bendDir; } else { a1 = ta - Math.atan2(maxY * bendDir, maxX); a2 = maxAngle * bendDir; } } const os = Math.atan2(child.y, child.x) * s2; a1 = (a1 - os) * MathUtils.radDeg + os1 - parent.rotation; if (a1 > 180) a1 -= 360; else if (a1 <= -180) a1 += 360; parent.rotation += a1 * mix; a2 = ((a2 + os) * MathUtils.radDeg - child.shearX) * s2 + os2 - child.rotation; if (a2 > 180) a2 -= 360; else if (a2 <= -180) a2 += 360; child.rotation += a2 * mix; } }; // spine-core/src/IkConstraintData.ts var IkConstraintData = class extends ConstraintData { /** The bones that are constrained by this IK constraint. */ bones = []; _target = null; /** The bone that is the IK target. */ set target(boneData) { this._target = boneData; } get target() { if (!this._target) throw new Error("target cannot be null."); return this._target; } /** Determines how the {@link BonePose.scaleY} changes when {@link IkConstraintPose.compress} or * {@link IkConstraintPose.stretch} set {@link BonePose.scaleX}. */ _scaleYMode = 0 /* None */; set scaleYMode(scaleYMode) { this._scaleYMode = scaleYMode; } get scaleYMode() { if (this._scaleYMode == null) throw new Error("scaleYMode cannot be null."); return this._scaleYMode; } constructor(name) { super(name, new IkConstraintPose()); } create(skeleton) { return new IkConstraint(this, skeleton); } }; // spine-core/src/PathConstraintPose.ts var PathConstraintPose = class { /** The position along the path. */ position = 0; /** The spacing between bones. */ spacing = 0; /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. */ mixRotate = 0; /** A percentage (0-1) that controls the mix between the constrained and unconstrained translation X. */ mixX = 0; /** A percentage (0-1) that controls the mix between the constrained and unconstrained translation Y. */ mixY = 0; set(pose) { this.position = pose.position; this.spacing = pose.spacing; this.mixRotate = pose.mixRotate; this.mixX = pose.mixX; this.mixY = pose.mixY; } }; // spine-core/src/PathConstraintData.ts var PathConstraintData = class extends ConstraintData { /** The bones that will be modified by this path constraint. */ bones = []; /** The slot whose path attachment will be used to constrained the bones. */ set slot(slotData) { this._slot = slotData; } get slot() { if (!this._slot) throw new Error("SlotData not set."); else return this._slot; } _slot = null; /** The mode for positioning the first bone on the path. */ positionMode = 0 /* Fixed */; /** The mode for positioning the bones after the first bone on the path. */ spacingMode = 1 /* Fixed */; /** The mode for adjusting the rotation of the bones. */ rotateMode = 1 /* Chain */; /** An offset added to the constrained bone rotation. */ offsetRotation = 0; constructor(name) { super(name, new PathConstraintPose()); } create(skeleton) { return new PathConstraint(this, skeleton); } }; var PositionMode = /* @__PURE__ */ ((PositionMode2) => { PositionMode2[PositionMode2["Fixed"] = 0] = "Fixed"; PositionMode2[PositionMode2["Percent"] = 1] = "Percent"; return PositionMode2; })(PositionMode || {}); var SpacingMode = /* @__PURE__ */ ((SpacingMode2) => { SpacingMode2[SpacingMode2["Length"] = 0] = "Length"; SpacingMode2[SpacingMode2["Fixed"] = 1] = "Fixed"; SpacingMode2[SpacingMode2["Percent"] = 2] = "Percent"; SpacingMode2[SpacingMode2["Proportional"] = 3] = "Proportional"; return SpacingMode2; })(SpacingMode || {}); var RotateMode = /* @__PURE__ */ ((RotateMode2) => { RotateMode2[RotateMode2["Tangent"] = 0] = "Tangent"; RotateMode2[RotateMode2["Chain"] = 1] = "Chain"; RotateMode2[RotateMode2["ChainScale"] = 2] = "ChainScale"; return RotateMode2; })(RotateMode || {}); // spine-core/src/PathConstraint.ts var PathConstraint = class _PathConstraint extends Constraint { static NONE = -1; static BEFORE = -2; static AFTER = -3; /** The path constraint's setup pose data. */ data; /** The bones that will be modified by this path constraint. */ bones; /** The slot whose path attachment will be used to constrained the bones. */ slot; spaces = []; positions = []; world = []; curves = []; lengths = []; segments = []; constructor(data, skeleton) { super(data, new PathConstraintPose(), new PathConstraintPose()); if (!skeleton) throw new Error("skeleton cannot be null."); this.data = data; this.bones = []; for (const boneData of this.data.bones) this.bones.push(skeleton.bones[boneData.index].constrainedPose); this.slot = skeleton.slots[data.slot.index]; } copy(skeleton) { var copy = new _PathConstraint(this.data, skeleton); copy.pose.set(this.pose); return copy; } update(skeleton, physics) { const attachment = this.slot.appliedPose.attachment; if (!(attachment instanceof PathAttachment)) return; const p = this.appliedPose; const mixRotate = p.mixRotate, mixX = p.mixX, mixY = p.mixY; if (mixRotate === 0 && mixX === 0 && mixY === 0) return; const data = this.data; const tangents = data.rotateMode === 0 /* Tangent */, scale = data.rotateMode === 2 /* ChainScale */; const bones = this.bones; const boneCount = bones.length, spacesCount = tangents ? boneCount : boneCount + 1; const spaces = Utils.setArraySize(this.spaces, spacesCount), lengths = scale ? this.lengths = Utils.setArraySize(this.lengths, boneCount) : []; const spacing = p.spacing; switch (data.spacingMode) { case 2 /* Percent */: if (scale) { for (let i = 0, n = spacesCount - 1; i < n; i++) { const bone = bones[i]; const setupLength = bone.bone.data.length; const x = setupLength * bone.a, y = setupLength * bone.c; lengths[i] = Math.sqrt(x * x + y * y); } } Utils.arrayFill(spaces, 1, spacesCount, spacing); break; case 3 /* Proportional */: { let sum = 0; for (let i = 0, n = spacesCount - 1; i < n; ) { const bone = bones[i]; const setupLength = bone.bone.data.length; if (setupLength < MathUtils.epsilon) { if (scale) lengths[i] = 0; spaces[++i] = spacing; } else { const x = setupLength * bone.a, y = setupLength * bone.c; const length = Math.sqrt(x * x + y * y); if (scale) lengths[i] = length; spaces[++i] = length; sum += length; } } if (sum > 0) { sum = spacesCount / sum * spacing; for (let i = 1; i < spacesCount; i++) spaces[i] *= sum; } break; } default: { const lengthSpacing = data.spacingMode === 0 /* Length */; for (let i = 0, n = spacesCount - 1; i < n; ) { const bone = bones[i]; const setupLength = bone.bone.data.length; if (setupLength < MathUtils.epsilon) { if (scale) lengths[i] = 0; spaces[++i] = spacing; } else { const x = setupLength * bone.a, y = setupLength * bone.c; const length = Math.sqrt(x * x + y * y); if (scale) lengths[i] = length; spaces[++i] = (lengthSpacing ? Math.max(0, setupLength + spacing) : spacing) * length / setupLength; } } } } const positions = this.computeWorldPositions(skeleton, attachment, spacesCount, tangents); let boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation; let tip = false; if (offsetRotation === 0) tip = data.rotateMode === 1 /* Chain */; else { tip = false; const bone = this.slot.bone.appliedPose; offsetRotation *= bone.a * bone.d - bone.b * bone.c > 0 ? MathUtils.degRad : -MathUtils.degRad; } for (let i = 0, ip = 3; i < boneCount; i++, ip += 3) { const bone = bones[i]; bone.modifyWorld(skeleton); bone.worldX += (boneX - bone.worldX) * mixX; bone.worldY += (boneY - bone.worldY) * mixY; const x = positions[ip], y = positions[ip + 1], dx = x - boneX, dy = y - boneY; if (scale) { const length = lengths[i]; if (length !== 0) { const s = (Math.sqrt(dx * dx + dy * dy) / length - 1) * mixRotate + 1; bone.a *= s; bone.c *= s; } } boneX = x; boneY = y; if (mixRotate > 0) { let a = bone.a, b = bone.b, c = bone.c, d = bone.d, r = 0, cos = 0, sin = 0; if (tangents) r = positions[ip - 1]; else if (spaces[i + 1] === 0) r = positions[ip + 2]; else r = Math.atan2(dy, dx); r -= Math.atan2(c, a); if (tip) { cos = Math.cos(r); sin = Math.sin(r); const length = bone.bone.data.length; boneX += (length * (cos * a - sin * c) - dx) * mixRotate; boneY += (length * (sin * a + cos * c) - dy) * mixRotate; } else { r += offsetRotation; } if (r > MathUtils.PI) r -= MathUtils.PI2; else if (r < -MathUtils.PI) r += MathUtils.PI2; r *= mixRotate; 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; } } } computeWorldPositions(skeleton, path, spacesCount, tangents) { const slot = this.slot; let position = this.appliedPose.position; let spaces = this.spaces, out = Utils.setArraySize(this.positions, spacesCount * 3 + 2), world = this.world; const closed = path.closed; let verticesLength = path.worldVerticesLength, curveCount = verticesLength / 6, prevCurve = _PathConstraint.NONE; if (!path.constantSpeed) { const lengths = path.lengths; curveCount -= closed ? 1 : 2; const pathLength2 = lengths[curveCount]; if (this.data.positionMode === 1 /* Percent */) position *= pathLength2; let multiplier2; switch (this.data.spacingMode) { case 2 /* Percent */: multiplier2 = pathLength2; break; case 3 /* Proportional */: multiplier2 = pathLength2 / spacesCount; break; default: multiplier2 = 1; } world = Utils.setArraySize(this.world, 8); for (let i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) { const space = spaces[i] * multiplier2; position += space; let p = position; if (closed) { p %= pathLength2; if (p < 0) p += pathLength2; curve = 0; } else if (p < 0) { if (prevCurve !== _PathConstraint.BEFORE) { prevCurve = _PathConstraint.BEFORE; path.computeWorldVertices(skeleton, slot, 2, 4, world, 0, 2); } this.addBeforePosition(p, world, 0, out, o); continue; } else if (p > pathLength2) { if (prevCurve !== _PathConstraint.AFTER) { prevCurve = _PathConstraint.AFTER; path.computeWorldVertices(skeleton, slot, verticesLength - 6, 4, world, 0, 2); } this.addAfterPosition(p - pathLength2, world, 0, out, o); continue; } for (; ; curve++) { const length = lengths[curve]; if (p > length) continue; if (curve === 0) p /= length; else { const prev = lengths[curve - 1]; p = (p - prev) / (length - prev); } break; } if (curve !== prevCurve) { prevCurve = curve; if (closed && curve === curveCount) { path.computeWorldVertices(skeleton, slot, verticesLength - 4, 4, world, 0, 2); path.computeWorldVertices(skeleton, slot, 0, 4, world, 4, 2); } else path.computeWorldVertices(skeleton, slot, 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 = Utils.setArraySize(this.world, verticesLength); path.computeWorldVertices(skeleton, slot, 2, verticesLength - 4, world, 0, 2); path.computeWorldVertices(skeleton, slot, 0, 2, world, verticesLength - 4, 2); world[verticesLength - 2] = world[0]; world[verticesLength - 1] = world[1]; } else { curveCount--; verticesLength -= 4; world = Utils.setArraySize(this.world, verticesLength); path.computeWorldVertices(skeleton, slot, 2, verticesLength, world, 0, 2); } const curves = Utils.setArraySize(this.curves, curveCount); let pathLength = 0; let x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0; let tmpx = 0, tmpy = 0, dddfx = 0, dddfy = 0, ddfx = 0, ddfy = 0, dfx = 0, dfy = 0; for (let 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 (this.data.positionMode === 1 /* Percent */) position *= pathLength; let multiplier; switch (this.data.spacingMode) { case 2 /* Percent */: multiplier = pathLength; break; case 3 /* Proportional */: multiplier = pathLength / spacesCount; break; default: multiplier = 1; } const segments = this.segments; let curveLength = 0; for (let i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) { const space = spaces[i] * multiplier; position += space; let p = position; if (closed) { p %= pathLength; if (p < 0) p += pathLength; curve = 0; segment = 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++) { const length = curves[curve]; if (p > length) continue; if (curve === 0) p /= length; else { const prev = curves[curve - 1]; p = (p - prev) / (length - prev); } break; } if (curve !== prevCurve) { prevCurve = curve; let 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) * 6e-3; dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 6e-3; 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++) { const length = segments[segment]; if (p > length) continue; if (segment === 0) p /= length; else { const prev = segments[segment - 1]; p = segment + (p - prev) / (length - prev); } break; } this.addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || i > 0 && space === 0); } return out; } addBeforePosition(p, temp, i, out, o) { const 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; } addAfterPosition(p, temp, i, out, o) { const 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; } addCurvePosition(p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents) { if (p === 0 || Number.isNaN(p)) { out[o] = x1; out[o + 1] = y1; out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1); return; } const tt = p * p, ttt = tt * p, u = 1 - p, uu = u * u, uuu = uu * u; const ut = u * p, ut3 = ut * 3, uut3 = u * ut3, utt3 = ut3 * p; const 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 < 1e-3) 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)); } } sort(skeleton) { const slotIndex = this.slot.data.index; const slotBone = this.slot.bone; if (skeleton.skin != null) this.sortPathSlot(skeleton, skeleton.skin, slotIndex, slotBone); if (skeleton.data.defaultSkin != null && skeleton.data.defaultSkin !== skeleton.skin) this.sortPathSlot(skeleton, skeleton.data.defaultSkin, slotIndex, slotBone); this.sortPath(skeleton, this.slot.pose.attachment, slotBone); const bones = this.bones; const boneCount = this.bones.length; for (let i = 0; i < boneCount; i++) { const bone = bones[i].bone; skeleton.sortBone(bone); skeleton.constrained(bone); } skeleton._updateCache.push(this); for (let i = 0; i < boneCount; i++) skeleton.sortReset(bones[i].bone.children); for (let i = 0; i < boneCount; i++) bones[i].bone.sorted = true; } sortPathSlot(skeleton, skin, slotIndex, slotBone) { const entries = skin.getAttachments(); for (let i = 0, n = entries.length; i < n; i++) { const entry = entries[i]; if (entry.slotIndex === slotIndex) this.sortPath(skeleton, entry.attachment, slotBone); } } sortPath(skeleton, attachment, slotBone) { if (!(attachment instanceof PathAttachment)) return; const pathBones = attachment.bones; if (pathBones == null) skeleton.sortBone(slotBone); else { const bones = skeleton.bones; for (let i = 0, n = pathBones.length; i < n; ) { let nn = pathBones[i++]; nn += i; while (i < nn) skeleton.sortBone(bones[pathBones[i++]]); } } } isSourceActive() { return this.slot.bone.active; } }; // spine-core/src/Physics.ts var Physics = /* @__PURE__ */ ((Physics2) => { Physics2[Physics2["none"] = 0] = "none"; Physics2[Physics2["reset"] = 1] = "reset"; Physics2[Physics2["update"] = 2] = "update"; Physics2[Physics2["pose"] = 3] = "pose"; return Physics2; })(Physics || {}); // spine-core/src/PhysicsConstraintPose.ts var PhysicsConstraintPose = class { /** Controls how much bone movement is converted into physics movement. */ inertia = 0; /** The amount of force used to return properties to the unconstrained value. */ strength = 0; /** Reduces the speed of physics movements, with more of a reduction at higher speeds. */ damping = 0; /** Determines susceptibility to acceleration. */ massInverse = 0; /** Applies a constant force along the {@link Skeleton.windX}, {@link Skeleton.windY} vector. */ wind = 0; /** Applies a constant force along the {@link Skeleton.gravityX}, {@link Skeleton.gravityY} vector. */ gravity = 0; /** A percentage (0+) that controls the mix between the constrained and unconstrained poses. */ mix = 0; set(pose) { this.inertia = pose.inertia; this.strength = pose.strength; this.damping = pose.damping; this.massInverse = pose.massInverse; this.wind = pose.wind; this.gravity = pose.gravity; this.mix = pose.mix; } }; // spine-core/src/SlotPose.ts var SlotPose = class { /** The color used to tint the slot's attachment. If {@link darkColor} is set, this is used as the light color for two color * tinting. */ color = new Color(1, 1, 1, 1); /** The dark color used to tint the slot's attachment for two color tinting, or null if two color tinting is not used. The dark * color's alpha is not used. */ darkColor = null; /** The current attachment for the slot, or null if the slot has no attachment. */ attachment = null; // Not used in setup pose. /** The index of the texture region to display when the slot's attachment has a {@link Sequence}. -1 represents the * {@link Sequence.getSetupIndex}. */ sequenceIndex = 0; /** Values to deform the slot's attachment. For an unweighted mesh, the entries are local positions for each vertex. For a * weighted mesh, the entries are an offset for each vertex which will be added to the mesh's local vertex positions. * * See {@link VertexAttachment.computeWorldVertices} and * {@link DeformTimeline}. */ deform = []; SlotPose() { } set(pose) { if (pose == null) throw new Error("pose cannot be null."); this.color.setFromColor(pose.color); if (this.darkColor != null && pose.darkColor != null) this.darkColor.setFromColor(pose.darkColor); this.attachment = pose.attachment; this.sequenceIndex = pose.sequenceIndex; this.deform.length = 0; this.deform.push(...pose.deform); } /** The current attachment for the slot, or null if the slot has no attachment. */ getAttachment() { return this.attachment; } /** Sets the slot's attachment and, if the attachment changed, resets {@link sequenceIndex} and clears the {@link deform}. * The deform is not cleared if the old attachment has the same {@link VertexAttachment.getTimelineAttachment} as the * specified attachment. */ setAttachment(attachment) { if (this.attachment === attachment) return; if (!(attachment instanceof VertexAttachment) || !(this.attachment instanceof VertexAttachment) || attachment.timelineAttachment !== this.attachment.timelineAttachment) { this.deform.length = 0; } this.attachment = attachment; this.sequenceIndex = -1; } }; // spine-core/src/Slot.ts var Slot = class _Slot extends Posed { skeleton; /** The bone this slot belongs to. */ bone; attachmentState = 0; constructor(data, skeleton) { super(data, new SlotPose(), new SlotPose()); if (!skeleton) throw new Error("skeleton cannot be null."); this.skeleton = skeleton; this.bone = skeleton.bones[data.boneData.index]; if (data.setupPose.darkColor != null) { this.pose.darkColor = new Color(); this.constrainedPose.darkColor = new Color(); } this.setupPose(); } /** Copy constructor. */ copy(slot, bone, skeleton) { const copy = new _Slot(slot.data, this.skeleton); if (this.data.setupPose.darkColor != null) { copy.pose.darkColor = new Color(); copy.constrainedPose.darkColor = new Color(); } copy.pose.set(slot.pose); return copy; } setupPose() { this.pose.color.setFromColor(this.data.setupPose.color); if (this.pose.darkColor) this.pose.darkColor.setFromColor(this.data.setupPose.darkColor); this.pose.sequenceIndex = this.data.setupPose.sequenceIndex; if (!this.data.attachmentName) this.pose.setAttachment(null); else { this.pose.attachment = null; this.pose.setAttachment(this.skeleton.getAttachment(this.data.index, this.data.attachmentName)); } } }; // spine-core/src/Skeleton.ts var Skeleton = class _Skeleton { static quadTriangles = [0, 1, 2, 2, 3, 0]; static yDown = false; static get yDir() { return _Skeleton.yDown ? -1 : 1; } /** The skeleton's setup pose data. */ data; /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */ bones; /** The skeleton's slots. To add a slot, also add it to {@link DrawOrder.pose}. */ slots; /** The skeleton's draw order. Use {@link DrawOrder.appliedPose} for rendering and {@link DrawOrder.pose} for changing the draw * order. */ drawOrder; /** The skeleton's constraints. */ // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types constraints; /** The skeleton's physics constraints. */ physics; /** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link updateCache}. */ // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types _updateCache = []; // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types resetCache = []; /** The skeleton's current skin. May be null. */ skin = null; /** The color to tint all the skeleton's attachments. */ color; /** Scales the entire skeleton on the X axis. * * Bones that do not inherit scale are still affected by this property. */ scaleX = 1; _scaleY = 1; /** Scales the entire skeleton on the Y axis. * * Bones that do not inherit scale are still affected by this property. */ get scaleY() { return this._scaleY * _Skeleton.yDir; } set scaleY(scaleY) { this._scaleY = scaleY; } /** Sets the skeleton X position, which is added to the root bone worldX position. * * Bones that do not inherit translation are still affected by this property. */ x = 0; /** Sets the skeleton Y position, which is added to the root bone worldY position. * * Bones that do not inherit translation are still affected by this property. */ y = 0; /** Returns the skeleton's time, is used for time-based manipulations, such as {@link PhysicsConstraint}. * * See {@link _update}. */ time = 0; /** The x component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */ windX = 1; /** The y component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */ windY = 0; /** The x component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */ gravityX = 0; /** The y component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */ gravityY = 1; _update = 0; constructor(data) { if (!data) throw new Error("data cannot be null."); this.data = data; this.bones = []; for (let i = 0; i < data.bones.length; i++) { const boneData = data.bones[i]; let bone; if (!boneData.parent) bone = new Bone(boneData, null); else { const parent = this.bones[boneData.parent.index]; bone = new Bone(boneData, parent); parent.children.push(bone); } this.bones.push(bone); } this.slots = []; for (const slotData of this.data.slots) this.slots.push(new Slot(slotData, this)); this.drawOrder = new DrawOrder(this.slots); this.physics = []; this.constraints = []; for (const constraintData of this.data.constraints) { const constraint = constraintData.create(this); if (constraint instanceof PhysicsConstraint) this.physics.push(constraint); this.constraints.push(constraint); } this.color = new Color(1, 1, 1, 1); this.updateCache(); } /** Caches information about bones and constraints. Must be called if the {@link skin} is modified or if bones, constraints, * or weighted path attachments are added or removed. */ updateCache() { this._updateCache.length = 0; this.resetCache.length = 0; this.drawOrder.unconstrained(); const slots = this.slots; for (let i = 0, n2 = slots.length; i < n2; i++) slots[i].unconstrained(); const bones = this.bones; const boneCount = bones.length; for (let i = 0, n2 = boneCount; i < n2; i++) { const bone = bones[i]; bone.sorted = bone.data.skinRequired; bone.active = !bone.sorted; bone.unconstrained(); } if (this.skin) { const skinBones = this.skin.bones; for (let i = 0, n2 = this.skin.bones.length; i < n2; i++) { let bone = this.bones[skinBones[i].index]; do { bone.sorted = false; bone.active = true; bone = bone.parent; } while (bone); } } const constraints = this.constraints; let n = this.constraints.length; for (let i = 0; i < n; i++) constraints[i].unconstrained(); for (let i = 0; i < n; i++) { const constraint = constraints[i]; constraint.active = constraint.isSourceActive() && (!constraint.data.skinRequired || this.skin != null && this.skin.constraints.includes(constraint.data)); if (constraint.active) constraint.sort(this); } for (let i = 0; i < boneCount; i++) this.sortBone(bones[i]); n = this._updateCache.length; for (let i = 0; i < n; i++) { const updateable = this._updateCache[i]; if (updateable instanceof Bone) this._updateCache[i] = updateable.appliedPose; } } // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types constrained(object) { if (object.pose === object.appliedPose) { object.constrained(); this.resetCache.push(object); } } sortBone(bone) { if (bone.sorted || !bone.active) return; const parent = bone.parent; if (parent) this.sortBone(parent); bone.sorted = true; this._updateCache.push(bone); } sortReset(bones) { for (let i = 0, n = bones.length; i < n; i++) { const bone = bones[i]; if (bone.active) { if (bone.sorted) this.sortReset(bone.children); bone.sorted = false; } } } /** Updates the world transform for each bone and applies all constraints. * * See World transforms in the Spine * Runtimes Guide. */ updateWorldTransform(physics) { this._update++; if (this.drawOrder.appliedPose === this.drawOrder.constrainedPose) this.drawOrder.resetConstrained(); const resetCache = this.resetCache; for (let i = 0, n = this.resetCache.length; i < n; i++) resetCache[i].resetConstrained(); const updateCache = this._updateCache; for (let i = 0, n = this._updateCache.length; i < n; i++) updateCache[i].update(this, physics); } /** Sets the bones, constraints, and slots to their setup pose values. */ setupPose() { this.setupPoseBones(); this.setupPoseSlots(); } /** Sets the bones and constraints to their setup pose values. */ setupPoseBones() { const bones = this.bones; for (let i = 0, n = bones.length; i < n; i++) bones[i].setupPose(); const constraints = this.constraints; for (let i = 0, n = constraints.length; i < n; i++) constraints[i].setupPose(); } /** Sets the slots and draw order to their setup pose values. */ setupPoseSlots() { this.drawOrder.setupPose(); const slots = this.slots; for (let i = 0, n = slots.length; i < n; i++) slots[i].setupPose(); } /** Returns the root bone, or null if the skeleton has no bones. */ getRootBone() { if (this.bones.length === 0) return null; return this.bones[0]; } /** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it * repeatedly. */ findBone(boneName) { if (!boneName) throw new Error("boneName cannot be null."); const bones = this.bones; for (let i = 0, n = bones.length; i < n; i++) if (bones[i].data.name === boneName) return bones[i]; return null; } /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it * repeatedly. */ findSlot(slotName) { if (!slotName) throw new Error("slotName cannot be null."); const slots = this.slots; for (let i = 0, n = slots.length; i < n; i++) if (slots[i].data.name === slotName) return slots[i]; return null; } setSkin(newSkin) { if (typeof newSkin === "string") this.setSkinByName(newSkin); else this.setSkinBySkin(newSkin); } setSkinByName(skinName) { const skin = this.data.findSkin(skinName); if (!skin) throw new Error(`Skin not found: ${skinName}`); this.setSkin(skin); } setSkinBySkin(newSkin) { if (newSkin === this.skin) return; if (newSkin) { if (this.skin) newSkin.attachAll(this, this.skin); else { const slots = this.slots; for (let i = 0, n = slots.length; i < n; i++) { const slot = slots[i]; const name = slot.data.attachmentName; if (name) { const attachment = newSkin.getAttachment(i, name); if (attachment) slot.pose.setAttachment(attachment); } } } } this.skin = newSkin; this.updateCache(); } getAttachment(slotNameOrIndex, placeholder) { if (typeof slotNameOrIndex === "string") return this.getAttachmentByName(slotNameOrIndex, placeholder); return this.getAttachmentByIndex(slotNameOrIndex, placeholder); } /** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot name and attachment * name. * * See {@link getAttachment}. * @returns May be null. */ getAttachmentByName(slotName, placeholder) { const slot = this.data.findSlot(slotName); if (!slot) throw new Error(`Can't find slot with name ${slotName}`); return this.getAttachment(slot.index, placeholder); } /** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot index and * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked. * * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide. * @returns May be null. */ getAttachmentByIndex(slotIndex, placeholder) { if (!placeholder) throw new Error("placeholder cannot be null."); if (this.skin) { const attachment = this.skin.getAttachment(slotIndex, placeholder); if (attachment) return attachment; } if (this.data.defaultSkin) return this.data.defaultSkin.getAttachment(slotIndex, placeholder); return null; } /** A convenience method to set an attachment by finding the slot with {@link findSlot}, finding the attachment with * {@link getAttachment}, then setting the slot's {@link Slot.attachment}. * @param placeholder May be null to clear the slot's attachment. */ setAttachment(slotName, placeholder) { if (!slotName) throw new Error("slotName cannot be null."); const slot = this.findSlot(slotName); if (!slot) throw new Error(`Slot not found: ${slotName}`); let attachment = null; if (placeholder) { attachment = this.getAttachment(slot.data.index, placeholder); if (!attachment) throw new Error(`Attachment not found: ${placeholder}, for slot: ${slotName}`); } slot.pose.setAttachment(attachment); } /** Finds a constraint of the specified type by comparing each constraints's name. It is more efficient to cache the results of * this method than to call it multiple times. */ // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types findConstraint(constraintName, type) { if (constraintName == null) throw new Error("constraintName cannot be null."); if (type == null) throw new Error("type cannot be null."); const constraints = this.constraints; for (let i = 0, n = constraints.length; i < n; i++) { const constraint = constraints[i]; if (constraint instanceof type && constraint.data.name === constraintName) return constraint; } return null; } /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose. * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB. * @param size An output value, the width and height of the AABB. * @param temp Working memory to temporarily store attachments' computed world vertices. */ getBoundsRect(clipper) { const offset = new Vector2(); const size = new Vector2(); this.getBounds(offset, size, void 0, clipper); return { x: offset.x, y: offset.y, width: size.x, height: size.y }; } /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose. Optionally applies * clipping. * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB. * @param size An output value, the width and height of the AABB. * @param temp Working memory to temporarily store attachments' computed world vertices. * @param clipper {@link SkeletonClipping} to use. If `null`, no clipping is applied. */ getBounds(offset, size, temp = new Array(2), clipper = null) { if (!offset) throw new Error("offset cannot be null."); if (!size) throw new Error("size cannot be null."); const drawOrder = this.drawOrder.appliedPose; const slots = drawOrder; let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY; for (let i = 0, n = drawOrder.length; i < n; i++) { const slot = slots[i]; if (!slot.bone.active) continue; let verticesLength = 0; let vertices = null; let triangles = null; const attachment = slot.appliedPose.attachment; if (attachment) { if (attachment instanceof RegionAttachment) { verticesLength = 8; vertices = Utils.setArraySize(temp, verticesLength, 0); attachment.computeWorldVertices(slot, attachment.getOffsets(slot.appliedPose), vertices, 0, 2); triangles = _Skeleton.quadTriangles; } else if (attachment instanceof MeshAttachment) { verticesLength = attachment.worldVerticesLength; vertices = Utils.setArraySize(temp, verticesLength, 0); attachment.computeWorldVertices(this, slot, 0, verticesLength, vertices, 0, 2); triangles = attachment.triangles; } else if (attachment instanceof ClippingAttachment && clipper) { clipper.clipEnd(slot); clipper.clipStart(this, slot, attachment); continue; } if (vertices && triangles) { if (clipper?.isClipping() && clipper.clipTriangles(vertices, triangles, triangles.length)) { vertices = clipper.clippedVertices; verticesLength = clipper.clippedVertices.length; } for (let ii = 0, nn = vertices.length; ii < nn; ii += 2) { const 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); } } } if (clipper) clipper.clipEnd(slot); } if (clipper) clipper.clipEnd(); offset.set(minX, minY); size.set(maxX - minX, maxY - minY); } /** Scales the entire skeleton on the X and Y axes. * * Bones that do not inherit scale are still affected by this property. */ setScale(scaleX, scaleY) { this.scaleX = scaleX; this.scaleY = scaleY; } /** Sets the skeleton X and Y position, which is added to the root bone worldX and worldY position. * * Bones that do not inherit translation are still affected by this property. */ setPosition(x, y) { this.x = x; this.y = y; } /** Increments the skeleton's {@link time}. */ update(delta) { this.time += delta; } /** Calls {@link PhysicsConstraint.translate} for each physics constraint. */ physicsTranslate(x, y) { const constraints = this.physics; for (let i = 0, n = constraints.length; i < n; i++) constraints[i].translate(x, y); } /** Calls {@link PhysicsConstraint.rotate} for each physics constraint. */ physicsRotate(x, y, degrees) { const constraints = this.physics; for (let i = 0, n = constraints.length; i < n; i++) constraints[i].rotate(x, y, degrees); } }; // spine-core/src/PhysicsConstraint.ts var PhysicsConstraint = class _PhysicsConstraint extends Constraint { bone; _reset = true; ux = 0; uy = 0; cx = 0; cy = 0; tx = 0; ty = 0; xOffset = 0; xLag = 0; xVelocity = 0; yOffset = 0; yLag = 0; yVelocity = 0; rotateOffset = 0; rotateLag = 0; rotateVelocity = 0; scaleOffset = 0; scaleLag = 0; scaleVelocity = 0; remaining = 0; lastTime = 0; constructor(data, skeleton) { super(data, new PhysicsConstraintPose(), new PhysicsConstraintPose()); if (skeleton == null) throw new Error("skeleton cannot be null."); this.bone = skeleton.bones[data.bone.index].constrainedPose; } copy(skeleton) { var copy = new _PhysicsConstraint(this.data, skeleton); copy.pose.set(this.pose); return copy; } /** Resets all physics state that was the result of previous movement. Use this after moving a bone to prevent physics from * reacting to the movement. */ reset(skeleton) { this.remaining = 0; this.lastTime = skeleton.time; this._reset = true; this.xOffset = 0; this.xLag = 0; this.xVelocity = 0; this.yOffset = 0; this.yLag = 0; this.yVelocity = 0; this.rotateOffset = 0; this.rotateLag = 0; this.rotateVelocity = 0; this.scaleOffset = 0; this.scaleLag = 0; this.scaleVelocity = 0; } /** Translates the physics constraint so the next {@link update} forces are applied as if the bone moved an * additional amount in world space. */ translate(x, y) { this.ux -= x; this.uy -= y; this.cx -= x; this.cy -= y; } /** Rotates the physics constraint so the next {@link update} forces are applied as if the bone rotated * around the specified point in world space. */ rotate(x, y, degrees) { const r = degrees * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r); const dx = this.cx - x, dy = this.cy - y; this.translate(dx * cos - dy * sin - dx, dx * sin + dy * cos - dy); } /** Applies the constraint to the constrained bones. */ update(skeleton, physics) { const p = this.appliedPose; const mix = p.mix; if (mix === 0) return; const x = this.data.x > 0, y = this.data.y > 0, rotateOrShearX = this.data.rotate > 0 || this.data.shearX > 0, scaleX = this.data.scaleX > 0; const bone = this.bone; let l = bone.bone.data.length, t = this.data.step, z = 0; if (physics === 0 /* none */) return; bone.modifyWorld(skeleton); switch (physics) { // biome-ignore lint/suspicious/noFallthroughSwitchClause: fall through expected case 1 /* reset */: this.reset(skeleton); // Fall through. case 2 /* update */: { const delta = Math.max(skeleton.time - this.lastTime, 0), aa = this.remaining; this.remaining += delta; this.lastTime = skeleton.time; const bx = bone.worldX, by = bone.worldY; if (this._reset) { this._reset = false; this.ux = bx; this.uy = by; } else { let a = this.remaining, i = p.inertia, f = skeleton.data.referenceScale, d = -1, m = 0, e = 0, qx = this.data.limit * delta, qy = qx * Math.abs(skeleton.scaleY); qx *= Math.abs(skeleton.scaleX); if (x || y) { if (x) { const u = (this.ux - bx) * i; this.xOffset += u > qx ? qx : u < -qx ? -qx : u; this.ux = bx; } if (y) { const u = (this.uy - by) * i; this.yOffset += u > qy ? qy : u < -qy ? -qy : u; this.uy = by; } if (a >= t) { const xs = this.xOffset, ys = this.yOffset; d = p.damping ** (60 * t); m = t * p.massInverse; e = p.strength; const w = f * p.wind, g = f * p.gravity; const ax = (w * skeleton.windX + g * skeleton.gravityX) * skeleton.scaleX; const ay = (w * skeleton.windY + g * skeleton.gravityY) * skeleton.scaleY; do { if (x) { this.xVelocity += (ax - this.xOffset * e) * m; this.xOffset += this.xVelocity * t; this.xVelocity *= d; } if (y) { this.yVelocity -= (ay + this.yOffset * e) * m; this.yOffset += this.yVelocity * t; this.yVelocity *= d; } a -= t; } while (a >= t); this.xLag = this.xOffset - xs; this.yLag = this.yOffset - ys; } z = Math.max(0, 1 - a / t); if (x) bone.worldX += (this.xOffset - this.xLag * z) * mix * this.data.x; if (y) bone.worldY += (this.yOffset - this.yLag * z) * mix * this.data.y; } if (rotateOrShearX || scaleX) { let ca = Math.atan2(bone.c, bone.a), c = 0, s = 0, mr = 0, dx = this.cx - bone.worldX, dy = this.cy - bone.worldY; if (dx > qx) dx = qx; else if (dx < -qx) dx = -qx; if (dy > qy) dy = qy; else if (dy < -qy) dy = -qy; a = this.remaining; if (rotateOrShearX) { mr = (this.data.rotate + this.data.shearX) * mix; z = this.rotateLag * Math.max(0, 1 - aa / t); let r = Math.atan2(dy + this.ty, dx + this.tx) - ca - (this.rotateOffset - z) * mr; this.rotateOffset += (r - Math.ceil(r * MathUtils.invPI2 - 0.5) * MathUtils.PI2) * i; r = (this.rotateOffset - z) * mr + ca; c = Math.cos(r); s = Math.sin(r); if (scaleX) { r = l * bone.getWorldScaleX(); if (r > 0) this.scaleOffset += (dx * c + dy * s) * i / r; } } else { c = Math.cos(ca); s = Math.sin(ca); const r = l * bone.getWorldScaleX() - this.scaleLag * Math.max(0, 1 - aa / t); if (r > 0) this.scaleOffset += (dx * c + dy * s) * i / r; } if (a >= t) { if (d === -1) { d = p.damping ** (60 * t); m = t * p.massInverse; e = p.strength; } const ax = p.wind * skeleton.windX + p.gravity * skeleton.gravityX; const ay = (p.wind * skeleton.windY + p.gravity * skeleton.gravityY) * Skeleton.yDir; const rs = this.rotateOffset, ss = this.scaleOffset, h = l / f; while (true) { a -= t; if (scaleX) { this.scaleVelocity += (ax * c - ay * s - this.scaleOffset * e) * m; this.scaleOffset += this.scaleVelocity * t; this.scaleVelocity *= d; } if (rotateOrShearX) { this.rotateVelocity -= ((ax * s + ay * c) * h + this.rotateOffset * e) * m; this.rotateOffset += this.rotateVelocity * t; this.rotateVelocity *= d; if (a < t) break; const r = this.rotateOffset * mr + ca; c = Math.cos(r); s = Math.sin(r); } else if (a < t) break; } this.rotateLag = this.rotateOffset - rs; this.scaleLag = this.scaleOffset - ss; } z = Math.max(0, 1 - a / t); } this.remaining = a; } this.cx = bone.worldX; this.cy = bone.worldY; break; } case 3 /* pose */: z = Math.max(0, 1 - this.remaining / t); if (x) bone.worldX += (this.xOffset - this.xLag * z) * mix * this.data.x; if (y) bone.worldY += (this.yOffset - this.yLag * z) * mix * this.data.y; } if (rotateOrShearX) { let o = (this.rotateOffset - this.rotateLag * z) * mix, s = 0, c = 0, a = 0; if (this.data.shearX > 0) { let r = 0; if (this.data.rotate > 0) { r = o * this.data.rotate; s = Math.sin(r); c = Math.cos(r); a = bone.b; bone.b = c * a - s * bone.d; bone.d = s * a + c * bone.d; } r += o * this.data.shearX; s = Math.sin(r); c = Math.cos(r); a = bone.a; bone.a = c * a - s * bone.c; bone.c = s * a + c * bone.c; } else { o *= this.data.rotate; s = Math.sin(o); c = Math.cos(o); a = bone.a; bone.a = c * a - s * bone.c; bone.c = s * a + c * bone.c; a = bone.b; bone.b = c * a - s * bone.d; bone.d = s * a + c * bone.d; } } if (scaleX) { let s = 1 + (this.scaleOffset - this.scaleLag * z) * mix * this.data.scaleX; bone.a *= s; bone.c *= s; switch (this.data.scaleYMode) { case 1 /* Uniform */: bone.b *= s; bone.d *= s; break; case 2 /* Volume */: s = Math.abs(s); s = s >= 0.7 ? 1 / s : 4 - 3.67347 * s; bone.b *= s; bone.d *= s; } } if (physics !== 3 /* pose */) { this.tx = l * bone.a; this.ty = l * bone.c; } } sort(skeleton) { const bone = this.bone.bone; skeleton.sortBone(bone); skeleton._updateCache.push(this); skeleton.sortReset(bone.children); skeleton.constrained(bone); } isSourceActive() { return this.bone.bone.active; } }; // spine-core/src/PhysicsConstraintData.ts var PhysicsConstraintData = class extends ConstraintData { /** The bone constrained by this physics constraint. */ set bone(boneData) { this._bone = boneData; } get bone() { if (!this._bone) throw new Error("BoneData not set."); else return this._bone; } _bone = null; /** Physics influence on x translation, 0-1. */ x = 0; /** Physics influence on y translation, 0-1. */ y = 0; /** Physics influence on rotation, 0-1. */ rotate = 0; /** Physics influence on scaleX, 0-1. */ scaleX = 0; /** Physics influence on shearX, 0-1. */ shearX = 0; /** Movement greater than the limit will not have a greater affect on physics. */ limit = 0; /** The time in milliseconds required to advanced the physics simulation one step. */ step = 0; /** True when this constraint's inertia is controlled by global slider timelines. */ inertiaGlobal = false; /** True when this constraint's strength is controlled by global slider timelines. */ strengthGlobal = false; /** True when this constraint's damping is controlled by global slider timelines. */ dampingGlobal = false; /** True when this constraint's mass is controlled by global slider timelines. */ massGlobal = false; /** True when this constraint's wind is controlled by global slider timelines. */ windGlobal = false; /** True when this constraint's gravity is controlled by global slider timelines. */ gravityGlobal = false; /** True when this constraint's mix is controlled by global slider timelines. */ mixGlobal = false; /** Determines how the {@link BonePose.scaleY} changes when {@link BonePose.scaleX} sets * {@link BonePose.scaleX}. */ _scaleYMode = 0 /* None */; get scaleYMode() { return this._scaleYMode; } set scaleYMode(scaleYMode) { if (scaleYMode == null) throw new Error("scaleYMode cannot be null."); this._scaleYMode = scaleYMode; } constructor(name) { super(name, new PhysicsConstraintPose()); } create(skeleton) { return new PhysicsConstraint(this, skeleton); } }; // spine-core/src/polyfills.ts (() => { if (typeof Math.fround === "undefined") { Math.fround = /* @__PURE__ */ ((array) => (x) => { array[0] = x; return array[0]; })(new Float32Array(1)); } })(); // spine-core/src/SliderPose.ts var SliderPose = class { /** The time in the {@link SliderData.animation} to apply the animation. */ time = 0; /** A percentage (unbounded) that controls the mix between the constrained and unconstrained poses. */ mix = 0; set(pose) { this.time = pose.time; this.mix = pose.mix; } }; // spine-core/src/Slider.ts var Slider = class _Slider extends Constraint { static offsets = [0, 0, 0, 0, 0, 0]; /** When set, the bone's transform property is used to set the slider's {@link SliderPose.time}. */ bone = null; constructor(data, skeleton) { super(data, new SliderPose(), new SliderPose()); if (!skeleton) throw new Error("skeleton cannot be null."); if (data.bone != null) this.bone = skeleton.bones[data.bone.index]; } copy(skeleton) { var copy = new _Slider(this.data, skeleton); copy.pose.set(this.pose); return copy; } update(skeleton, physics) { const p = this.appliedPose; if (p.mix === 0) return; const data = this.data, animation = data.animation, bone = this.bone; if (bone !== null) { if (!bone.active) return; if (data.local) bone.appliedPose.validateLocalTransform(skeleton); p.time = data.offset + (data.property.value(skeleton, bone.appliedPose, data.local, _Slider.offsets) - data.property.offset) * data.scale; if (data.loop) p.time = animation.duration + p.time % animation.duration; else p.time = Math.max(0, p.time); } const bones = skeleton.bones; const indices = animation.bones; for (let i = 0, n = animation.bones.length; i < n; i++) bones[indices[i]].appliedPose.modifyLocal(skeleton); animation.apply(skeleton, p.time, p.time, data.loop, null, p.mix, 0 /* current */, data.additive, false, true); } sort(skeleton) { const bone = this.bone; const data = this.data; if (bone && !data.local) skeleton.sortBone(bone); skeleton._updateCache.push(this); const bones = skeleton.bones; const indices = data.animation.bones; for (let i = 0, n = data.animation.bones.length; i < n; i++) { const bone2 = bones[indices[i]]; bone2.sorted = false; skeleton.sortReset(bone2.children); skeleton.constrained(bone2); } const timelines = data.animation.timelines; const slots = skeleton.slots; const constraints = skeleton.constraints; const physics = skeleton.physics; const physicsCount = skeleton.physics.length; for (let i = 0, n = data.animation.timelines.length; i < n; i++) { const t = timelines[i]; if (isSlotTimeline(t)) skeleton.constrained(slots[t.slotIndex]); else if (t instanceof DrawOrderTimeline || t instanceof DrawOrderFolderTimeline) skeleton.drawOrder.constrained(); else if (t instanceof PhysicsConstraintTimeline) { if (t.constraintIndex === -1) { for (let ii = 0; ii < physicsCount; ii++) skeleton.constrained(physics[ii]); } else skeleton.constrained(constraints[t.constraintIndex]); } else if (isConstraintTimeline(t)) { const constraintIndex = t.constraintIndex; if (constraintIndex !== -1) skeleton.constrained(constraints[constraintIndex]); } } } }; // spine-core/src/SliderData.ts var SliderData = class extends ConstraintData { /** The animation the slider will apply. */ animation; /** When true, the animation is applied by adding it to the current pose rather than overwriting it. */ additive = false; /** When true, the animation repeats after its duration, otherwise the last frame is used. */ loop = false; /** When set, the bone's transform property is used to set the slider's {@link SliderPose.time}. */ bone = null; /** When a bone is set, the specified transform property is used to set the slider's {@link SliderPose.time}. */ property; /** When a bone is set, this is the scale of the {@link property} value in relation to the slider time. */ scale = 0; /** When a bone is set, the offset is added to the property. */ offset = 0; /** When true and a bone is set, the bone's local transform property is read instead of its world transform. */ local = false; // Nonessential. /** When a bone is set, the maximum slider time for the bone property range, or 0 if nonessential data was not exported. */ max = 0; constructor(name) { super(name, new SliderPose()); } create(skeleton) { return new Slider(this, skeleton); } }; // spine-core/src/SkeletonData.ts var SkeletonData = class { /** The skeleton's name, which by default is the name of the skeleton data file, if possible. May be null. */ name = null; /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */ bones = []; // Ordered parents first. /** The skeleton's slots in the setup pose draw order. */ slots = []; // Setup pose draw order. skins = []; /** The skeleton's default skin. By default this skin contains all attachments that were not in a skin in Spine. * * See {@link Skeleton.getAttachmentByName}. * May be null. */ defaultSkin = null; /** The skeleton's events. */ events = []; /** The skeleton's animations. */ animations = []; /** The skeleton's IK constraints. */ // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types constraints = []; /** The X coordinate of the skeleton's axis aligned bounding box in the setup pose. */ x = 0; /** The Y coordinate of the skeleton's axis aligned bounding box in the setup pose. */ y = 0; /** The width of the skeleton's axis aligned bounding box in the setup pose. */ width = 0; /** The height of the skeleton's axis aligned bounding box in the setup pose. */ height = 0; /** Baseline scale factor for applying distance-dependent effects on non-scalable properties, such as angle or scale. Default * is 100. */ referenceScale = 100; /** The Spine version used to export the skeleton data, or null. */ version = null; /** The skeleton data hash. This value will change if any of the skeleton data has changed. May be null. */ hash = null; // Nonessential /** The dopesheet FPS in Spine. Available only when nonessential data was exported. */ fps = 30; /** The path to the images folder as defined in Spine. Available only when nonessential data was exported. May be null. */ imagesPath = null; /** The path to the audio folder as defined in Spine. Available only when nonessential data was exported. May be null. */ audioPath = null; /** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it * multiple times. * @returns May be null. */ findBone(boneName) { if (!boneName) throw new Error("boneName cannot be null."); const bones = this.bones; for (let i = 0, n = bones.length; i < n; i++) if (bones[i].name === boneName) return bones[i]; return null; } /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it * multiple times. * @returns May be null. */ findSlot(slotName) { if (!slotName) throw new Error("slotName cannot be null."); const slots = this.slots; for (let i = 0, n = slots.length; i < n; i++) if (slots[i].name === slotName) return slots[i]; return null; } /** Finds a skin by comparing each skin's name. It is more efficient to cache the results of this method than to call it * multiple times. * @returns May be null. */ findSkin(skinName) { if (!skinName) throw new Error("skinName cannot be null."); const skins = this.skins; for (let i = 0, n = skins.length; i < n; i++) if (skins[i].name === skinName) return skins[i]; return null; } /** Finds an event by comparing each events's name. It is more efficient to cache the results of this method than to call it * multiple times. * @returns May be null. */ findEvent(eventDataName) { if (!eventDataName) throw new Error("eventDataName cannot be null."); const events = this.events; for (let i = 0, n = events.length; i < n; i++) if (events[i].name === eventDataName) return events[i]; return null; } /** Collects animations used by {@link SliderData slider constraints}. * * Slider animations are designed to be applied by slider constraints rather than on their own. Applications that have a user * choose an animation may want to exclude them. */ findSliderAnimations(animations) { const constraints = this.constraints; for (let i = 0, n = this.constraints.length; i < n; i++) { const data = constraints[i]; if (data instanceof SliderData && data.animation != null) animations.push(data.animation); } return animations; } /** Finds an animation by comparing each animation's name. It is more efficient to cache the results of this method than to * call it multiple times. * @returns May be null. */ findAnimation(animationName) { if (!animationName) throw new Error("animationName cannot be null."); const animations = this.animations; for (let i = 0, n = animations.length; i < n; i++) if (animations[i].name === animationName) return animations[i]; return null; } // --- Constraints. /** Finds a constraint of the specified type by comparing each constraints's name. It is more efficient to cache the results of * this method than to call it multiple times. */ // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types findConstraint(constraintName, type) { if (!constraintName) throw new Error("constraintName cannot be null."); if (type == null) throw new Error("type cannot be null."); const constraints = this.constraints; for (let i = 0, n = this.constraints.length; i < n; i++) { const constraint = constraints[i]; if (constraint instanceof type && constraint.name === constraintName) return constraint; } return null; } }; // spine-core/src/Skin.ts var SkinEntry = class { /** The {@link Skeleton.slots} index. */ slotIndex = 0; placeholder; /** The attachment for this skin entry. */ attachment; constructor(slotIndex = 0, placeholder, attachment) { this.slotIndex = slotIndex; this.placeholder = placeholder; this.attachment = attachment; } }; var Skin = class { /** The skin's name, unique across all skins in the skeleton. * * See {@link SkeletonData.findSkin}. */ name; attachments = []; bones = []; // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types constraints = []; /** The color of the skin as it was in Spine, or a default color if nonessential data was not exported. */ color = new Color(0.99607843, 0.61960787, 0.30980393, 1); // fe9e4fff constructor(name) { if (!name) throw new Error("name cannot be null."); this.name = name; } /** Adds an attachment to the skin for the specified slot index and name. */ setAttachment(slotIndex, placeholder, attachment) { if (!attachment) throw new Error("attachment cannot be null."); const attachments = this.attachments; if (slotIndex >= attachments.length) attachments.length = slotIndex + 1; if (!attachments[slotIndex]) attachments[slotIndex] = {}; attachments[slotIndex][placeholder] = attachment; } /** Adds all attachments, bones, and constraints from the specified skin to this skin. */ addSkin(skin) { for (let i = 0; i < skin.bones.length; i++) { const bone = skin.bones[i]; let contained = false; for (let ii = 0; ii < this.bones.length; ii++) { if (this.bones[ii] === bone) { contained = true; break; } } if (!contained) this.bones.push(bone); } for (let i = 0; i < skin.constraints.length; i++) { const constraint = skin.constraints[i]; let contained = false; for (let ii = 0; ii < this.constraints.length; ii++) { if (this.constraints[ii] === constraint) { contained = true; break; } } if (!contained) this.constraints.push(constraint); } const attachments = skin.getAttachments(); for (let i = 0; i < attachments.length; i++) { const attachment = attachments[i]; this.setAttachment(attachment.slotIndex, attachment.placeholder, attachment.attachment); } } /** Adds all bones and constraints and copies of all attachments from the specified skin to this skin. Mesh attachments are not * copied, instead a new linked mesh is created. The attachment copies can be modified without affecting the originals. */ copySkin(skin) { for (let i = 0; i < skin.bones.length; i++) { const bone = skin.bones[i]; let contained = false; for (let ii = 0; ii < this.bones.length; ii++) { if (this.bones[ii] === bone) { contained = true; break; } } if (!contained) this.bones.push(bone); } for (let i = 0; i < skin.constraints.length; i++) { const constraint = skin.constraints[i]; let contained = false; for (let ii = 0; ii < this.constraints.length; ii++) { if (this.constraints[ii] === constraint) { contained = true; break; } } if (!contained) this.constraints.push(constraint); } const attachments = skin.getAttachments(); for (let i = 0; i < attachments.length; i++) { const attachment = attachments[i]; if (!attachment.attachment) continue; if (attachment.attachment instanceof MeshAttachment) { attachment.attachment = attachment.attachment.newLinkedMesh(); this.setAttachment(attachment.slotIndex, attachment.placeholder, attachment.attachment); } else { attachment.attachment = attachment.attachment.copy(); this.setAttachment(attachment.slotIndex, attachment.placeholder, attachment.attachment); } } } /** Returns the attachment for the specified slot index and placeholder, or null. */ getAttachment(slotIndex, placeholder) { const dictionary = this.attachments[slotIndex]; return dictionary ? dictionary[placeholder] : null; } /** Removes the attachment in the skin for the specified slot index and placeholder, if any. */ removeAttachment(slotIndex, placeholder) { const dictionary = this.attachments[slotIndex]; if (dictionary) delete dictionary[placeholder]; } /** Returns all attachments in this skin. */ getAttachments() { const entries = []; for (let i = 0; i < this.attachments.length; i++) { const slotAttachments = this.attachments[i]; if (slotAttachments) { for (const name in slotAttachments) { const attachment = slotAttachments[name]; if (attachment) entries.push(new SkinEntry(i, name, attachment)); } } } return entries; } /** Returns all attachments in this skin for the specified slot index. */ getAttachmentsForSlot(slotIndex, attachments) { const slotAttachments = this.attachments[slotIndex]; if (slotAttachments) { for (const name in slotAttachments) { const attachment = slotAttachments[name]; if (attachment) attachments.push(new SkinEntry(slotIndex, name, attachment)); } } } /** Clears all attachments, bones, and constraints. */ clear() { this.attachments.length = 0; this.bones.length = 0; this.constraints.length = 0; } /** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */ attachAll(skeleton, oldSkin) { let slotIndex = 0; for (let i = 0; i < skeleton.slots.length; i++) { const slot = skeleton.slots[i]; const slotAttachment = slot.pose.getAttachment(); if (slotAttachment && slotIndex < oldSkin.attachments.length) { const dictionary = oldSkin.attachments[slotIndex]; for (const placeholder in dictionary) { const skinAttachment = dictionary[placeholder]; if (slotAttachment === skinAttachment) { const attachment = this.getAttachment(slotIndex, placeholder); if (attachment) slot.pose.setAttachment(attachment); break; } } } slotIndex++; } } }; // spine-core/src/SlotData.ts var SlotData = class extends PosedData { /** The index of the slot in {@link Skeleton.slots}. */ index = 0; /** The bone this slot belongs to. */ boneData; /** The name of the attachment that is visible for this slot in the setup pose, or null if no attachment is visible. */ attachmentName = null; /** The blend mode for drawing the slot's attachment. */ blendMode = 0 /* Normal */; // Nonessential. /** False if the slot was hidden in Spine and nonessential data was exported. Does not affect runtime rendering. */ visible = true; constructor(index, name, boneData) { super(name, new SlotPose()); if (index < 0) throw new Error("index must be >= 0."); if (!boneData) throw new Error("boneData cannot be null."); this.index = index; this.boneData = boneData; } }; var BlendMode = /* @__PURE__ */ ((BlendMode2) => { BlendMode2[BlendMode2["Normal"] = 0] = "Normal"; BlendMode2[BlendMode2["Additive"] = 1] = "Additive"; BlendMode2[BlendMode2["Multiply"] = 2] = "Multiply"; BlendMode2[BlendMode2["Screen"] = 3] = "Screen"; return BlendMode2; })(BlendMode || {}); // spine-core/src/TransformConstraintPose.ts var TransformConstraintPose = class { /** A percentage (unbounded) that controls the mix between the constrained and unconstrained rotation. */ mixRotate = 0; /** A percentage (unbounded) that controls the mix between the constrained and unconstrained translation X. */ mixX = 0; /** A percentage (unbounded) that controls the mix between the constrained and unconstrained translation Y. */ mixY = 0; /** A percentage (unbounded) that controls the mix between the constrained and unconstrained scale X. */ mixScaleX = 0; /** A percentage (unbounded) that controls the mix between the constrained and unconstrained scale Y. */ mixScaleY = 0; /** A percentage (unbounded) that controls the mix between the constrained and unconstrained shear Y. */ mixShearY = 0; set(pose) { this.mixRotate = pose.mixRotate; this.mixX = pose.mixX; this.mixY = pose.mixY; this.mixScaleX = pose.mixScaleX; this.mixScaleY = pose.mixScaleY; this.mixShearY = pose.mixShearY; } }; // spine-core/src/TransformConstraint.ts var TransformConstraint = class _TransformConstraint extends Constraint { /** The bones that will be modified by this transform constraint. */ bones; /** The bone whose world transform will be copied to the constrained bones. */ source; constructor(data, skeleton) { super(data, new TransformConstraintPose(), new TransformConstraintPose()); if (!skeleton) throw new Error("skeleton cannot be null."); this.bones = []; for (const boneData of data.bones) this.bones.push(skeleton.bones[boneData.index].constrainedPose); const source = skeleton.bones[data.source.index]; if (source == null) throw new Error("source cannot be null."); this.source = source; } copy(skeleton) { var copy = new _TransformConstraint(this.data, skeleton); copy.pose.set(this.pose); return copy; } update(skeleton, physics) { const p = this.appliedPose; if (p.mixRotate === 0 && p.mixX === 0 && p.mixY === 0 && p.mixScaleX === 0 && p.mixScaleY === 0 && p.mixShearY === 0) return; const data = this.data; const localSource = data.localSource, localTarget = data.localTarget, additive = data.additive, clamp = data.clamp; const offsets = data.offsets; const source = this.source.appliedPose; if (localSource) source.validateLocalTransform(skeleton); const fromItems = data.properties; const fn = data.properties.length; const bones = this.bones; for (let i = 0, n = this.bones.length; i < n; i++) { const bone = bones[i]; if (localTarget) bone.modifyLocal(skeleton); else bone.modifyWorld(skeleton); for (let f = 0; f < fn; f++) { const from = fromItems[f]; const value = from.value(skeleton, source, localSource, offsets) - from.offset; const toItems = from.to; for (let t = 0, tn = from.to.length; t < tn; t++) { const to = toItems[t]; if (to.mix(p) !== 0) { let clamped = to.offset + value * to.scale; if (clamp) { if (to.offset < to.max) clamped = MathUtils.clamp(clamped, to.offset, to.max); else clamped = MathUtils.clamp(clamped, to.max, to.offset); } to.apply(skeleton, p, bone, clamped, localTarget, additive); } } } } } sort(skeleton) { if (!this.data.localSource) skeleton.sortBone(this.source); const bones = this.bones; const boneCount = this.bones.length; const worldTarget = !this.data.localTarget; if (worldTarget) { for (let i = 0; i < boneCount; i++) skeleton.sortBone(bones[i].bone); } skeleton._updateCache.push(this); for (let i = 0; i < boneCount; i++) { const bone = bones[i].bone; skeleton.sortReset(bone.children); skeleton.constrained(bone); } for (let i = 0; i < boneCount; i++) bones[i].bone.sorted = worldTarget; } isSourceActive() { return this.source.active; } }; // spine-core/src/TransformConstraintData.ts var TransformConstraintData = class _TransformConstraintData extends ConstraintData { static ROTATION = 0; static X = 1; static Y = 2; static SCALEX = 3; static SCALEY = 4; static SHEARY = 5; /** The bones that will be modified by this transform constraint. */ bones = []; /** The bone whose world transform will be copied to the constrained bones. */ set source(source) { this._source = source; } get source() { if (!this._source) throw new Error("BoneData not set."); else return this._source; } _source = null; offsets = [0, 0, 0, 0, 0, 0]; /** An offset added to the constrained bone X translation. */ offsetX = 0; /** An offset added to the constrained bone Y translation. */ offsetY = 0; /** Reads the source bone's local transform instead of its world transform. */ localSource = false; /** Sets the constrained bones' local transforms instead of their world transforms. */ localTarget = false; /** Adds the source bone transform to the constrained bones instead of setting it absolutely. */ additive = false; /** Prevents constrained bones from exceeding the ranged defined by {@link ToProperty.offset} and {@link ToProperty.max}. */ clamp = false; /** The mapping of transform properties to other transform properties. */ properties = []; constructor(name) { super(name, new TransformConstraintPose()); } create(skeleton) { return new TransformConstraint(this, skeleton); } /** An offset added to the constrained bone rotation. */ getOffsetRotation() { return this.offsets[_TransformConstraintData.ROTATION]; } setOffsetRotation(offsetRotation) { this.offsets[_TransformConstraintData.ROTATION] = offsetRotation; } /** An offset added to the constrained bone X translation. */ getOffsetX() { return this.offsets[_TransformConstraintData.X]; } setOffsetX(offsetX) { this.offsets[_TransformConstraintData.X] = offsetX; } /** An offset added to the constrained bone Y translation. */ getOffsetY() { return this.offsets[_TransformConstraintData.Y]; } setOffsetY(offsetY) { this.offsets[_TransformConstraintData.Y] = offsetY; } /** An offset added to the constrained bone scaleX. */ getOffsetScaleX() { return this.offsets[_TransformConstraintData.SCALEX]; } setOffsetScaleX(offsetScaleX) { this.offsets[_TransformConstraintData.SCALEX] = offsetScaleX; } /** An offset added to the constrained bone scaleY. */ getOffsetScaleY() { return this.offsets[_TransformConstraintData.SCALEY]; } setOffsetScaleY(offsetScaleY) { this.offsets[_TransformConstraintData.SCALEY] = offsetScaleY; } /** An offset added to the constrained bone shearY. */ getOffsetShearY() { return this.offsets[_TransformConstraintData.SHEARY]; } setOffsetShearY(offsetShearY) { this.offsets[_TransformConstraintData.SHEARY] = offsetShearY; } }; var FromProperty = class { /** The value of this property that corresponds to {@link ToProperty.offset}. */ offset = 0; /** Constrained properties. */ to = []; }; var ToProperty = class { /** The value of this property that corresponds to {@link FromProperty.offset}. */ offset = 0; /** The maximum value of this property when {@link TransformConstraintData.clamp clamped}. */ max = 0; /** The scale of the {@link FromProperty} value in relation to this property. */ scale = 0; }; var FromRotate = class extends FromProperty { value(skeleton, source, local, offsets) { if (local) return source.rotation + offsets[TransformConstraintData.ROTATION]; const sx = skeleton.scaleX, sy = skeleton.scaleY; let value = Math.atan2(source.c / sy, source.a / sx) * MathUtils.radDeg + ((source.a * source.d - source.b * source.c) * sx * sy > 0 ? offsets[TransformConstraintData.ROTATION] : -offsets[TransformConstraintData.ROTATION]); if (value < 0) value += 360; return value; } }; var ToRotate = class extends ToProperty { mix(pose) { return pose.mixRotate; } apply(skeleton, pose, bone, value, local, additive) { if (local) bone.rotation += (additive ? value : value - bone.rotation) * pose.mixRotate; else { const sx = skeleton.scaleX, sy = skeleton.scaleY, ix = 1 / sx, iy = 1 / sy; const a = bone.a * ix, b = bone.b * ix, c = bone.c * iy, d = bone.d * iy; value *= MathUtils.degRad; if (!additive) value -= Math.atan2(c, a); if (value > MathUtils.PI) value -= MathUtils.PI2; else if (value < -MathUtils.PI) value += MathUtils.PI2; value *= pose.mixRotate; const cos = Math.cos(value), sin = Math.sin(value); bone.a = (cos * a - sin * c) * sx; bone.b = (cos * b - sin * d) * sx; bone.c = (sin * a + cos * c) * sy; bone.d = (sin * b + cos * d) * sy; } } }; var FromX = class extends FromProperty { value(skeleton, source, local, offsets) { return local ? source.x + offsets[TransformConstraintData.X] : (offsets[TransformConstraintData.X] * source.a + offsets[TransformConstraintData.Y] * source.b + source.worldX) / skeleton.scaleX; } }; var ToX = class extends ToProperty { mix(pose) { return pose.mixX; } apply(skeleton, pose, bone, value, local, additive) { if (local) bone.x += (additive ? value : value - bone.x) * pose.mixX; else { if (!additive) value -= bone.worldX / skeleton.scaleX; bone.worldX += value * pose.mixX * skeleton.scaleX; } } }; var FromY = class extends FromProperty { value(skeleton, source, local, offsets) { return local ? source.y + offsets[TransformConstraintData.Y] : (offsets[TransformConstraintData.X] * source.c + offsets[TransformConstraintData.Y] * source.d + source.worldY) / skeleton.scaleY; } }; var ToY = class extends ToProperty { mix(pose) { return pose.mixY; } apply(skeleton, pose, bone, value, local, additive) { if (local) bone.y += (additive ? value : value - bone.y) * pose.mixY; else { if (!additive) value -= bone.worldY / skeleton.scaleY; bone.worldY += value * pose.mixY * skeleton.scaleY; } } }; var FromScaleX = class extends FromProperty { value(skeleton, source, local, offsets) { if (local) return source.scaleX + offsets[TransformConstraintData.SCALEX]; const a = source.a / skeleton.scaleX, c = source.c / skeleton.scaleY; return Math.sqrt(a * a + c * c) + offsets[TransformConstraintData.SCALEX]; } }; var ToScaleX = class extends ToProperty { mix(pose) { return pose.mixScaleX; } apply(skeleton, pose, bone, value, local, additive) { if (local) { if (additive) bone.scaleX *= 1 + (value - 1) * pose.mixScaleX; else if (bone.scaleX !== 0) bone.scaleX += (value - bone.scaleX) * pose.mixScaleX; } else if (additive) { const s = 1 + (value - 1) * pose.mixScaleX; bone.a *= s; bone.c *= s; } else { let a = bone.a / skeleton.scaleX, c = bone.c / skeleton.scaleY, s = Math.sqrt(a * a + c * c); if (s !== 0) { s = 1 + (value - s) * pose.mixScaleX / s; bone.a *= s; bone.c *= s; } } } }; var FromScaleY = class extends FromProperty { value(skeleton, source, local, offsets) { if (local) return source.scaleY + offsets[TransformConstraintData.SCALEY]; const b = source.b / skeleton.scaleX, d = source.d / skeleton.scaleY; return Math.sqrt(b * b + d * d) + offsets[TransformConstraintData.SCALEY]; } }; var ToScaleY = class extends ToProperty { mix(pose) { return pose.mixScaleY; } apply(skeleton, pose, bone, value, local, additive) { if (local) { if (additive) bone.scaleY *= 1 + (value - 1) * pose.mixScaleY; else if (bone.scaleY !== 0) bone.scaleY += (value - bone.scaleY) * pose.mixScaleY; } else if (additive) { const s = 1 + (value - 1) * pose.mixScaleY; bone.b *= s; bone.d *= s; } else { let b = bone.b / skeleton.scaleX, d = bone.d / skeleton.scaleY, s = Math.sqrt(b * b + d * d); if (s !== 0) { s = 1 + (value - s) * pose.mixScaleY / s; bone.b *= s; bone.d *= s; } } } }; var FromShearY = class extends FromProperty { value(skeleton, source, local, offsets) { if (local) return source.shearY + offsets[TransformConstraintData.SHEARY]; const ix = 1 / skeleton.scaleX, iy = 1 / skeleton.scaleY; return (Math.atan2(source.d * iy, source.b * ix) - Math.atan2(source.c * iy, source.a * ix)) * MathUtils.radDeg - 90 + offsets[TransformConstraintData.SHEARY]; } }; var ToShearY = class extends ToProperty { mix(pose) { return pose.mixShearY; } apply(skeleton, pose, bone, value, local, additive) { if (local) { if (!additive) value -= bone.shearY; bone.shearY += value * pose.mixShearY; } else { const sx = skeleton.scaleX, sy = skeleton.scaleY, b = bone.b / sx, d = bone.d / sy, by = Math.atan2(d, b); value = (value + 90) * MathUtils.degRad; if (additive) value -= MathUtils.PI / 2; else { value -= by - Math.atan2(bone.c / sy, bone.a / sx); if (value > MathUtils.PI) value -= MathUtils.PI2; else if (value < -MathUtils.PI) value += MathUtils.PI2; } value = by + value * pose.mixShearY; const s = Math.sqrt(b * b + d * d); bone.b = Math.cos(value) * s * sx; bone.d = Math.sin(value) * s * sy; } } }; // spine-core/src/SkeletonBinary.ts var SkeletonBinary = class { /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at * runtime than were used in Spine. * * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */ scale = 1; attachmentLoader; linkedMeshes = []; constructor(attachmentLoader) { this.attachmentLoader = attachmentLoader; } readSkeletonData(binary) { const scale = this.scale; const skeletonData = new SkeletonData(); skeletonData.name = ""; const input = new BinaryInput(binary); const lowHash = input.readInt32(); const highHash = input.readInt32(); skeletonData.hash = highHash === 0 && lowHash === 0 ? null : highHash.toString(16) + lowHash.toString(16); skeletonData.version = input.readString(); skeletonData.x = input.readFloat(); skeletonData.y = input.readFloat(); skeletonData.width = input.readFloat(); skeletonData.height = input.readFloat(); skeletonData.referenceScale = input.readFloat() * scale; const nonessential = input.readBoolean(); if (nonessential) { skeletonData.fps = input.readFloat(); skeletonData.imagesPath = input.readString(); skeletonData.audioPath = input.readString(); } let n = 0; n = input.readInt(true); for (let i = 0; i < n; i++) { const str = input.readString(); if (!str) throw new Error("String in string table must not be null."); input.strings.push(str); } const bones = skeletonData.bones; n = input.readInt(true); for (let i = 0; i < n; i++) { const name = input.readString(); if (!name) throw new Error("Bone name must not be null."); const parent = i === 0 ? null : bones[input.readInt(true)]; const data = new BoneData(i, name, parent); const setup = data.setupPose; setup.rotation = input.readFloat(); setup.x = input.readFloat() * scale; setup.y = input.readFloat() * scale; setup.scaleX = input.readFloat(); setup.scaleY = input.readFloat(); setup.shearX = input.readFloat(); setup.shearY = input.readFloat(); setup.inherit = input.readByte(); data.length = input.readFloat() * scale; data.skinRequired = input.readBoolean(); if (nonessential) { Color.rgba8888ToColor(data.color, input.readInt32()); data.icon = input.readString() ?? void 0; data.iconSize = input.readFloat(); data.iconRotation = input.readFloat(); data.visible = input.readBoolean(); } bones.push(data); } n = input.readInt(true); for (let i = 0; i < n; i++) { const slotName = input.readString(); if (!slotName) throw new Error("Slot name must not be null."); const boneData = bones[input.readInt(true)]; const data = new SlotData(i, slotName, boneData); Color.rgba8888ToColor(data.setupPose.color, input.readInt32()); const darkColor = input.readInt32(); if (darkColor !== -1) Color.rgb888ToColor(data.setupPose.darkColor = new Color(), darkColor); data.attachmentName = input.readStringRef(); data.blendMode = input.readInt(true); if (nonessential) data.visible = input.readBoolean(); skeletonData.slots.push(data); } const constraints = skeletonData.constraints; const constraintCount = input.readInt(true); for (let i = 0; i < constraintCount; i++) { const name = input.readString(); if (!name) throw new Error("Constraint data name must not be null."); let nn; switch (input.readByte()) { case CONSTRAINT_IK: { const data = new IkConstraintData(name); nn = input.readInt(true); for (let ii = 0; ii < nn; ii++) data.bones.push(bones[input.readInt(true)]); data.target = bones[input.readInt(true)]; const flags = input.readByte(); data.skinRequired = (flags & 1) !== 0; if ((flags & 2) !== 0) data.scaleYMode = input.readUnsignedByte(); const setup = data.setupPose; setup.bendDirection = (flags & 4) !== 0 ? -1 : 1; setup.compress = (flags & 8) !== 0; setup.stretch = (flags & 16) !== 0; if ((flags & 32) !== 0) setup.mix = (flags & 64) !== 0 ? input.readFloat() : 1; if ((flags & 128) !== 0) setup.softness = input.readFloat() * scale; constraints.push(data); break; } case CONSTRAINT_TRANSFORM: { const data = new TransformConstraintData(name); nn = input.readInt(true); for (let ii = 0; ii < nn; ii++) data.bones.push(bones[input.readInt(true)]); data.source = bones[input.readInt(true)]; let flags = input.readUnsignedByte(); data.skinRequired = (flags & 1) !== 0; data.localSource = (flags & 2) !== 0; data.localTarget = (flags & 4) !== 0; data.additive = (flags & 8) !== 0; data.clamp = (flags & 16) !== 0; nn = flags >> 5; for (let ii = 0, tn; ii < nn; ii++) { let fromScale = 1; let from; switch (input.readByte()) { case 0: from = new FromRotate(); break; case 1: { fromScale = scale; from = new FromX(); break; } case 2: { fromScale = scale; from = new FromY(); break; } case 3: from = new FromScaleX(); break; case 4: from = new FromScaleY(); break; case 5: from = new FromShearY(); break; default: from = null; } if (!from) continue; from.offset = input.readFloat() * fromScale; tn = input.readByte(); for (let t = 0; t < tn; t++) { let toScale = 1; let to; switch (input.readByte()) { case 0: to = new ToRotate(); break; case 1: { toScale = scale; to = new ToX(); break; } case 2: { toScale = scale; to = new ToY(); break; } case 3: to = new ToScaleX(); break; case 4: to = new ToScaleY(); break; case 5: to = new ToShearY(); break; default: to = null; } if (!to) continue; to.offset = input.readFloat() * toScale; to.max = input.readFloat() * toScale; to.scale = input.readFloat() * toScale / fromScale; from.to[t] = to; } data.properties[ii] = from; } flags = input.readByte(); if ((flags & 1) !== 0) data.offsets[TransformConstraintData.ROTATION] = input.readFloat(); if ((flags & 2) !== 0) data.offsets[TransformConstraintData.X] = input.readFloat() * scale; if ((flags & 4) !== 0) data.offsets[TransformConstraintData.Y] = input.readFloat() * scale; if ((flags & 8) !== 0) data.offsets[TransformConstraintData.SCALEX] = input.readFloat(); if ((flags & 16) !== 0) data.offsets[TransformConstraintData.SCALEY] = input.readFloat(); if ((flags & 32) !== 0) data.offsets[TransformConstraintData.SHEARY] = input.readFloat(); flags = input.readByte(); const setup = data.setupPose; if ((flags & 1) !== 0) setup.mixRotate = input.readFloat(); if ((flags & 2) !== 0) setup.mixX = input.readFloat(); if ((flags & 4) !== 0) setup.mixY = input.readFloat(); if ((flags & 8) !== 0) setup.mixScaleX = input.readFloat(); if ((flags & 16) !== 0) setup.mixScaleY = input.readFloat(); if ((flags & 32) !== 0) setup.mixShearY = input.readFloat(); constraints.push(data); break; } case CONSTRAINT_PATH: { const data = new PathConstraintData(name); nn = input.readInt(true); for (let ii = 0; ii < nn; ii++) data.bones.push(bones[input.readInt(true)]); data.slot = skeletonData.slots[input.readInt(true)]; const flags = input.readByte(); data.skinRequired = (flags & 1) !== 0; data.positionMode = flags >> 1 & 1; data.spacingMode = flags >> 2 & 3; data.rotateMode = flags >> 4 & 3; if ((flags & 128) !== 0) data.offsetRotation = input.readFloat(); const setup = data.setupPose; setup.position = input.readFloat(); if (data.positionMode === 0 /* Fixed */) setup.position *= scale; setup.spacing = input.readFloat(); if (data.spacingMode === 0 /* Length */ || data.spacingMode === 1 /* Fixed */) setup.spacing *= scale; setup.mixRotate = input.readFloat(); setup.mixX = input.readFloat(); setup.mixY = input.readFloat(); constraints.push(data); break; } case CONSTRAINT_PHYSICS: { const data = new PhysicsConstraintData(name); data.bone = bones[input.readInt(true)]; let flags = input.readByte(); data.skinRequired = (flags & 1) !== 0; if ((flags & 2) !== 0) data.x = input.readFloat(); if ((flags & 4) !== 0) data.y = input.readFloat(); if ((flags & 8) !== 0) data.rotate = input.readFloat(); if ((flags & 16) !== 0) { let scaleX = input.readFloat(); if (scaleX < -2) { data.scaleYMode = 2 /* Volume */; scaleX = -2 - scaleX; } else if (scaleX < 0) { data.scaleYMode = 1 /* Uniform */; scaleX = -1 - scaleX; } data.scaleX = scaleX; } if ((flags & 32) !== 0) data.shearX = input.readFloat(); data.limit = ((flags & 64) !== 0 ? input.readFloat() : 5e3) * scale; data.step = 1 / input.readUnsignedByte(); const setup = data.setupPose; setup.inertia = input.readFloat(); setup.strength = input.readFloat(); setup.damping = input.readFloat(); setup.massInverse = (flags & 128) !== 0 ? input.readFloat() : 1; setup.wind = input.readFloat(); setup.gravity = input.readFloat(); flags = input.readByte(); if ((flags & 1) !== 0) data.inertiaGlobal = true; if ((flags & 2) !== 0) data.strengthGlobal = true; if ((flags & 4) !== 0) data.dampingGlobal = true; if ((flags & 8) !== 0) data.massGlobal = true; if ((flags & 16) !== 0) data.windGlobal = true; if ((flags & 32) !== 0) data.gravityGlobal = true; if ((flags & 64) !== 0) data.mixGlobal = true; setup.mix = (flags & 128) !== 0 ? input.readFloat() : 1; constraints.push(data); break; } case CONSTRAINT_SLIDER: { const data = new SliderData(name); const flags = input.readByte(); data.skinRequired = (flags & 1) !== 0; data.loop = (flags & 2) !== 0; data.additive = (flags & 4) !== 0; if ((flags & 8) !== 0) { const value = input.readFloat(); if (nonessential && (flags & 64) !== 0) data.max = value; else data.setupPose.time = value; } if ((flags & 16) !== 0) data.setupPose.mix = (flags & 32) !== 0 ? input.readFloat() : 1; if ((flags & 64) !== 0) { data.local = (flags & 128) !== 0; data.bone = bones[input.readInt(true)]; const offset = input.readFloat(); let propertyScale = 1; switch (input.readByte()) { case 0: data.property = new FromRotate(); break; case 1: { propertyScale = scale; data.property = new FromX(); break; } case 2: { propertyScale = scale; data.property = new FromY(); break; } case 3: data.property = new FromScaleX(); break; case 4: data.property = new FromScaleY(); break; case 5: data.property = new FromShearY(); break; default: continue; } ; data.property.offset = offset * propertyScale; data.offset = input.readFloat(); data.scale = input.readFloat() / propertyScale; } constraints.push(data); break; } } } const defaultSkin = this.readSkin(input, skeletonData, true, nonessential); if (defaultSkin) { skeletonData.defaultSkin = defaultSkin; skeletonData.skins.push(defaultSkin); } { let i = skeletonData.skins.length; Utils.setArraySize(skeletonData.skins, n = i + input.readInt(true)); for (; i < n; i++) { const skin = this.readSkin(input, skeletonData, false, nonessential); if (!skin) throw new Error("readSkin() should not have returned null."); skeletonData.skins[i] = skin; } } n = this.linkedMeshes.length; for (let i = 0; i < n; i++) { const linkedMesh = this.linkedMeshes[i]; const skin = skeletonData.skins[linkedMesh.skinIndex]; if (!linkedMesh.source) throw new Error("Linked mesh parent must not be null"); const source = skin.getAttachment(linkedMesh.sourceIndex, linkedMesh.source); if (!source) throw new Error(`Source mesh not found: ${linkedMesh.source}`); linkedMesh.mesh.timelineAttachment = linkedMesh.inheritTimelines ? source : linkedMesh.mesh; linkedMesh.mesh.setSourceMesh(source); linkedMesh.mesh.updateSequence(); } this.linkedMeshes.length = 0; n = input.readInt(true); for (let i = 0; i < n; i++) { const eventName = input.readString(); if (!eventName) throw new Error("Event data name must not be null"); const data = new EventData(eventName); const setup = data.setupPose; setup.intValue = input.readInt(false); setup.floatValue = input.readFloat(); setup.stringValue = input.readString(); data._audioPath = input.readString(); if (data.audioPath) { setup.volume = input.readFloat(); setup.balance = input.readFloat(); } skeletonData.events.push(data); } const animations = skeletonData.animations; n = input.readInt(true); for (let i = 0; i < n; i++) { const animationName = input.readString(); if (!animationName) throw new Error("Animation name must not be null."); animations.push(this.readAnimation(input, animationName, skeletonData, nonessential)); } for (let i = 0; i < constraintCount; i++) { const constraint = constraints[i]; if (constraint instanceof SliderData) constraint.animation = animations[input.readInt(true)]; } return skeletonData; } readSkin(input, skeletonData, defaultSkin, nonessential) { let skin = null; let slotCount = 0; if (defaultSkin) { slotCount = input.readInt(true); if (slotCount === 0) return null; skin = new Skin("default"); } else { const skinName = input.readString(); if (!skinName) throw new Error("Skin name must not be null."); skin = new Skin(skinName); if (nonessential) Color.rgba8888ToColor(skin.color, input.readInt32()); let n = input.readInt(true); let from = skeletonData.bones, to = skin.bones; for (let i = 0; i < n; i++) to[i] = from[input.readInt(true)]; n = input.readInt(true); from = skeletonData.constraints; to = skin.constraints; for (let i = 0; i < n; i++) to[i] = from[input.readInt(true)]; slotCount = input.readInt(true); } for (let i = 0; i < slotCount; i++) { const slotIndex = input.readInt(true); for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) { const placeholder = input.readStringRef(); if (!placeholder) throw new Error("Attachment name must not be null"); const attachment = this.readAttachment(input, skeletonData, skin, slotIndex, placeholder, nonessential); if (attachment) skin.setAttachment(slotIndex, placeholder, attachment); } } return skin; } readAttachment(input, skeletonData, skin, slotIndex, placeholder, nonessential) { const scale = this.scale; const flags = input.readByte(); const name = (flags & 8) !== 0 ? input.readStringRef() : placeholder; if (!name) throw new Error("Attachment name must not be null"); switch (flags & 7) { // BUG? case 0 /* Region */: { let path = (flags & 16) !== 0 ? input.readStringRef() : null; const color = (flags & 32) !== 0 ? input.readInt32() : 4294967295; const sequence = this.readSequence(input, (flags & 64) !== 0); const rotation = (flags & 128) !== 0 ? input.readFloat() : 0; const x = input.readFloat(); const y = input.readFloat(); const scaleX = input.readFloat(); const scaleY = input.readFloat(); const width = input.readFloat(); const height = input.readFloat(); if (!path) path = name; const region = this.attachmentLoader.newRegionAttachment(skin, placeholder, name, path, sequence); if (!region) return null; region.path = path; region.x = x * scale; region.y = y * scale; region.scaleX = scaleX; region.scaleY = scaleY; region.rotation = rotation; region.width = width * scale; region.height = height * scale; Color.rgba8888ToColor(region.color, color); region.updateSequence(); return region; } case 1 /* BoundingBox */: { const vertices = this.readVertices(input, (flags & 16) !== 0); const color = nonessential ? input.readInt32() : 0; const box = this.attachmentLoader.newBoundingBoxAttachment(skin, placeholder, name); if (!box) return null; box.worldVerticesLength = vertices.length; box.vertices = vertices.vertices; box.bones = vertices.bones; if (nonessential) Color.rgba8888ToColor(box.color, color); return box; } case 2 /* Mesh */: { let path = (flags & 16) !== 0 ? input.readStringRef() : name; const color = (flags & 32) !== 0 ? input.readInt32() : 4294967295; const sequence = this.readSequence(input, (flags & 64) !== 0); const hullLength = input.readInt(true); const vertices = this.readVertices(input, (flags & 128) !== 0); const uvs = this.readFloatArray(input, vertices.length, 1); const triangles = this.readShortArray(input, (vertices.length - hullLength - 2) * 3); const slotCount = input.readInt(true); let timelineSlots = null; if (slotCount > 0) { timelineSlots = []; for (let i = 0; i < slotCount; i++) timelineSlots[i] = input.readInt(true); } let edges = []; let width = 0, height = 0; if (nonessential) { edges = this.readShortArray(input, input.readInt(true)); width = input.readFloat(); height = input.readFloat(); } if (!path) path = name; const mesh = this.attachmentLoader.newMeshAttachment(skin, placeholder, name, path, sequence); if (!mesh) return null; mesh.path = path; Color.rgba8888ToColor(mesh.color, color); mesh.hullLength = hullLength << 1; mesh.bones = vertices.bones; mesh.vertices = vertices.vertices; mesh.worldVerticesLength = vertices.length; mesh.regionUVs = uvs; mesh.triangles = triangles; if (timelineSlots) mesh.timelineSlots = timelineSlots; if (nonessential) { mesh.edges = edges; mesh.width = width * scale; mesh.height = height * scale; } mesh.updateSequence(); return mesh; } case 3 /* LinkedMesh */: { const path = (flags & 16) !== 0 ? input.readStringRef() : name; if (path == null) throw new Error("Path of linked mesh must not be null"); const color = (flags & 32) !== 0 ? input.readInt32() : 4294967295; const sequence = this.readSequence(input, (flags & 64) !== 0); const inheritTimelines = (flags & 128) !== 0; const sourceIndex = input.readInt(true); const skinIndex = input.readInt(true); const source = input.readStringRef(); let width = 0, height = 0; if (nonessential) { width = input.readFloat(); height = input.readFloat(); } const mesh = this.attachmentLoader.newMeshAttachment(skin, placeholder, name, path, sequence); if (!mesh) return null; mesh.path = path; Color.rgba8888ToColor(mesh.color, color); if (nonessential) { mesh.width = width * scale; mesh.height = height * scale; } this.linkedMeshes.push(new LinkedMesh(mesh, skinIndex, slotIndex, sourceIndex, source, inheritTimelines)); return mesh; } case 4 /* Path */: { const closed = (flags & 16) !== 0; const constantSpeed = (flags & 32) !== 0; const vertices = this.readVertices(input, (flags & 64) !== 0); const lengths = this.readFloatArray(input, vertices.length / 6, scale); const color = nonessential ? input.readInt32() : 0; const path = this.attachmentLoader.newPathAttachment(skin, placeholder, name); if (!path) return null; path.closed = closed; path.constantSpeed = constantSpeed; path.worldVerticesLength = vertices.length; path.vertices = vertices.vertices; path.bones = vertices.bones; path.lengths = lengths; if (nonessential) Color.rgba8888ToColor(path.color, color); return path; } case 5 /* Point */: { const rotation = input.readFloat(); const x = input.readFloat(); const y = input.readFloat(); const color = nonessential ? input.readInt32() : 0; const point = this.attachmentLoader.newPointAttachment(skin, placeholder, name); if (!point) return null; point.x = x * scale; point.y = y * scale; point.rotation = rotation; if (nonessential) Color.rgba8888ToColor(point.color, color); return point; } case 6 /* Clipping */: { const endSlotIndex = input.readInt(true); const vertices = this.readVertices(input, (flags & 16) !== 0); const color = nonessential ? input.readInt32() : 0; const clip = this.attachmentLoader.newClippingAttachment(skin, placeholder, name); if (!clip) return null; clip.endSlot = skeletonData.slots[endSlotIndex]; clip.convex = (flags & 32) !== 0; clip.inverse = (flags & 64) !== 0; clip.worldVerticesLength = vertices.length; clip.vertices = vertices.vertices; clip.bones = vertices.bones; if (nonessential) Color.rgba8888ToColor(clip.color, color); return clip; } } } readSequence(input, hasPathSuffix) { if (!hasPathSuffix) return new Sequence(1, false); const sequence = new Sequence(input.readInt(true), true); sequence.start = input.readInt(true); sequence.digits = input.readInt(true); sequence.setupIndex = input.readInt(true); return sequence; } readVertices(input, weighted) { const scale = this.scale; const vertexCount = input.readInt(true); const length = vertexCount << 1; if (!weighted) return new Vertices(null, this.readFloatArray(input, length, scale), length); const n = input.readInt(true); const bones = []; const weights = []; for (let b = 0, w = 0; b < n; ) { const boneCount = input.readInt(true); bones[b++] = boneCount; for (let ii = 0; ii < boneCount; ii++, w += 3) { bones[b++] = input.readInt(true); weights[w] = input.readFloat() * scale; weights[w + 1] = input.readFloat() * scale; weights[w + 2] = input.readFloat(); } } return new Vertices(bones, Utils.toFloatArray(weights), length); } readFloatArray(input, n, scale) { const array = []; if (scale === 1) { for (let i = 0; i < n; i++) array[i] = input.readFloat(); } else { for (let i = 0; i < n; i++) array[i] = input.readFloat() * scale; } return array; } readShortArray(input, n) { const array = []; for (let i = 0; i < n; i++) array[i] = input.readInt(true); return array; } readAnimation(input, name, skeletonData, nonessential) { input.readInt(true); const timelines = []; const scale = this.scale; for (let i = 0, n = input.readInt(true); i < n; i++) { const slotIndex = input.readInt(true); for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) { const timelineType = input.readByte(); const frameCount = input.readInt(true); const frameLast = frameCount - 1; switch (timelineType) { case SLOT_ATTACHMENT: { const timeline = new AttachmentTimeline(frameCount, slotIndex); for (let frame = 0; frame < frameCount; frame++) timeline.setFrame(frame, input.readFloat(), input.readStringRef()); timelines.push(timeline); break; } case SLOT_RGBA: { const bezierCount = input.readInt(true); const timeline = new RGBATimeline(frameCount, bezierCount, slotIndex); let time = input.readFloat(); let r = input.readUnsignedByte() / 255; let g = input.readUnsignedByte() / 255; let b = input.readUnsignedByte() / 255; let a = input.readUnsignedByte() / 255; for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, r, g, b, a); if (frame === frameLast) break; const time2 = input.readFloat(); const r2 = input.readUnsignedByte() / 255; const g2 = input.readUnsignedByte() / 255; const b2 = input.readUnsignedByte() / 255; const a2 = input.readUnsignedByte() / 255; switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, r, r2, 1); setBezier(input, timeline, bezier++, frame, 1, time, time2, g, g2, 1); setBezier(input, timeline, bezier++, frame, 2, time, time2, b, b2, 1); setBezier(input, timeline, bezier++, frame, 3, time, time2, a, a2, 1); } time = time2; r = r2; g = g2; b = b2; a = a2; } timelines.push(timeline); break; } case SLOT_RGB: { const bezierCount = input.readInt(true); const timeline = new RGBTimeline(frameCount, bezierCount, slotIndex); let time = input.readFloat(); let r = input.readUnsignedByte() / 255; let g = input.readUnsignedByte() / 255; let b = input.readUnsignedByte() / 255; for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, r, g, b); if (frame === frameLast) break; const time2 = input.readFloat(); const r2 = input.readUnsignedByte() / 255; const g2 = input.readUnsignedByte() / 255; const b2 = input.readUnsignedByte() / 255; switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, r, r2, 1); setBezier(input, timeline, bezier++, frame, 1, time, time2, g, g2, 1); setBezier(input, timeline, bezier++, frame, 2, time, time2, b, b2, 1); } time = time2; r = r2; g = g2; b = b2; } timelines.push(timeline); break; } case SLOT_RGBA2: { const bezierCount = input.readInt(true); const timeline = new RGBA2Timeline(frameCount, bezierCount, slotIndex); let time = input.readFloat(); let r = input.readUnsignedByte() / 255; let g = input.readUnsignedByte() / 255; let b = input.readUnsignedByte() / 255; let a = input.readUnsignedByte() / 255; let r2 = input.readUnsignedByte() / 255; let g2 = input.readUnsignedByte() / 255; let b2 = input.readUnsignedByte() / 255; for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, r, g, b, a, r2, g2, b2); if (frame === frameLast) break; const time2 = input.readFloat(); const nr = input.readUnsignedByte() / 255; const ng = input.readUnsignedByte() / 255; const nb = input.readUnsignedByte() / 255; const na = input.readUnsignedByte() / 255; const nr2 = input.readUnsignedByte() / 255; const ng2 = input.readUnsignedByte() / 255; const nb2 = input.readUnsignedByte() / 255; switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, r, nr, 1); setBezier(input, timeline, bezier++, frame, 1, time, time2, g, ng, 1); setBezier(input, timeline, bezier++, frame, 2, time, time2, b, nb, 1); setBezier(input, timeline, bezier++, frame, 3, time, time2, a, na, 1); setBezier(input, timeline, bezier++, frame, 4, time, time2, r2, nr2, 1); setBezier(input, timeline, bezier++, frame, 5, time, time2, g2, ng2, 1); setBezier(input, timeline, bezier++, frame, 6, time, time2, b2, nb2, 1); } time = time2; r = nr; g = ng; b = nb; a = na; r2 = nr2; g2 = ng2; b2 = nb2; } timelines.push(timeline); break; } case SLOT_RGB2: { const bezierCount = input.readInt(true); const timeline = new RGB2Timeline(frameCount, bezierCount, slotIndex); let time = input.readFloat(); let r = input.readUnsignedByte() / 255; let g = input.readUnsignedByte() / 255; let b = input.readUnsignedByte() / 255; let r2 = input.readUnsignedByte() / 255; let g2 = input.readUnsignedByte() / 255; let b2 = input.readUnsignedByte() / 255; for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, r, g, b, r2, g2, b2); if (frame === frameLast) break; const time2 = input.readFloat(); const nr = input.readUnsignedByte() / 255; const ng = input.readUnsignedByte() / 255; const nb = input.readUnsignedByte() / 255; const nr2 = input.readUnsignedByte() / 255; const ng2 = input.readUnsignedByte() / 255; const nb2 = input.readUnsignedByte() / 255; switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, r, nr, 1); setBezier(input, timeline, bezier++, frame, 1, time, time2, g, ng, 1); setBezier(input, timeline, bezier++, frame, 2, time, time2, b, nb, 1); setBezier(input, timeline, bezier++, frame, 3, time, time2, r2, nr2, 1); setBezier(input, timeline, bezier++, frame, 4, time, time2, g2, ng2, 1); setBezier(input, timeline, bezier++, frame, 5, time, time2, b2, nb2, 1); } time = time2; r = nr; g = ng; b = nb; r2 = nr2; g2 = ng2; b2 = nb2; } timelines.push(timeline); break; } case SLOT_ALPHA: { const timeline = new AlphaTimeline(frameCount, input.readInt(true), slotIndex); let time = input.readFloat(), a = input.readUnsignedByte() / 255; for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, a); if (frame === frameLast) break; const time2 = input.readFloat(); const a2 = input.readUnsignedByte() / 255; switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, a, a2, 1); } time = time2; a = a2; } timelines.push(timeline); } } } } for (let i = 0, n = input.readInt(true); i < n; i++) { const boneIndex = input.readInt(true); for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) { const type = input.readByte(), frameCount = input.readInt(true); if (type === BONE_INHERIT) { const timeline = new InheritTimeline(frameCount, boneIndex); for (let frame = 0; frame < frameCount; frame++) { timeline.setFrame(frame, input.readFloat(), input.readByte()); } timelines.push(timeline); continue; } const bezierCount = input.readInt(true); switch (type) { case BONE_ROTATE: readTimeline(input, timelines, new RotateTimeline(frameCount, bezierCount, boneIndex), 1); break; case BONE_TRANSLATE: readTimeline(input, timelines, new TranslateTimeline(frameCount, bezierCount, boneIndex), scale); break; case BONE_TRANSLATEX: readTimeline(input, timelines, new TranslateXTimeline(frameCount, bezierCount, boneIndex), scale); break; case BONE_TRANSLATEY: readTimeline(input, timelines, new TranslateYTimeline(frameCount, bezierCount, boneIndex), scale); break; case BONE_SCALE: readTimeline(input, timelines, new ScaleTimeline(frameCount, bezierCount, boneIndex), 1); break; case BONE_SCALEX: readTimeline(input, timelines, new ScaleXTimeline(frameCount, bezierCount, boneIndex), 1); break; case BONE_SCALEY: readTimeline(input, timelines, new ScaleYTimeline(frameCount, bezierCount, boneIndex), 1); break; case BONE_SHEAR: readTimeline(input, timelines, new ShearTimeline(frameCount, bezierCount, boneIndex), 1); break; case BONE_SHEARX: readTimeline(input, timelines, new ShearXTimeline(frameCount, bezierCount, boneIndex), 1); break; case BONE_SHEARY: readTimeline(input, timelines, new ShearYTimeline(frameCount, bezierCount, boneIndex), 1); break; } } } for (let i = 0, n = input.readInt(true); i < n; i++) { const index = input.readInt(true), frameCount = input.readInt(true), frameLast = frameCount - 1; const timeline = new IkConstraintTimeline(frameCount, input.readInt(true), index); let flags = input.readByte(); let time = input.readFloat(), mix = (flags & 1) !== 0 ? (flags & 2) !== 0 ? input.readFloat() : 1 : 0; let softness = (flags & 4) !== 0 ? input.readFloat() * scale : 0; for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, mix, softness, (flags & 8) !== 0 ? 1 : -1, (flags & 16) !== 0, (flags & 32) !== 0); if (frame === frameLast) break; flags = input.readByte(); const time2 = input.readFloat(), mix2 = (flags & 1) !== 0 ? (flags & 2) !== 0 ? input.readFloat() : 1 : 0; const softness2 = (flags & 4) !== 0 ? input.readFloat() * scale : 0; if ((flags & 64) !== 0) { timeline.setStepped(frame); } else if ((flags & 128) !== 0) { setBezier(input, timeline, bezier++, frame, 0, time, time2, mix, mix2, 1); setBezier(input, timeline, bezier++, frame, 1, time, time2, softness, softness2, scale); } time = time2; mix = mix2; softness = softness2; } timelines.push(timeline); } for (let i = 0, n = input.readInt(true); i < n; i++) { const index = input.readInt(true), frameCount = input.readInt(true), frameLast = frameCount - 1; const timeline = new TransformConstraintTimeline(frameCount, input.readInt(true), index); let time = input.readFloat(), mixRotate = input.readFloat(), mixX = input.readFloat(), mixY = input.readFloat(), mixScaleX = input.readFloat(), mixScaleY = input.readFloat(), mixShearY = input.readFloat(); for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY); if (frame === frameLast) break; const time2 = input.readFloat(), mixRotate2 = input.readFloat(), mixX2 = input.readFloat(), mixY2 = input.readFloat(), mixScaleX2 = input.readFloat(), mixScaleY2 = input.readFloat(), mixShearY2 = input.readFloat(); switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1); setBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1); setBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1); setBezier(input, timeline, bezier++, frame, 3, time, time2, mixScaleX, mixScaleX2, 1); setBezier(input, timeline, bezier++, frame, 4, time, time2, mixScaleY, mixScaleY2, 1); setBezier(input, timeline, bezier++, frame, 5, time, time2, mixShearY, mixShearY2, 1); } time = time2; mixRotate = mixRotate2; mixX = mixX2; mixY = mixY2; mixScaleX = mixScaleX2; mixScaleY = mixScaleY2; mixShearY = mixShearY2; } timelines.push(timeline); } for (let i = 0, n = input.readInt(true); i < n; i++) { const index = input.readInt(true); const data = skeletonData.constraints[index]; for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) { const type = input.readByte(), frameCount = input.readInt(true), bezierCount = input.readInt(true); switch (type) { case PATH_POSITION: readTimeline( input, timelines, new PathConstraintPositionTimeline(frameCount, bezierCount, index), data.positionMode === 0 /* Fixed */ ? scale : 1 ); break; case PATH_SPACING: readTimeline( input, timelines, new PathConstraintSpacingTimeline(frameCount, bezierCount, index), data.spacingMode === 0 /* Length */ || data.spacingMode === 1 /* Fixed */ ? scale : 1 ); break; case PATH_MIX: { const timeline = new PathConstraintMixTimeline(frameCount, bezierCount, index); let time = input.readFloat(), mixRotate = input.readFloat(), mixX = input.readFloat(), mixY = input.readFloat(); for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1; ; frame++) { timeline.setFrame(frame, time, mixRotate, mixX, mixY); if (frame === frameLast) break; const time2 = input.readFloat(), mixRotate2 = input.readFloat(), mixX2 = input.readFloat(), mixY2 = input.readFloat(); switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1); setBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1); setBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1); } time = time2; mixRotate = mixRotate2; mixX = mixX2; mixY = mixY2; } timelines.push(timeline); } } } } for (let i = 0, n = input.readInt(true); i < n; i++) { const index = input.readInt(true) - 1; for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) { const type = input.readByte(), frameCount = input.readInt(true); if (type === PHYSICS_RESET) { const timeline = new PhysicsConstraintResetTimeline(frameCount, index); for (let frame = 0; frame < frameCount; frame++) timeline.setFrame(frame, input.readFloat()); timelines.push(timeline); continue; } const bezierCount = input.readInt(true); switch (type) { case PHYSICS_INERTIA: readTimeline(input, timelines, new PhysicsConstraintInertiaTimeline(frameCount, bezierCount, index), 1); break; case PHYSICS_STRENGTH: readTimeline(input, timelines, new PhysicsConstraintStrengthTimeline(frameCount, bezierCount, index), 1); break; case PHYSICS_DAMPING: readTimeline(input, timelines, new PhysicsConstraintDampingTimeline(frameCount, bezierCount, index), 1); break; case PHYSICS_MASS: readTimeline(input, timelines, new PhysicsConstraintMassTimeline(frameCount, bezierCount, index), 1); break; case PHYSICS_WIND: readTimeline(input, timelines, new PhysicsConstraintWindTimeline(frameCount, bezierCount, index), 1); break; case PHYSICS_GRAVITY: readTimeline(input, timelines, new PhysicsConstraintGravityTimeline(frameCount, bezierCount, index), 1); break; case PHYSICS_MIX: readTimeline(input, timelines, new PhysicsConstraintMixTimeline(frameCount, bezierCount, index), 1); break; default: throw new Error("Unknown physics timeline type."); } } } for (let i = 0, n = input.readInt(true); i < n; i++) { const index = input.readInt(true); for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) { const type = input.readByte(), frameCount = input.readInt(true), bezierCount = input.readInt(true); switch (type) { case SLIDER_TIME: readTimeline(input, timelines, new SliderTimeline(frameCount, bezierCount, index), 1); break; case SLIDER_MIX: readTimeline(input, timelines, new SliderMixTimeline(frameCount, bezierCount, index), 1); break; default: throw new Error(`Uknown slider type: ${type}`); } } } for (let i = 0, n = input.readInt(true); i < n; i++) { const skin = skeletonData.skins[input.readInt(true)]; for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) { const slotIndex = input.readInt(true); for (let iii = 0, nnn = input.readInt(true); iii < nnn; iii++) { const attachmentName = input.readStringRef(); if (!attachmentName) throw new Error("attachmentName must not be null."); const attachment = skin.getAttachment(slotIndex, attachmentName); const timelineType = input.readByte(); const frameCount = input.readInt(true); const frameLast = frameCount - 1; switch (timelineType) { case ATTACHMENT_DEFORM: { const vertexAttachment = attachment; const weighted = vertexAttachment.bones; const vertices = vertexAttachment.vertices; const deformLength = weighted ? vertices.length / 3 * 2 : vertices.length; const bezierCount = input.readInt(true); const timeline = new DeformTimeline(frameCount, bezierCount, slotIndex, vertexAttachment); let time = input.readFloat(); for (let frame = 0, bezier = 0; ; frame++) { let deform; let end = input.readInt(true); if (end === 0) deform = weighted ? Utils.newFloatArray(deformLength) : vertices; else { deform = Utils.newFloatArray(deformLength); const start = input.readInt(true); end += start; if (scale === 1) { for (let v = start; v < end; v++) deform[v] = input.readFloat(); } else { for (let v = start; v < end; v++) deform[v] = input.readFloat() * scale; } if (!weighted) { for (let v = 0, vn = deform.length; v < vn; v++) deform[v] += vertices[v]; } } timeline.setFrame(frame, time, deform); if (frame === frameLast) break; const time2 = input.readFloat(); switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, 0, 1, 1); } time = time2; } timelines.push(timeline); break; } case ATTACHMENT_SEQUENCE: { const timeline = new SequenceTimeline(frameCount, slotIndex, attachment); for (let frame = 0; frame < frameCount; frame++) { const time = input.readFloat(); const modeAndIndex = input.readInt32(); timeline.setFrame( frame, time, SequenceModeValues[modeAndIndex & 15], modeAndIndex >> 4, input.readFloat() ); } timelines.push(timeline); break; } } } } } const slotCount = skeletonData.slots.length; const drawOrderCount = input.readInt(true); if (drawOrderCount > 0) { const timeline = new DrawOrderTimeline(drawOrderCount); for (let i = 0; i < drawOrderCount; i++) timeline.setFrame(i, input.readFloat(), readDrawOrder(input, slotCount)); timelines.push(timeline); } const folderCount = input.readInt(true); for (let i = 0; i < folderCount; i++) { const folderSlotCount = input.readInt(true); const folderSlots = new Array(folderSlotCount); for (let ii = 0; ii < folderSlotCount; ii++) folderSlots[ii] = input.readInt(true); const keyCount = input.readInt(true); const timeline = new DrawOrderFolderTimeline(keyCount, folderSlots, slotCount); for (let ii = 0; ii < keyCount; ii++) timeline.setFrame(ii, input.readFloat(), readDrawOrder(input, folderSlotCount)); timelines.push(timeline); } const eventCount = input.readInt(true); if (eventCount > 0) { const timeline = new EventTimeline(eventCount); for (let i = 0; i < eventCount; i++) { const time = input.readFloat(); const eventData = skeletonData.events[input.readInt(true)]; const event = new Event(time, eventData); event.intValue = input.readInt(false); event.floatValue = input.readFloat(); event.stringValue = input.readString(); if (event.stringValue == null) event.stringValue = eventData.setupPose.stringValue; if (event.data.audioPath) { event.volume = input.readFloat(); event.balance = input.readFloat(); } timeline.setFrame(i, event); } timelines.push(timeline); } let duration = 0; for (let i = 0, n = timelines.length; i < n; i++) duration = Math.max(duration, timelines[i].getDuration()); const animation = new Animation(name, timelines, duration); if (nonessential) Color.rgba8888ToColor(animation.color, input.readInt32()); return animation; } }; var BinaryInput = class { constructor(data, strings = [], index = 0, buffer = new DataView(data instanceof ArrayBuffer ? data : data.buffer)) { this.strings = strings; this.index = index; this.buffer = buffer; } readByte() { return this.buffer.getInt8(this.index++); } readUnsignedByte() { return this.buffer.getUint8(this.index++); } readShort() { const value = this.buffer.getInt16(this.index); this.index += 2; return value; } readInt32() { const value = this.buffer.getInt32(this.index); this.index += 4; return value; } readInt(optimizePositive) { let b = this.readByte(); let result = b & 127; if ((b & 128) !== 0) { b = this.readByte(); result |= (b & 127) << 7; if ((b & 128) !== 0) { b = this.readByte(); result |= (b & 127) << 14; if ((b & 128) !== 0) { b = this.readByte(); result |= (b & 127) << 21; if ((b & 128) !== 0) { b = this.readByte(); result |= (b & 127) << 28; } } } } return optimizePositive ? result : result >>> 1 ^ -(result & 1); } readStringRef() { const index = this.readInt(true); return index === 0 ? null : this.strings[index - 1]; } readString() { let byteCount = this.readInt(true); switch (byteCount) { case 0: return null; case 1: return ""; } byteCount--; let chars = ""; for (let i = 0; i < byteCount; ) { const b = this.readUnsignedByte(); switch (b >> 4) { case 12: case 13: chars += String.fromCharCode((b & 31) << 6 | this.readByte() & 63); i += 2; break; case 14: chars += String.fromCharCode((b & 15) << 12 | (this.readByte() & 63) << 6 | this.readByte() & 63); i += 3; break; default: chars += String.fromCharCode(b); i++; } } return chars; } readFloat() { const value = this.buffer.getFloat32(this.index); this.index += 4; return value; } readBoolean() { return this.readByte() !== 0; } }; var LinkedMesh = class { source; skinIndex; slotIndex; sourceIndex; mesh; inheritTimelines; constructor(mesh, skinIndex, slotIndex, sourceIndex, source, inheritTimelines) { this.mesh = mesh; this.skinIndex = skinIndex; this.slotIndex = slotIndex; this.sourceIndex = sourceIndex; this.source = source; this.inheritTimelines = inheritTimelines; } }; var Vertices = class { constructor(bones = null, vertices, length = 0) { this.bones = bones; this.vertices = vertices; this.length = length; } }; function readTimeline(input, timelines, timeline, scale) { if (timeline instanceof CurveTimeline1) readTimeline1(input, timelines, timeline, scale); else readTimeline2(input, timelines, timeline, scale); } function readTimeline1(input, timelines, timeline, scale) { let time = input.readFloat(), value = input.readFloat() * scale; for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1; ; frame++) { timeline.setFrame(frame, time, value); if (frame === frameLast) break; const time2 = input.readFloat(), value2 = input.readFloat() * scale; switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, value, value2, scale); } time = time2; value = value2; } timelines.push(timeline); } function readTimeline2(input, timelines, timeline, scale) { let time = input.readFloat(), value1 = input.readFloat() * scale, value2 = input.readFloat() * scale; for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1; ; frame++) { timeline.setFrame(frame, time, value1, value2); if (frame === frameLast) break; const time2 = input.readFloat(), nvalue1 = input.readFloat() * scale, nvalue2 = input.readFloat() * scale; switch (input.readByte()) { case CURVE_STEPPED: timeline.setStepped(frame); break; case CURVE_BEZIER: setBezier(input, timeline, bezier++, frame, 0, time, time2, value1, nvalue1, scale); setBezier(input, timeline, bezier++, frame, 1, time, time2, value2, nvalue2, scale); } time = time2; value1 = nvalue1; value2 = nvalue2; } timelines.push(timeline); } function readDrawOrder(input, slotCount) { const changeCount = input.readInt(true); if (changeCount === 0) return null; const drawOrder = new Array(slotCount).fill(-1); const unchanged = new Array(slotCount - changeCount); let originalIndex = 0, unchangedIndex = 0; for (let i = 0; i < changeCount; i++) { const slotIndex = input.readInt(true); while (originalIndex !== slotIndex) unchanged[unchangedIndex++] = originalIndex++; drawOrder[originalIndex + input.readInt(true)] = originalIndex++; } while (originalIndex < slotCount) unchanged[unchangedIndex++] = originalIndex++; for (let i = slotCount - 1; i >= 0; i--) if (drawOrder[i] === -1) drawOrder[i] = unchanged[--unchangedIndex]; return drawOrder; } function setBezier(input, timeline, bezier, frame, value, time1, time2, value1, value2, scale) { timeline.setBezier(bezier, frame, value, time1, value1, input.readFloat(), input.readFloat() * scale, input.readFloat(), input.readFloat() * scale, time2, value2); } var BONE_ROTATE = 0; var BONE_TRANSLATE = 1; var BONE_TRANSLATEX = 2; var BONE_TRANSLATEY = 3; var BONE_SCALE = 4; var BONE_SCALEX = 5; var BONE_SCALEY = 6; var BONE_SHEAR = 7; var BONE_SHEARX = 8; var BONE_SHEARY = 9; var BONE_INHERIT = 10; var SLOT_ATTACHMENT = 0; var SLOT_RGBA = 1; var SLOT_RGB = 2; var SLOT_RGBA2 = 3; var SLOT_RGB2 = 4; var SLOT_ALPHA = 5; var CONSTRAINT_IK = 0; var CONSTRAINT_PATH = 1; var CONSTRAINT_TRANSFORM = 2; var CONSTRAINT_PHYSICS = 3; var CONSTRAINT_SLIDER = 4; var ATTACHMENT_DEFORM = 0; var ATTACHMENT_SEQUENCE = 1; var PATH_POSITION = 0; var PATH_SPACING = 1; var PATH_MIX = 2; var PHYSICS_INERTIA = 0; var PHYSICS_STRENGTH = 1; var PHYSICS_DAMPING = 2; var PHYSICS_MASS = 4; var PHYSICS_WIND = 5; var PHYSICS_GRAVITY = 6; var PHYSICS_MIX = 7; var PHYSICS_RESET = 8; var SLIDER_TIME = 0; var SLIDER_MIX = 1; var CURVE_STEPPED = 1; var CURVE_BEZIER = 2; // spine-core/src/SkeletonBounds.ts var SkeletonBounds = class { /** The left edge of the axis aligned bounding box. */ minX = 0; /** The bottom edge of the axis aligned bounding box. */ minY = 0; /** The right edge of the axis aligned bounding box. */ maxX = 0; /** The top edge of the axis aligned bounding box. */ maxY = 0; /** The visible bounding boxes. */ boundingBoxes = []; /** The world vertices for the bounding box polygons. */ polygons = []; polygonPool = new Pool(() => { return Utils.newFloatArray(16); }); /** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding * box's polygon. * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the * SkeletonBounds AABB methods will always return true. */ update(skeleton, updateAabb) { if (!skeleton) throw new Error("skeleton cannot be null."); const boundingBoxes = this.boundingBoxes; const polygons = this.polygons; const polygonPool = this.polygonPool; const slots = skeleton.slots; const slotCount = slots.length; boundingBoxes.length = 0; polygonPool.freeAll(polygons); polygons.length = 0; for (let i = 0; i < slotCount; i++) { const slot = slots[i]; if (!slot.bone.active) continue; const attachment = slot.appliedPose.attachment; if (attachment instanceof BoundingBoxAttachment) { boundingBoxes.push(attachment); let polygon = polygonPool.obtain(); if (polygon.length !== attachment.worldVerticesLength) { polygon = Utils.newFloatArray(attachment.worldVerticesLength); } polygons.push(polygon); attachment.computeWorldVertices(skeleton, slot, 0, attachment.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; } } aabbCompute() { let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY; const polygons = this.polygons; for (let i = 0, n = polygons.length; i < n; i++) { const polygon = polygons[i]; const vertices = polygon; for (let ii = 0, nn = polygon.length; ii < nn; ii += 2) { const x = vertices[ii]; const 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; } /** Returns true if the axis aligned bounding box contains the point. */ aabbContainsPoint(x, y) { return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY; } /** Returns true if the axis aligned bounding box intersects the line segment. */ aabbIntersectsSegment(x1, y1, x2, y2) { const minX = this.minX; const minY = this.minY; const maxX = this.maxX; const maxY = this.maxY; if (x1 <= minX && x2 <= minX || y1 <= minY && y2 <= minY || x1 >= maxX && x2 >= maxX || y1 >= maxY && y2 >= maxY) return false; const m = (y2 - y1) / (x2 - x1); let y = m * (minX - x1) + y1; if (y > minY && y < maxY) return true; y = m * (maxX - x1) + y1; if (y > minY && y < maxY) return true; let 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; } /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */ aabbIntersectsSkeleton(bounds) { return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY > bounds.minY; } /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more * efficient to only call this method if {@link aabbContainsPoint} returns true. */ containsPoint(x, y) { const polygons = this.polygons; for (let i = 0, n = polygons.length; i < n; i++) if (this.containsPointPolygon(polygons[i], x, y)) return this.boundingBoxes[i]; return null; } /** Returns true if the polygon contains the point. */ containsPointPolygon(polygon, x, y) { const vertices = polygon; const nn = polygon.length; let prevIndex = nn - 2; let inside = false; for (let ii = 0; ii < nn; ii += 2) { const vertexY = vertices[ii + 1]; const prevY = vertices[prevIndex + 1]; if (vertexY < y && prevY >= y || prevY < y && vertexY >= y) { const vertexX = vertices[ii]; if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside; } prevIndex = ii; } return inside; } /** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it * is usually more efficient to only call this method if {@link aabbIntersectsSegment} returns * true. */ intersectsSegment(x1, y1, x2, y2) { const polygons = this.polygons; for (let i = 0, n = polygons.length; i < n; i++) if (this.intersectsSegmentPolygon(polygons[i], x1, y1, x2, y2)) return this.boundingBoxes[i]; return null; } /** Returns true if the polygon contains any part of the line segment. */ intersectsSegmentPolygon(polygon, x1, y1, x2, y2) { const vertices = polygon; const nn = polygon.length; const width12 = x1 - x2, height12 = y1 - y2; const det1 = x1 * y2 - y1 * x2; let x3 = vertices[nn - 2], y3 = vertices[nn - 1]; for (let ii = 0; ii < nn; ii += 2) { const x4 = vertices[ii], y4 = vertices[ii + 1]; const det2 = x3 * y4 - y3 * x4; const width34 = x3 - x4, height34 = y3 - y4; const det3 = width12 * height34 - height12 * width34; const x = (det1 * width34 - width12 * det2) / det3; if ((x >= x3 && x <= x4 || x >= x4 && x <= x3) && (x >= x1 && x <= x2 || x >= x2 && x <= x1)) { const 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; } /** Returns the polygon for the specified bounding box, or null. */ getPolygon(boundingBox) { if (!boundingBox) throw new Error("boundingBox cannot be null."); const index = this.boundingBoxes.indexOf(boundingBox); return index === -1 ? null : this.polygons[index]; } /** The width of the axis aligned bounding box. */ getWidth() { return this.maxX - this.minX; } /** The height of the axis aligned bounding box. */ getHeight() { return this.maxY - this.minY; } }; // spine-core/src/Triangulator.ts var Triangulator = class _Triangulator { convexPolygons = []; convexPolygonsIndices = []; indicesArray = []; isConcaveArray = []; triangles = []; polygonPool = new Pool(() => { return []; }); polygonIndicesPool = new Pool(() => { return []; }); triangulate(verticesArray) { const vertices = verticesArray; let vertexCount = verticesArray.length >> 1; const indices = this.indicesArray; indices.length = 0; for (let i = 0; i < vertexCount; i++) indices[i] = i; const isConcave = this.isConcaveArray; isConcave.length = 0; for (let i = 0; i < vertexCount; i++) isConcave[i] = _Triangulator.isConcave(i, vertexCount, vertices, indices); const triangles = this.triangles; triangles.length = 0; while (vertexCount > 3) { let previous = vertexCount - 1, i = 0, next = 1; while (true) { outer: if (!isConcave[i]) { const p1 = indices[previous] << 1, p2 = indices[i] << 1, p3 = indices[next] << 1; const p1x = vertices[p1], p1y = vertices[p1 + 1]; const p2x = vertices[p2], p2y = vertices[p2 + 1]; const p3x = vertices[p3], p3y = vertices[p3 + 1]; for (let ii = next + 1 < vertexCount ? next + 1 : 0; ii !== previous; ) { if (isConcave[ii]) { const v = indices[ii] << 1; const vx = vertices[v], vy = vertices[v + 1]; if (_Triangulator.positiveArea(p3x, p3y, p1x, p1y, vx, vy) && _Triangulator.positiveArea(p1x, p1y, p2x, p2y, vx, vy) && _Triangulator.positiveArea(p2x, p2y, p3x, p3y, vx, vy)) break outer; } if (++ii === vertexCount) ii = 0; } break; } if (next === 0) { do { if (!isConcave[i]) break; i--; } while (i > 0); previous = i > 0 ? i - 1 : vertexCount - 1; next = i + 1 < vertexCount ? i + 1 : 0; break; } previous = i; i = next; if (++next === vertexCount) next = 0; } triangles.push(indices[previous], indices[i], indices[next]); indices.splice(i, 1); isConcave.splice(i, 1); vertexCount--; const previousIndex = i > 0 ? i - 1 : vertexCount - 1; const nextIndex = i < vertexCount ? i : 0; isConcave[previousIndex] = _Triangulator.isConcave(previousIndex, vertexCount, vertices, indices); isConcave[nextIndex] = _Triangulator.isConcave(nextIndex, vertexCount, vertices, indices); } if (vertexCount === 3) triangles.push(indices[2], indices[0], indices[1]); return triangles; } decompose(verticesArray, triangles) { const vertices = verticesArray; const convexPolygons = this.convexPolygons; this.polygonPool.freeAll(convexPolygons); convexPolygons.length = 0; const convexPolygonsIndices = this.convexPolygonsIndices; this.polygonIndicesPool.freeAll(convexPolygonsIndices); convexPolygonsIndices.length = 0; let polygonIndices = this.polygonIndicesPool.obtain(); polygonIndices.length = 0; let polygon = this.polygonPool.obtain(); polygon.length = 0; let fanBaseIndex = -1, lastWinding = 0; for (let i = 0, n = triangles.length; i < n; i += 3) { const t1 = triangles[i] << 1, t2 = triangles[i + 1] << 1, t3 = triangles[i + 2] << 1; const x1 = vertices[t1], y1 = vertices[t1 + 1]; const x2 = vertices[t2], y2 = vertices[t2 + 1]; const x3 = vertices[t3], y3 = vertices[t3 + 1]; if (fanBaseIndex === t1) { const o = polygon.length - 4; if (_Triangulator.winding(polygon[o], polygon[o + 1], polygon[o + 2], polygon[o + 3], x3, y3) === lastWinding && _Triangulator.winding(x3, y3, polygon[0], polygon[1], polygon[2], polygon[3]) === lastWinding) { polygon.push(x3, y3); polygonIndices.push(t3); continue; } } if (polygon.length > 0) { convexPolygons.push(polygon); convexPolygonsIndices.push(polygonIndices); polygon = this.polygonPool.obtain(); polygonIndices = this.polygonIndicesPool.obtain(); } polygon.length = 0; polygon.push(x1, y1, x2, y2); polygon.push(x3, y3); polygonIndices.length = 0; polygonIndices.push(t1, t2, t3); lastWinding = _Triangulator.winding(x1, y1, x2, y2, x3, y3); fanBaseIndex = t1; } if (polygon.length > 0) { convexPolygons.push(polygon); convexPolygonsIndices.push(polygonIndices); } for (let i = 0, n = convexPolygons.length; i < n; i++) { polygonIndices = convexPolygonsIndices[i]; if (polygonIndices.length === 0) continue; const firstIndex = polygonIndices[0]; let lastIndex = polygonIndices[polygonIndices.length - 1]; polygon = convexPolygons[i]; const o = polygon.length - 4; let prevPrevX = polygon[o], prevPrevY = polygon[o + 1]; let prevX = polygon[o + 2], prevY = polygon[o + 3]; const firstX = polygon[0], firstY = polygon[1]; const secondX = polygon[2], secondY = polygon[3]; const winding = _Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, firstX, firstY); for (let ii = 0; ii < n; ii++) { if (ii === i) continue; const otherIndices = convexPolygonsIndices[ii]; if (otherIndices.length !== 3) continue; const otherFirstIndex = otherIndices[0]; const otherSecondIndex = otherIndices[1]; const otherLastIndex = otherIndices[2]; const otherPoly = convexPolygons[ii]; const x3 = otherPoly[otherPoly.length - 2], y3 = otherPoly[otherPoly.length - 1]; if (otherFirstIndex !== firstIndex || otherSecondIndex !== lastIndex) continue; if (_Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, x3, y3) === winding && _Triangulator.winding(x3, y3, firstX, firstY, secondX, secondY) === winding) { otherPoly.length = 0; otherIndices.length = 0; polygon.push(x3, y3); polygonIndices.push(otherLastIndex); lastIndex = otherLastIndex; prevPrevX = prevX; prevPrevY = prevY; prevX = x3; prevY = y3; ii = -1; } } } for (let 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); } else polygon.push(polygon[0], polygon[1]); } return convexPolygons; } static isConcave(index, vertexCount, vertices, indices) { const previous = indices[index > 0 ? index - 1 : vertexCount - 1] << 1; const current = indices[index] << 1; const next = indices[index + 1 < vertexCount ? index + 1 : 0] << 1; return !_Triangulator.positiveArea( vertices[previous], vertices[previous + 1], vertices[current], vertices[current + 1], vertices[next], vertices[next + 1] ); } static positiveArea(p1x, p1y, p2x, p2y, p3x, p3y) { return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0; } static winding(p1x, p1y, p2x, p2y, p3x, p3y) { return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0 ? 1 : -1; } }; // spine-core/src/SkeletonClipping.ts var SkeletonClipping = class { triangulator = null; clippingPolygon = []; clippingPolygons = []; clipOutput = []; clippedVertices = []; /** An empty array unless {@link clipTrianglesUnpacked} was used. **/ clippedUVs = []; clippedTriangles = []; inverseVertices = []; _clippedVerticesTyped = new Float32Array(1024); _clippedUVsTyped = new Float32Array(1024); _clippedTrianglesTyped = new Uint16Array(1024); clippedVerticesTyped = new Float32Array(0); clippedUVsTyped = new Float32Array(0); clippedTrianglesTyped = new Uint16Array(0); clippedVerticesLength = 0; clippedUVsLength = 0; clippedTrianglesLength = 0; scratch = []; inverse = false; clipAttachment = null; clipStart(skeleton, slot, clip) { if (this.clipAttachment) return; const n = clip.worldVerticesLength; this.clipAttachment = clip; this.inverse = clip.inverse; const vertices = Utils.setArraySize(this.clippingPolygon, n); clip.computeWorldVertices(skeleton, slot, 0, n, vertices, 0, 2); const clippingPolygon = this.clippingPolygon; const convex = this.makeClockwise(clippingPolygon); if (convex || this.inverse || clip.convex) { if (!convex) this.makeConvex(clippingPolygon); this.clippingPolygon.push(clippingPolygon[0], clippingPolygon[1]); this.clippingPolygons.push(clippingPolygon); } else { if (this.triangulator === null) this.triangulator = new Triangulator(); this.clippingPolygons.push(...this.triangulator.decompose(clippingPolygon, this.triangulator.triangulate(clippingPolygon))); } } clipEnd(slot) { if (!this.clipAttachment) return; if (slot && this.clipAttachment.endSlot !== slot.data) return; this.clipAttachment = null; this.clippingPolygons.length = 0; } isClipping() { return this.clipAttachment != null; } clipTriangles(vertices, triangles, trianglesLength, uvs, light, dark, twoColor, stride) { return uvs && light && dark && typeof twoColor === "boolean" && typeof stride === "number" ? this.clipTrianglesRender(vertices, triangles, trianglesLength, uvs, light, dark, twoColor, stride) : this.clipTrianglesNoRender(vertices, triangles, trianglesLength); } clipTrianglesNoRender(vertices, triangles, trianglesLength) { const clippedVertices = this.clippedVertices; clippedVertices.length = 0; const clippedTriangles = this.clippedTriangles; clippedTriangles.length = 0; let index = 0; if (this.inverse) { const polygon = this.clippingPolygons[0]; for (let i = 0; i < trianglesLength; i += 3) { let t = triangles[i] << 1; const x1 = vertices[t], y1 = vertices[t + 1]; t = triangles[i + 1] << 1; const x2 = vertices[t], y2 = vertices[t + 1]; t = triangles[i + 2] << 1; const x3 = vertices[t], y3 = vertices[t + 1]; this.clipInverse(x1, y1, x2, y2, x3, y3, polygon); const iv = this.inverseVertices; for (let offset = 0, nn = this.inverseVertices.length; offset < nn; ) { const polygonSize = iv[offset++]; let vertexCount = polygonSize >> 1, s = clippedVertices.length; const cv = Utils.setArraySize(clippedVertices, s + polygonSize); Utils.arrayCopy(iv, offset, cv, s, polygonSize); s = clippedTriangles.length; const ct = Utils.setArraySize(clippedTriangles, s + 3 * (vertexCount - 2)); for (let ii = 1; ii < vertexCount - 1; ii++, s += 3) { ct[s] = index; ct[s + 1] = index + ii; ct[s + 2] = index + ii + 1; } index += vertexCount; offset += polygonSize; } } return true; } const clipOutput = this.clipOutput; const polygons = this.clippingPolygons; const polygonsCount = polygons.length; let clipOutputItems = null; for (let i = 0; i < trianglesLength; i += 3) { let t = triangles[i] << 1; const x1 = vertices[t], y1 = vertices[t + 1]; t = triangles[i + 1] << 1; const x2 = vertices[t], y2 = vertices[t + 1]; t = triangles[i + 2] << 1; const x3 = vertices[t], y3 = vertices[t + 1]; for (let p = 0; p < polygonsCount; p++) { let s = clippedVertices.length; if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p])) { clipOutputItems = this.clipOutput; const clipOutputLength = clipOutput.length; if (clipOutputLength === 0) continue; let clipOutputCount = clipOutputLength >> 1; const cv = Utils.setArraySize(clippedVertices, s + clipOutputLength); Utils.arrayCopy(clipOutputItems, 0, cv, s, clipOutputLength); s = clippedTriangles.length; const ct = Utils.setArraySize(clippedTriangles, s + 3 * (clipOutputCount - 2)); clipOutputCount--; for (let ii = 1; ii < clipOutputCount; ii++, s += 3) { ct[s] = index; ct[s + 1] = index + ii; ct[s + 2] = index + ii + 1; } index += clipOutputCount; } else { const cv = Utils.setArraySize(clippedVertices, s + 3 * 2); cv[s] = x1; cv[s + 1] = y1; cv[s + 2] = x2; cv[s + 3] = y2; cv[s + 4] = x3; cv[s + 5] = y3; s = clippedTriangles.length; const ct = Utils.setArraySize(clippedTriangles, s + 3); ct[s] = index; ct[s + 1] = index + 1; ct[s + 2] = index + 2; index += 3; break; } } } return clipOutputItems != null; } clipTrianglesRender(vertices, triangles, trianglesLength, uvs, light, dark, twoColor, stride) { const clippedVertices = this.clippedVertices; clippedVertices.length = 0; const clippedTriangles = this.clippedTriangles; clippedTriangles.length = 0; let index = 0; if (this.inverse) { const polygon = this.clippingPolygons[0]; for (let i = 0; i < trianglesLength; i += 3) { let t0 = triangles[i], t1 = triangles[i + 1], t2 = triangles[i + 2]; const x1 = vertices[t0 * stride], y1 = vertices[t0 * stride + 1]; const x2 = vertices[t1 * stride], y2 = vertices[t1 * stride + 1]; const x3 = vertices[t2 * stride], y3 = vertices[t2 * stride + 1]; this.clipInverse(x1, y1, x2, y2, x3, y3, polygon); const nn = this.inverseVertices.length; if (nn === 0) continue; const u1 = uvs[t0 <<= 1], v1 = uvs[t0 + 1]; const u2 = uvs[t1 <<= 1], v2 = uvs[t1 + 1]; const u3 = uvs[t2 <<= 1], v3 = uvs[t2 + 1]; const d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1, d = 1 / (d0 * d2 + d1 * (y1 - y3)); const iv = this.inverseVertices; for (let offset = 0; offset < nn; ) { const polygonSize = iv[offset++]; const vertexCount = polygonSize >> 1; let s = clippedVertices.length; const cv = Utils.setArraySize(clippedVertices, s + vertexCount * stride); for (let ii = 0; ii < polygonSize; ii += 2, s += stride) { const x = iv[offset + ii], y = iv[offset + ii + 1]; cv[s] = x; cv[s + 1] = y; cv[s + 2] = light.r; cv[s + 3] = light.g; cv[s + 4] = light.b; cv[s + 5] = light.a; const c0 = x - x3, c1 = y - y3, a = (d0 * c0 + d1 * c1) * d, b = (d4 * c0 + d2 * c1) * d, c = 1 - a - b; cv[s + 6] = u1 * a + u2 * b + u3 * c; cv[s + 7] = v1 * a + v2 * b + v3 * c; if (twoColor) { cv[s + 8] = dark.r; cv[s + 9] = dark.g; cv[s + 10] = dark.b; cv[s + 11] = dark.a; } } s = clippedTriangles.length; const ct = Utils.setArraySize(clippedTriangles, s + 3 * (vertexCount - 2)); for (let ii = 1; ii < vertexCount - 1; ii++, s += 3) { ct[s] = index; ct[s + 1] = index + ii; ct[s + 2] = index + ii + 1; } index += vertexCount; offset += polygonSize; } } return true; } const clipOutput = this.clipOutput; const polygons = this.clippingPolygons; const polygonsCount = this.clippingPolygons.length; let clipOutputItems = null; for (let i = 0; i < trianglesLength; i += 3) { let t = triangles[i]; const x1 = vertices[t * stride], y1 = vertices[t * stride + 1]; const u1 = uvs[t << 1], v1 = uvs[(t << 1) + 1]; t = triangles[i + 1]; const x2 = vertices[t * stride], y2 = vertices[t * stride + 1]; const u2 = uvs[t << 1], v2 = uvs[(t << 1) + 1]; t = triangles[i + 2]; const x3 = vertices[t * stride], y3 = vertices[t * stride + 1]; const u3 = uvs[t << 1], v3 = uvs[(t << 1) + 1]; let d0 = 0, d1 = 0, d2 = 0, d4 = 0, d = 0; for (let p = 0; p < polygonsCount; p++) { let s = clippedVertices.length; if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p])) { clipOutputItems = this.clipOutput; const clipOutputLength = clipOutput.length; if (clipOutputLength === 0) continue; let clipOutputCount = clipOutputLength >> 1; if (d === 0) { d0 = y2 - y3; d1 = x3 - x2; d2 = x1 - x3; d4 = y3 - y1; d = 1 / (d0 * d2 - d1 * d4); } const cv = Utils.setArraySize(clippedVertices, s + clipOutputCount * stride); for (let ii = 0; ii < clipOutputLength; ii += 2, s += stride) { const x = clipOutputItems[ii], y = clipOutputItems[ii + 1]; cv[s] = x; cv[s + 1] = y; cv[s + 2] = light.r; cv[s + 3] = light.g; cv[s + 4] = light.b; cv[s + 5] = light.a; const c0 = x - x3, c1 = y - y3, a = (d0 * c0 + d1 * c1) * d, b = (d4 * c0 + d2 * c1) * d, c = 1 - a - b; cv[s + 6] = u1 * a + u2 * b + u3 * c; cv[s + 7] = v1 * a + v2 * b + v3 * c; if (twoColor) { cv[s + 8] = dark.r; cv[s + 9] = dark.g; cv[s + 10] = dark.b; cv[s + 11] = dark.a; } } s = clippedTriangles.length; const ct = Utils.setArraySize(clippedTriangles, s + 3 * (clipOutputCount - 2)); clipOutputCount--; for (let ii = 1; ii < clipOutputCount; ii++, s += 3) { ct[s] = index; ct[s + 1] = index + ii; ct[s + 2] = index + ii + 1; } index += clipOutputCount + 1; } else { const cv = Utils.setArraySize(clippedVertices, s + 3 * stride); cv[s] = x1; cv[s + 1] = y1; cv[s + 2] = light.r; cv[s + 3] = light.g; cv[s + 4] = light.b; cv[s + 5] = light.a; if (!twoColor) { cv[s + 6] = u1; cv[s + 7] = v1; cv[s + 8] = x2; cv[s + 9] = y2; cv[s + 10] = light.r; cv[s + 11] = light.g; cv[s + 12] = light.b; cv[s + 13] = light.a; cv[s + 14] = u2; cv[s + 15] = v2; cv[s + 16] = x3; cv[s + 17] = y3; cv[s + 18] = light.r; cv[s + 19] = light.g; cv[s + 20] = light.b; cv[s + 21] = light.a; cv[s + 22] = u3; cv[s + 23] = v3; } else { cv[s + 6] = u1; cv[s + 7] = v1; cv[s + 8] = dark.r; cv[s + 9] = dark.g; cv[s + 10] = dark.b; cv[s + 11] = dark.a; cv[s + 12] = x2; cv[s + 13] = y2; cv[s + 14] = light.r; cv[s + 15] = light.g; cv[s + 16] = light.b; cv[s + 17] = light.a; cv[s + 18] = u2; cv[s + 19] = v2; cv[s + 20] = dark.r; cv[s + 21] = dark.g; cv[s + 22] = dark.b; cv[s + 23] = dark.a; cv[s + 24] = x3; cv[s + 25] = y3; cv[s + 26] = light.r; cv[s + 27] = light.g; cv[s + 28] = light.b; cv[s + 29] = light.a; cv[s + 30] = u3; cv[s + 31] = v3; cv[s + 32] = dark.r; cv[s + 33] = dark.g; cv[s + 34] = dark.b; cv[s + 35] = dark.a; } s = clippedTriangles.length; const ct = Utils.setArraySize(clippedTriangles, s + 3); ct[s] = index; ct[s + 1] = index + 1; ct[s + 2] = index + 2; index += 3; break; } } } return clipOutputItems != null; } clipTrianglesUnpacked(vertices, vertexStart, triangles, trianglesLength, uvs, stride = 2) { let clippedVertices = this._clippedVerticesTyped; let clippedUVs = this._clippedUVsTyped; let clippedTriangles = this._clippedTrianglesTyped; let index = 0; this.clippedVerticesLength = 0; this.clippedUVsLength = 0; this.clippedTrianglesLength = 0; if (this.inverse) { const polygon = this.clippingPolygons[0]; for (let i = 0; i < trianglesLength; i += 3) { let v = triangles[i] * stride; const x1 = vertices[vertexStart + v], y1 = vertices[vertexStart + v + 1]; let uv = triangles[i] << 1; const u1 = uvs[uv], v1 = uvs[uv + 1]; v = triangles[i + 1] * stride; const x2 = vertices[vertexStart + v], y2 = vertices[vertexStart + v + 1]; uv = triangles[i + 1] << 1; const u2 = uvs[uv], v2 = uvs[uv + 1]; v = triangles[i + 2] * stride; const x3 = vertices[vertexStart + v], y3 = vertices[vertexStart + v + 1]; uv = triangles[i + 2] << 1; const u3 = uvs[uv], v3 = uvs[uv + 1]; this.clipInverse(x1, y1, x2, y2, x3, y3, polygon); const nn = this.inverseVertices.length; if (nn === 0) continue; const d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1, d = 1 / (d0 * d2 + d1 * (y1 - y3)); const iv = this.inverseVertices; for (let offset = 0; offset < nn; ) { const polygonSize = iv[offset++]; const vertexCount = polygonSize >> 1; let s = this.clippedVerticesLength; const newLength = s + vertexCount * stride; const newUVLength = this.clippedUVsLength + vertexCount * 2; if (clippedVertices.length < newLength) { this._clippedVerticesTyped = new Float32Array(newLength * 2); this._clippedVerticesTyped.set(clippedVertices.subarray(0, s)); clippedVertices = this._clippedVerticesTyped; } if (clippedUVs.length < newUVLength) { this._clippedUVsTyped = new Float32Array(newUVLength * 2); this._clippedUVsTyped.set(clippedUVs.subarray(0, this.clippedUVsLength)); clippedUVs = this._clippedUVsTyped; } this.clippedVerticesLength = newLength; this.clippedUVsLength = newUVLength; const cv = this._clippedVerticesTyped; const cu = this._clippedUVsTyped; let uvIndex = newUVLength - vertexCount * 2; for (let ii = 0; ii < polygonSize; ii += 2, s += stride, uvIndex += 2) { const x = iv[offset + ii], y = iv[offset + ii + 1]; cv[s] = x; cv[s + 1] = y; const c0 = x - x3, c1 = y - y3, a = (d0 * c0 + d1 * c1) * d, b = (d4 * c0 + d2 * c1) * d, c = 1 - a - b; cu[uvIndex] = u1 * a + u2 * b + u3 * c; cu[uvIndex + 1] = v1 * a + v2 * b + v3 * c; } s = this.clippedTrianglesLength; const newLengthTriangles = s + 3 * (vertexCount - 2); if (clippedTriangles.length < newLengthTriangles) { this._clippedTrianglesTyped = new Uint16Array(newLengthTriangles * 2); this._clippedTrianglesTyped.set(clippedTriangles.subarray(0, s)); clippedTriangles = this._clippedTrianglesTyped; } this.clippedTrianglesLength = newLengthTriangles; const ct = clippedTriangles; for (let ii = 1; ii < vertexCount - 1; ii++, s += 3) { ct[s] = index; ct[s + 1] = index + ii; ct[s + 2] = index + ii + 1; } index += vertexCount; offset += polygonSize; } } this.clippedVerticesTyped = this._clippedVerticesTyped.subarray(0, this.clippedVerticesLength); this.clippedUVsTyped = this._clippedUVsTyped.subarray(0, this.clippedUVsLength); this.clippedTrianglesTyped = this._clippedTrianglesTyped.subarray(0, this.clippedTrianglesLength); return true; } const clipOutput = this.clipOutput; const polygons = this.clippingPolygons; const polygonsCount = this.clippingPolygons.length; let clipOutputItems = null; for (let i = 0; i < trianglesLength; i += 3) { let t = triangles[i]; let v = t * stride; const x1 = vertices[vertexStart + v], y1 = vertices[vertexStart + v + 1]; let uv = t << 1; const u1 = uvs[uv], v1 = uvs[uv + 1]; t = triangles[i + 1]; v = t * stride; const x2 = vertices[vertexStart + v], y2 = vertices[vertexStart + v + 1]; uv = t << 1; const u2 = uvs[uv], v2 = uvs[uv + 1]; t = triangles[i + 2]; v = t * stride; const x3 = vertices[vertexStart + v], y3 = vertices[vertexStart + v + 1]; uv = t << 1; const u3 = uvs[uv], v3 = uvs[uv + 1]; let d0 = 0, d1 = 0, d2 = 0, d4 = 0, d = 0; for (let p = 0; p < polygonsCount; p++) { let s = this.clippedVerticesLength; if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p])) { clipOutputItems = clipOutput; const clipOutputLength = clipOutput.length; if (clipOutputLength === 0) continue; let clipOutputCount = clipOutputLength >> 1; if (d === 0) { d0 = y2 - y3; d1 = x3 - x2; d2 = x1 - x3; d4 = y3 - y1; d = 1 / (d0 * d2 - d1 * d4); } const newLength = s + clipOutputCount * stride; if (clippedVertices.length < newLength) { this._clippedVerticesTyped = new Float32Array(newLength * 2); this._clippedVerticesTyped.set(clippedVertices.subarray(0, s)); this._clippedUVsTyped = new Float32Array((this.clippedUVsLength + clipOutputCount * 2) * 2); this._clippedUVsTyped.set(clippedUVs.subarray(0, this.clippedUVsLength)); clippedVertices = this._clippedVerticesTyped; clippedUVs = this._clippedUVsTyped; } const cv = clippedVertices; const cu = clippedUVs; this.clippedVerticesLength = newLength; let uvIndex = this.clippedUVsLength; this.clippedUVsLength = uvIndex + clipOutputCount * 2; for (let ii = 0; ii < clipOutputLength; ii += 2, s += stride, uvIndex += 2) { const x = clipOutputItems[ii], y = clipOutputItems[ii + 1]; cv[s] = x; cv[s + 1] = y; const c0 = x - x3, c1 = y - y3, a = (d0 * c0 + d1 * c1) * d, b = (d4 * c0 + d2 * c1) * d, c = 1 - a - b; cu[uvIndex] = u1 * a + u2 * b + u3 * c; cu[uvIndex + 1] = v1 * a + v2 * b + v3 * c; } s = this.clippedTrianglesLength; const newLengthTriangles = s + 3 * (clipOutputCount - 2); if (clippedTriangles.length < newLengthTriangles) { this._clippedTrianglesTyped = new Uint16Array(newLengthTriangles * 2); this._clippedTrianglesTyped.set(clippedTriangles.subarray(0, s)); clippedTriangles = this._clippedTrianglesTyped; } this.clippedTrianglesLength = newLengthTriangles; const ct = clippedTriangles; clipOutputCount--; for (let ii = 1; ii < clipOutputCount; ii++, s += 3) { ct[s] = index; ct[s + 1] = index + ii; ct[s + 2] = index + ii + 1; } index += clipOutputCount + 1; } else { let newLength = s + 3 * stride; if (clippedVertices.length < newLength) { this._clippedVerticesTyped = new Float32Array(newLength * 2); this._clippedVerticesTyped.set(clippedVertices.subarray(0, s)); clippedVertices = this._clippedVerticesTyped; } clippedVertices[s] = x1; clippedVertices[s + 1] = y1; clippedVertices[s + stride] = x2; clippedVertices[s + stride + 1] = y2; clippedVertices[s + stride * 2] = x3; clippedVertices[s + stride * 2 + 1] = y3; const uvLength = this.clippedUVsLength + 3 * 2; if (clippedUVs.length < uvLength) { this._clippedUVsTyped = new Float32Array(uvLength * 2); this._clippedUVsTyped.set(clippedUVs.subarray(0, this.clippedUVsLength)); clippedUVs = this._clippedUVsTyped; } const uvIndex = this.clippedUVsLength; clippedUVs[uvIndex] = u1; clippedUVs[uvIndex + 1] = v1; clippedUVs[uvIndex + 2] = u2; clippedUVs[uvIndex + 3] = v2; clippedUVs[uvIndex + 4] = u3; clippedUVs[uvIndex + 5] = v3; this.clippedVerticesLength = newLength; this.clippedUVsLength = uvLength; s = this.clippedTrianglesLength; newLength = s + 3; if (clippedTriangles.length < newLength) { this._clippedTrianglesTyped = new Uint16Array(newLength * 2); this._clippedTrianglesTyped.set(clippedTriangles.subarray(0, s)); clippedTriangles = this._clippedTrianglesTyped; } const ct = clippedTriangles; ct[s] = index; ct[s + 1] = index + 1; ct[s + 2] = index + 2; index += 3; this.clippedTrianglesLength = newLength; break; } } } this.clippedVerticesTyped = this._clippedVerticesTyped.subarray(0, this.clippedVerticesLength); this.clippedUVsTyped = this._clippedUVsTyped.subarray(0, this.clippedUVsLength); this.clippedTrianglesTyped = this._clippedTrianglesTyped.subarray(0, this.clippedTrianglesLength); return clipOutputItems !== null; } clip(x1, y1, x2, y2, x3, y3, polygon) { const originalOutput = this.clipOutput; let clipped = false; let input, output; if (polygon.length % 4 >= 2) { input = this.clipOutput; output = this.scratch; } else { input = this.scratch; output = this.clipOutput; } const v = polygon; input.length = 8; const iv = input; iv[0] = x1; iv[1] = y1; iv[2] = x2; iv[3] = y2; iv[4] = x3; iv[5] = y3; iv[6] = x1; iv[7] = y1; output.length = 0; const last = polygon.length - 4; for (let i = 0; ; i += 2) { const edgeX = v[i], edgeY = v[i + 1], ex = edgeX - v[i + 2], ey = edgeY - v[i + 3]; const outputStart = output.length; const iv2 = input; x1 = iv2[0]; y1 = iv2[1]; let s1 = ey * (edgeX - x1) - ex * (edgeY - y1); for (let ii = 2, nn = input.length - 2; ii <= nn; ii += 2) { x2 = iv2[ii]; y2 = iv2[ii + 1]; const s2 = ey * (edgeX - x2) - ex * (edgeY - y2); if (s1 > 0) { if (s2 > 0) output.push(x2, y2); else { const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex); if (t >= 0 && t <= 1) { output.push(x1 + ix * t, y1 + iy * t); clipped = true; } else output.push(x2, y2); } } else if (s2 > 0) { const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex); if (t >= 0 && t <= 1) { output.push(x1 + ix * t, y1 + iy * t, x2, y2); clipped = true; } else output.push(x2, y2); } else clipped = true; x1 = x2; y1 = y2; s1 = s2; } if (outputStart === output.length) { originalOutput.length = 0; return true; } output.push(output[0], output[1]); if (i === last) break; const temp = output; output = input; output.length = 0; input = temp; } if (originalOutput !== output) { originalOutput.length = 0; for (let i = 0, n = output.length - 2; i < n; i++) originalOutput[i] = output[i]; } else originalOutput.length = originalOutput.length - 2; return clipped; } clipInverse(x1, y1, x2, y2, x3, y3, polygon) { this.inverseVertices.length = 0; const vLast = polygon.length - 4; let input, output; if (polygon.length % 4 >= 2) { input = this.clipOutput; output = this.scratch; } else { input = this.scratch; output = this.clipOutput; } input.length = 8; let v = polygon, iv = input; iv[0] = x1; iv[1] = y1; iv[2] = x2; iv[3] = y2; iv[4] = x3; iv[5] = y3; iv[6] = x1; iv[7] = y1; output.length = 0; for (let i = 0; ; i += 2) { const edgeX = v[i], edgeY = v[i + 1], ex = edgeX - v[i + 2], ey = edgeY - v[i + 3]; const outputStart = output.length, fragmentStart = this.inverseVertices.length; this.inverseVertices.push(0); iv = input; x1 = iv[0]; y1 = iv[1]; let s1 = ey * (edgeX - x1) - ex * (edgeY - y1); for (let ii = 2, nn = input.length - 2; ii <= nn; ii += 2) { x2 = iv[ii]; y2 = iv[ii + 1]; const s2 = ey * (edgeX - x2) - ex * (edgeY - y2); if (s1 > 0) { if (s2 > 0) output.push(x2, y2); else { const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex); if (t >= 0 && t <= 1) { const cx = x1 + ix * t, cy = y1 + iy * t; output.push(cx, cy); this.inverseVertices.push(cx, cy, x2, y2); } else output.push(x2, y2); } } else if (s2 > 0) { const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex); if (t >= 0 && t <= 1) { const cx = x1 + ix * t, cy = y1 + iy * t; this.inverseVertices.push(cx, cy); output.push(cx, cy, x2, y2); } else output.push(x2, y2); } else this.inverseVertices.push(x2, y2); x1 = x2; y1 = y2; s1 = s2; } const fragmentSize = this.inverseVertices.length - fragmentStart - 1; if (fragmentSize >= 6) this.inverseVertices[fragmentStart] = fragmentSize; else this.inverseVertices.length = fragmentStart; if (outputStart === output.length) break; output.push(output[0], output[1]); if (i === vLast) break; const temp = output; output = input; output.length = 0; input = temp; } } makeClockwise(polygon) { const v = polygon; const n = polygon.length; let noCW = true, noCCW = true; let area = 0, prevX = v[n - 2], prevY = v[n - 1], currX = v[0], currY = v[1]; for (let i = 2; i < n; i += 2) { const nextX = v[i], nextY = v[i + 1]; area += currX * nextY - nextX * currY; const cross2 = (currX - prevX) * (nextY - currY) - (currY - prevY) * (nextX - currX); noCCW = noCCW && cross2 <= 0; noCW = noCW && cross2 >= 0; prevX = currX; prevY = currY; currX = nextX; currY = nextY; } area += currX * v[1] - v[0] * currY; const cross = (currX - prevX) * (v[1] - currY) - (currY - prevY) * (v[0] - currX); noCCW = noCCW && cross <= 0; noCW = noCW && cross >= 0; if (area >= 0) { for (let i = 0, lastX = n - 2, half = n >> 1; i < half; i += 2) { const x = v[i], y = v[i + 1]; const other = lastX - i; v[i] = v[other]; v[i + 1] = v[other + 1]; v[other] = x; v[other + 1] = y; } return noCW; } return noCCW; } makeConvex(polygon) { const n = polygon.length; const v = polygon; this.clipOutput.length = n; const sorted = this.clipOutput; sorted[0] = v[0]; sorted[1] = v[1]; for (let i = 2; i < n; i += 2) { const x = v[i], y = v[i + 1]; let p = i - 2; for (; p >= 0 && (sorted[p] > x || sorted[p] === x && sorted[p + 1] > y); p -= 2) { sorted[p + 2] = sorted[p]; sorted[p + 3] = sorted[p + 1]; } sorted[p + 2] = x; sorted[p + 3] = y; } v[0] = sorted[0]; v[1] = sorted[1]; v[2] = sorted[2]; v[3] = sorted[3]; let s = 4; for (let i = 4; i < n; i += 2, s += 2) { const x = sorted[i], y = sorted[i + 1]; while ((v[s - 2] - v[s - 4]) * (y - v[s - 3]) - (v[s - 1] - v[s - 3]) * (x - v[s - 4]) >= 0) { s -= 2; if (s === 2) break; } v[s] = x; v[s + 1] = y; } v[s] = sorted[n - 4]; v[s + 1] = sorted[n - 3]; const t = s; s += 2; for (let i = n - 6; i >= 0; i -= 2, s += 2) { const x = sorted[i], y = sorted[i + 1]; while ((v[s - 2] - v[s - 4]) * (y - v[s - 3]) - (v[s - 1] - v[s - 3]) * (x - v[s - 4]) >= 0) { s -= 2; if (s === t) break; } v[s] = x; v[s + 1] = y; } polygon.length = s - 2; } }; // spine-core/src/SkeletonJson.ts var SkeletonJson = class { attachmentLoader; /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at * runtime than were used in Spine. * * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */ scale = 1; linkedMeshes = []; constructor(attachmentLoader) { this.attachmentLoader = attachmentLoader; } // biome-ignore lint/suspicious/noExplicitAny: it is any until we define a schema readSkeletonData(json) { const scale = this.scale; const skeletonData = new SkeletonData(); const root = typeof json === "string" ? JSON.parse(json) : json; const skeletonMap = root.skeleton; if (skeletonMap) { skeletonData.hash = skeletonMap.hash; skeletonData.version = skeletonMap.spine; skeletonData.x = skeletonMap.x; skeletonData.y = skeletonMap.y; skeletonData.width = skeletonMap.width; skeletonData.height = skeletonMap.height; skeletonData.referenceScale = getValue(skeletonMap, "referenceScale", 100) * scale; skeletonData.fps = skeletonMap.fps; skeletonData.imagesPath = skeletonMap.images ?? null; skeletonData.audioPath = skeletonMap.audio ?? null; } if (root.bones) { for (let i = 0; i < root.bones.length; i++) { const boneMap = root.bones[i]; let parent = null; const parentName = getValue(boneMap, "parent", null); if (parentName) parent = skeletonData.findBone(parentName); const data = new BoneData(skeletonData.bones.length, boneMap.name, parent); data.length = getValue(boneMap, "length", 0) * scale; const setup = data.setupPose; setup.x = getValue(boneMap, "x", 0) * scale; setup.y = getValue(boneMap, "y", 0) * scale; setup.rotation = getValue(boneMap, "rotation", 0); setup.scaleX = getValue(boneMap, "scaleX", 1); setup.scaleY = getValue(boneMap, "scaleY", 1); setup.shearX = getValue(boneMap, "shearX", 0); setup.shearY = getValue(boneMap, "shearY", 0); setup.inherit = Utils.enumValue(Inherit, getValue(boneMap, "inherit", "Normal")); data.skinRequired = getValue(boneMap, "skin", false); const color = getValue(boneMap, "color", null); if (color) data.color.setFromString(color); data.icon = getValue(boneMap, "icon", void 0); data.iconSize = getValue(boneMap, "iconSize", 1); data.iconRotation = getValue(boneMap, "iconRotation", 0); skeletonData.bones.push(data); } } if (root.slots) { for (let i = 0; i < root.slots.length; i++) { const slotMap = root.slots[i]; const slotName = slotMap.name; const boneData = skeletonData.findBone(slotMap.bone); if (!boneData) throw new Error(`Couldn't find bone ${slotMap.bone} for slot ${slotName}`); const data = new SlotData(skeletonData.slots.length, slotName, boneData); const color = getValue(slotMap, "color", null); if (color) data.setupPose.color.setFromString(color); const dark = getValue(slotMap, "dark", null); if (dark) data.setupPose.darkColor = Color.fromString(dark); data.attachmentName = getValue(slotMap, "attachment", null); data.blendMode = Utils.enumValue(BlendMode, getValue(slotMap, "blend", "normal")); data.visible = getValue(slotMap, "visible", true); skeletonData.slots.push(data); } } if (root.constraints) { for (const constraintMap of root.constraints) { const name = constraintMap.name; const skinRequired = getValue(constraintMap, "skin", false); switch (getValue(constraintMap, "type", false)) { case "ik": { const data = new IkConstraintData(name); data.skinRequired = skinRequired; for (let ii = 0; ii < constraintMap.bones.length; ii++) { const bone = skeletonData.findBone(constraintMap.bones[ii]); if (!bone) throw new Error(`Couldn't find bone ${constraintMap.bones[ii]} for IK constraint ${name}.`); data.bones.push(bone); } const targetName = constraintMap.target; const target = skeletonData.findBone(targetName); if (!target) throw new Error(`Couldn't find target bone ${targetName} for IK constraint ${name}.`); data.target = target; const scaleY = getValue(constraintMap, "scaleY", null); if (scaleY != null) data.scaleYMode = Utils.enumValue(ScaleYMode, scaleY); const setup = data.setupPose; setup.mix = getValue(constraintMap, "mix", 1); setup.softness = getValue(constraintMap, "softness", 0) * scale; setup.bendDirection = getValue(constraintMap, "bendPositive", true) ? 1 : -1; setup.compress = getValue(constraintMap, "compress", false); setup.stretch = getValue(constraintMap, "stretch", false); skeletonData.constraints.push(data); break; } case "transform": { const data = new TransformConstraintData(name); data.skinRequired = skinRequired; for (let ii = 0; ii < constraintMap.bones.length; ii++) { const boneName = constraintMap.bones[ii]; const bone = skeletonData.findBone(boneName); if (!bone) throw new Error(`Couldn't find bone ${boneName} for transform constraint ${constraintMap.name}.`); data.bones.push(bone); } const sourceName = constraintMap.source; const source = skeletonData.findBone(sourceName); if (!source) throw new Error(`Couldn't find source bone ${sourceName} for transform constraint ${constraintMap.name}.`); data.source = source; data.localSource = getValue(constraintMap, "localSource", false); data.localTarget = getValue(constraintMap, "localTarget", false); data.additive = getValue(constraintMap, "additive", false); data.clamp = getValue(constraintMap, "clamp", false); let rotate = false, x = false, y = false, scaleX = false, scaleY = false, shearY = false; const fromEntries = Object.entries(getValue(constraintMap, "properties", {})); for (const [name2, fromEntry] of fromEntries) { const from = this.fromProperty(name2); const fromScale = this.propertyScale(name2, scale); from.offset = getValue(fromEntry, "offset", 0) * fromScale; const toEntries = Object.entries(getValue(fromEntry, "to", {})); for (const [name3, toEntry] of toEntries) { let toScale = 1; let to; switch (name3) { case "rotate": { rotate = true; to = new ToRotate(); break; } case "x": { x = true; to = new ToX(); toScale = scale; break; } case "y": { y = true; to = new ToY(); toScale = scale; break; } case "scaleX": { scaleX = true; to = new ToScaleX(); break; } case "scaleY": { scaleY = true; to = new ToScaleY(); break; } case "shearY": { shearY = true; to = new ToShearY(); break; } default: throw new Error(`Invalid transform constraint to property: ${name3}`); } to.offset = getValue(toEntry, "offset", 0) * toScale; to.max = getValue(toEntry, "max", 1) * toScale; to.scale = getValue(toEntry, "scale", 1) * toScale / fromScale; from.to.push(to); } if (from.to.length > 0) data.properties.push(from); } data.offsets[TransformConstraintData.ROTATION] = getValue(constraintMap, "rotation", 0); data.offsets[TransformConstraintData.X] = getValue(constraintMap, "x", 0) * scale; data.offsets[TransformConstraintData.Y] = getValue(constraintMap, "y", 0) * scale; data.offsets[TransformConstraintData.SCALEX] = getValue(constraintMap, "scaleX", 0); data.offsets[TransformConstraintData.SCALEY] = getValue(constraintMap, "scaleY", 0); data.offsets[TransformConstraintData.SHEARY] = getValue(constraintMap, "shearY", 0); const setup = data.setupPose; if (rotate) setup.mixRotate = getValue(constraintMap, "mixRotate", 1); if (x) setup.mixX = getValue(constraintMap, "mixX", 1); if (y) setup.mixY = getValue(constraintMap, "mixY", setup.mixX); if (scaleX) setup.mixScaleX = getValue(constraintMap, "mixScaleX", 1); if (scaleY) setup.mixScaleY = getValue(constraintMap, "mixScaleY", setup.mixScaleX); if (shearY) setup.mixShearY = getValue(constraintMap, "mixShearY", 1); skeletonData.constraints.push(data); break; } case "path": { const data = new PathConstraintData(name); data.skinRequired = skinRequired; for (let ii = 0; ii < constraintMap.bones.length; ii++) { const boneName = constraintMap.bones[ii]; const bone = skeletonData.findBone(boneName); if (!bone) throw new Error(`Couldn't find bone ${boneName} for path constraint ${constraintMap.name}.`); data.bones.push(bone); } const slotName = constraintMap.slot; const slot = skeletonData.findSlot(slotName); if (!slot) throw new Error(`Couldn't find slot ${slotName} for path constraint ${constraintMap.name}.`); data.slot = slot; data.positionMode = Utils.enumValue(PositionMode, getValue(constraintMap, "positionMode", "Percent")); data.spacingMode = Utils.enumValue(SpacingMode, getValue(constraintMap, "spacingMode", "Length")); data.rotateMode = Utils.enumValue(RotateMode, getValue(constraintMap, "rotateMode", "Tangent")); data.offsetRotation = getValue(constraintMap, "rotation", 0); const setup = data.setupPose; setup.position = getValue(constraintMap, "position", 0); if (data.positionMode === 0 /* Fixed */) setup.position *= scale; setup.spacing = getValue(constraintMap, "spacing", 0); if (data.spacingMode === 0 /* Length */ || data.spacingMode === 1 /* Fixed */) setup.spacing *= scale; setup.mixRotate = getValue(constraintMap, "mixRotate", 1); setup.mixX = getValue(constraintMap, "mixX", 1); setup.mixY = getValue(constraintMap, "mixY", setup.mixX); skeletonData.constraints.push(data); break; } case "physics": { const data = new PhysicsConstraintData(name); data.skinRequired = skinRequired; const boneName = constraintMap.bone; const bone = skeletonData.findBone(boneName); if (bone == null) throw new Error(`Physics bone not found: ${boneName}`); data.bone = bone; data.x = getValue(constraintMap, "x", 0); data.y = getValue(constraintMap, "y", 0); data.rotate = getValue(constraintMap, "rotate", 0); data.scaleX = getValue(constraintMap, "scaleX", 0); const scaleY = getValue(constraintMap, "scaleY", null); if (scaleY != null) data.scaleYMode = Utils.enumValue(ScaleYMode, scaleY); data.shearX = getValue(constraintMap, "shearX", 0); data.limit = getValue(constraintMap, "limit", 5e3) * scale; data.step = 1 / getValue(constraintMap, "fps", 60); const setup = data.setupPose; setup.inertia = getValue(constraintMap, "inertia", 0.5); setup.strength = getValue(constraintMap, "strength", 100); setup.damping = getValue(constraintMap, "damping", 0.85); setup.massInverse = 1 / getValue(constraintMap, "mass", 1); setup.wind = getValue(constraintMap, "wind", 0); setup.gravity = getValue(constraintMap, "gravity", 0); setup.mix = getValue(constraintMap, "mix", 1); data.inertiaGlobal = getValue(constraintMap, "inertiaGlobal", false); data.strengthGlobal = getValue(constraintMap, "strengthGlobal", false); data.dampingGlobal = getValue(constraintMap, "dampingGlobal", false); data.massGlobal = getValue(constraintMap, "massGlobal", false); data.windGlobal = getValue(constraintMap, "windGlobal", false); data.gravityGlobal = getValue(constraintMap, "gravityGlobal", false); data.mixGlobal = getValue(constraintMap, "mixGlobal", false); skeletonData.constraints.push(data); break; } case "slider": { const data = new SliderData(name); data.skinRequired = skinRequired; data.additive = getValue(constraintMap, "additive", false); data.loop = getValue(constraintMap, "loop", false); data.setupPose.mix = getValue(constraintMap, "mix", 1); const boneName = constraintMap.bone; if (boneName) { data.bone = skeletonData.findBone(boneName); if (!data.bone) throw new Error(`Slider bone not found: ${boneName}`); const property = constraintMap.property; data.property = this.fromProperty(property); const propertyScale = this.propertyScale(property, scale); data.property.offset = getValue(constraintMap, "from", 0) * propertyScale; data.offset = getValue(constraintMap, "to", 0); data.scale = getValue(constraintMap, "scale", 1) / propertyScale; data.max = getValue(constraintMap, "max", 0); data.local = getValue(constraintMap, "local", false); } else data.setupPose.time = getValue(constraintMap, "time", 0); skeletonData.constraints.push(data); break; } } } } if (root.skins) { for (let i = 0; i < root.skins.length; i++) { const skinMap = root.skins[i]; const skin = new Skin(skinMap.name); if (skinMap.bones) { for (let ii = 0; ii < skinMap.bones.length; ii++) { const boneName = skinMap.bones[ii]; const bone = skeletonData.findBone(boneName); if (!bone) throw new Error(`Couldn't find bone ${boneName} for skin ${skinMap.name}.`); skin.bones.push(bone); } } if (skinMap.ik) { for (let ii = 0; ii < skinMap.ik.length; ii++) { const constraintName = skinMap.ik[ii]; const constraint = skeletonData.findConstraint(constraintName, IkConstraintData); if (!constraint) throw new Error(`Couldn't find IK constraint ${constraintName} for skin ${skinMap.name}.`); skin.constraints.push(constraint); } } if (skinMap.transform) { for (let ii = 0; ii < skinMap.transform.length; ii++) { const constraintName = skinMap.transform[ii]; const constraint = skeletonData.findConstraint(constraintName, TransformConstraintData); if (!constraint) throw new Error(`Couldn't find transform constraint ${constraintName} for skin ${skinMap.name}.`); skin.constraints.push(constraint); } } if (skinMap.path) { for (let ii = 0; ii < skinMap.path.length; ii++) { const constraintName = skinMap.path[ii]; const constraint = skeletonData.findConstraint(constraintName, PathConstraintData); if (!constraint) throw new Error(`Couldn't find path constraint ${constraintName} for skin ${skinMap.name}.`); skin.constraints.push(constraint); } } if (skinMap.physics) { for (let ii = 0; ii < skinMap.physics.length; ii++) { const constraintName = skinMap.physics[ii]; const constraint = skeletonData.findConstraint(constraintName, PhysicsConstraintData); if (!constraint) throw new Error(`Couldn't find physics constraint ${constraintName} for skin ${skinMap.name}.`); skin.constraints.push(constraint); } } if (skinMap.slider) { for (let ii = 0; ii < skinMap.slider.length; ii++) { const constraintName = skinMap.slider[ii]; const constraint = skeletonData.findConstraint(constraintName, SliderData); if (!constraint) throw new Error(`Couldn't find slider constraint ${constraintName} for skin ${skinMap.name}.`); skin.constraints.push(constraint); } } for (const slotName in skinMap.attachments) { const slot = skeletonData.findSlot(slotName); if (!slot) throw new Error(`Couldn't find skin slot ${slotName} for skin ${skinMap.name}.`); const slotMap = skinMap.attachments[slotName]; for (const entryName in slotMap) { const attachment = this.readAttachment(slotMap[entryName], skin, slot.index, entryName, skeletonData); if (attachment) skin.setAttachment(slot.index, entryName, attachment); } } skeletonData.skins.push(skin); if (skin.name === "default") skeletonData.defaultSkin = skin; } } for (let i = 0, n = this.linkedMeshes.length; i < n; i++) { const linkedMesh = this.linkedMeshes[i]; const skin = !linkedMesh.skin ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin); if (!skin) throw new Error(`Skin not found: ${linkedMesh.skin}`); const source = skin.getAttachment(linkedMesh.sourceIndex, linkedMesh.source); if (!source) throw new Error(`Source mesh not found: ${linkedMesh.source}`); linkedMesh.mesh.timelineAttachment = linkedMesh.inheritTimelines ? source : linkedMesh.mesh; linkedMesh.mesh.setSourceMesh(source); linkedMesh.mesh.updateSequence(); outer: if (linkedMesh.inheritTimelines && linkedMesh.slotIndex !== linkedMesh.sourceIndex) { const slots = source.timelineSlots; for (const existing of slots) if (existing === linkedMesh.slotIndex) break outer; const newSlots = [...slots]; newSlots[slots.length] = linkedMesh.slotIndex; source.timelineSlots = newSlots; } } this.linkedMeshes.length = 0; if (root.events) { for (const eventName in root.events) { const eventMap = root.events[eventName]; const data = new EventData(eventName); const setup = data.setupPose; setup.intValue = getValue(eventMap, "int", 0); setup.floatValue = getValue(eventMap, "float", 0); setup.stringValue = getValue(eventMap, "string", ""); data._audioPath = getValue(eventMap, "audio", null); if (data.audioPath) { setup.volume = getValue(eventMap, "volume", setup.volume); setup.balance = getValue(eventMap, "balance", setup.balance); } skeletonData.events.push(data); } } if (root.animations) { for (const animationName in root.animations) { const animationMap = root.animations[animationName]; this.readAnimation(animationMap, animationName, skeletonData); } } if (root.constraints) { for (const animationName in root.constraints) { const animationMap = root.constraints[animationName]; if (animationMap.type === "slider") { const data = skeletonData.findConstraint(animationMap.name, SliderData); const animationName2 = animationMap.animation; const animation = skeletonData.findAnimation(animationName2); if (!animation) throw new Error(`Slider animation not found: ${animationName2}`); data.animation = animation; } } } return skeletonData; } fromProperty(type) { let from; switch (type) { case "rotate": from = new FromRotate(); break; case "x": from = new FromX(); break; case "y": from = new FromY(); break; case "scaleX": from = new FromScaleX(); break; case "scaleY": from = new FromScaleY(); break; case "shearY": from = new FromShearY(); break; default: throw new Error(`Invalid transform constraint from property: ${type}`); } return from; } propertyScale(type, scale) { switch (type) { case "x": case "y": return scale; default: return 1; } } // biome-ignore lint/suspicious/noExplicitAny: it is any until we define a schema readAttachment(map, skin, slotIndex, placeholder, skeletonData) { const scale = this.scale; const name = getValue(map, "name", placeholder); switch (getValue(map, "type", "region")) { case "region": { const path = getValue(map, "path", name); const sequence = this.readSequence(getValue(map, "sequence", null)); const region = this.attachmentLoader.newRegionAttachment(skin, placeholder, name, path, sequence); if (!region) return null; region.path = path; region.x = getValue(map, "x", 0) * scale; region.y = getValue(map, "y", 0) * scale; region.scaleX = getValue(map, "scaleX", 1); region.scaleY = getValue(map, "scaleY", 1); region.rotation = getValue(map, "rotation", 0); region.width = map.width * scale; region.height = map.height * scale; const color = getValue(map, "color", null); if (color) region.color.setFromString(color); region.updateSequence(); return region; } case "boundingbox": { const box = this.attachmentLoader.newBoundingBoxAttachment(skin, placeholder, name); if (!box) return null; this.readVertices(map, box, map.vertexCount << 1); const color = getValue(map, "color", null); if (color) box.color.setFromString(color); return box; } case "mesh": case "linkedmesh": { const path = getValue(map, "path", name); const sequence = this.readSequence(getValue(map, "sequence", null)); const mesh = this.attachmentLoader.newMeshAttachment(skin, placeholder, name, path, sequence); if (!mesh) return null; mesh.path = path; const color = getValue(map, "color", null); if (color) mesh.color.setFromString(color); mesh.width = getValue(map, "width", 0) * scale; mesh.height = getValue(map, "height", 0) * scale; const source = getValue(map, "source", null); if (source) { let sourceIndex = slotIndex; const slot = getValue(map, "slot", null); if (slot) { const sourceSlot = skeletonData.findSlot(slot); if (!sourceSlot) throw new Error(`Source mesh slot not found: ${slot}`); sourceIndex = sourceSlot.index; } this.linkedMeshes.push(new LinkedMesh2( mesh, getValue(map, "skin", null), slotIndex, sourceIndex, source, getValue(map, "timelines", true) )); return mesh; } const uvs = map.uvs; this.readVertices(map, mesh, uvs.length); mesh.triangles = map.triangles; mesh.regionUVs = uvs; mesh.edges = getValue(map, "edges", null); mesh.hullLength = getValue(map, "hull", 0) * 2; mesh.updateSequence(); return mesh; } case "path": { const path = this.attachmentLoader.newPathAttachment(skin, placeholder, name); if (!path) return null; path.closed = getValue(map, "closed", false); path.constantSpeed = getValue(map, "constantSpeed", true); const vertexCount = map.vertexCount; this.readVertices(map, path, vertexCount << 1); const lengths = Utils.newArray(vertexCount / 3, 0); for (let i = 0; i < map.lengths.length; i++) lengths[i] = map.lengths[i] * scale; path.lengths = lengths; const color = getValue(map, "color", null); if (color) path.color.setFromString(color); return path; } case "point": { const point = this.attachmentLoader.newPointAttachment(skin, placeholder, name); if (!point) return null; point.x = getValue(map, "x", 0) * scale; point.y = getValue(map, "y", 0) * scale; point.rotation = getValue(map, "rotation", 0); const color = getValue(map, "color", null); if (color) point.color.setFromString(color); return point; } case "clipping": { const clip = this.attachmentLoader.newClippingAttachment(skin, placeholder, name); if (!clip) return null; const end = getValue(map, "end", null); if (end) clip.endSlot = skeletonData.findSlot(end); clip.convex = getValue(map, "convex", false); clip.inverse = getValue(map, "inverse", false); const vertexCount = map.vertexCount; this.readVertices(map, clip, vertexCount << 1); const color = getValue(map, "color", null); if (color) clip.color.setFromString(color); return clip; } } return null; } readSequence(map) { if (map == null) return new Sequence(1, false); const sequence = new Sequence(getValue(map, "count", 0), true); sequence.start = getValue(map, "start", 1); sequence.digits = getValue(map, "digits", 0); sequence.setupIndex = getValue(map, "setup", 0); return sequence; } // biome-ignore lint/suspicious/noExplicitAny: it is any until we define a schema readVertices(map, attachment, verticesLength) { const scale = this.scale; attachment.worldVerticesLength = verticesLength; const vertices = map.vertices; if (verticesLength === vertices.length) { const scaledVertices = Utils.toFloatArray(vertices); if (scale !== 1) { for (let i = 0, n = vertices.length; i < n; i++) scaledVertices[i] *= scale; } attachment.vertices = scaledVertices; return; } const weights = []; const bones = []; for (let i = 0, n = vertices.length; i < n; ) { const boneCount = vertices[i++]; bones.push(boneCount); for (let 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 = Utils.toFloatArray(weights); } // biome-ignore lint/suspicious/noExplicitAny: it is any untile we define a schema readAnimation(map, name, skeletonData) { const scale = this.scale; const timelines = []; if (map.slots) { for (const slotName in map.slots) { const slotMap = map.slots[slotName]; const slot = skeletonData.findSlot(slotName); if (!slot) throw new Error(`Slot not found: ${slotName}`); const slotIndex = slot.index; for (const timelineName in slotMap) { const timelineMap = slotMap[timelineName]; if (!timelineMap) continue; const frames = timelineMap.length; switch (timelineName) { case "attachment": { const timeline = new AttachmentTimeline(frames, slotIndex); for (let frame = 0; frame < frames; frame++) { const keyMap = timelineMap[frame]; timeline.setFrame(frame, getValue(keyMap, "time", 0), getValue(keyMap, "name", null)); } timelines.push(timeline); break; } case "rgba": { const timeline = new RGBATimeline(frames, frames << 2, slotIndex); let keyMap = timelineMap[0]; let time = getValue(keyMap, "time", 0); let color2 = Color.fromString(keyMap.color); for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, color2.r, color2.g, color2.b, color2.a); const nextMap = timelineMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const newColor = Color.fromString(nextMap.color); const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color2.r, newColor.r, 1); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color2.g, newColor.g, 1); bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color2.b, newColor.b, 1); bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, color2.a, newColor.a, 1); } time = time2; color2 = newColor; keyMap = nextMap; } timelines.push(timeline); break; } case "rgb": { const timeline = new RGBTimeline(frames, frames * 3, slotIndex); let keyMap = timelineMap[0]; let time = getValue(keyMap, "time", 0); let color2 = Color.fromString(keyMap.color); for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, color2.r, color2.g, color2.b); const nextMap = timelineMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const newColor = Color.fromString(nextMap.color); const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color2.r, newColor.r, 1); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color2.g, newColor.g, 1); bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color2.b, newColor.b, 1); } time = time2; color2 = newColor; keyMap = nextMap; } timelines.push(timeline); break; } case "alpha": { readTimeline12(timelines, timelineMap, new AlphaTimeline(frames, frames, slotIndex), 0, 1); break; } case "rgba2": { const timeline = new RGBA2Timeline(frames, frames * 7, slotIndex); let keyMap = timelineMap[0]; let time = getValue(keyMap, "time", 0); let color2 = Color.fromString(keyMap.light); let color22 = Color.fromString(keyMap.dark); for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, color2.r, color2.g, color2.b, color2.a, color22.r, color22.g, color22.b); const nextMap = timelineMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const newColor = Color.fromString(nextMap.light); const newColor2 = Color.fromString(nextMap.dark); const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color2.r, newColor.r, 1); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color2.g, newColor.g, 1); bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color2.b, newColor.b, 1); bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, color2.a, newColor.a, 1); bezier = readCurve(curve, timeline, bezier, frame, 4, time, time2, color22.r, newColor2.r, 1); bezier = readCurve(curve, timeline, bezier, frame, 5, time, time2, color22.g, newColor2.g, 1); bezier = readCurve(curve, timeline, bezier, frame, 6, time, time2, color22.b, newColor2.b, 1); } time = time2; color2 = newColor; color22 = newColor2; keyMap = nextMap; } timelines.push(timeline); break; } case "rgb2": { const timeline = new RGB2Timeline(frames, frames * 6, slotIndex); let keyMap = timelineMap[0]; let time = getValue(keyMap, "time", 0); let color2 = Color.fromString(keyMap.light); let color22 = Color.fromString(keyMap.dark); for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, color2.r, color2.g, color2.b, color22.r, color22.g, color22.b); const nextMap = timelineMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const newColor = Color.fromString(nextMap.light); const newColor2 = Color.fromString(nextMap.dark); const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color2.r, newColor.r, 1); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color2.g, newColor.g, 1); bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color2.b, newColor.b, 1); bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, color22.r, newColor2.r, 1); bezier = readCurve(curve, timeline, bezier, frame, 4, time, time2, color22.g, newColor2.g, 1); bezier = readCurve(curve, timeline, bezier, frame, 5, time, time2, color22.b, newColor2.b, 1); } time = time2; color2 = newColor; color22 = newColor2; keyMap = nextMap; } timelines.push(timeline); break; } default: throw new Error(`Invalid timeline type for a slot: ${timelineMap.name} (${slotMap.name})`); } } } } if (map.bones) { for (const boneName in map.bones) { const boneMap = map.bones[boneName]; const bone = skeletonData.findBone(boneName); if (!bone) throw new Error(`Bone not found: ${boneName}`); const boneIndex = bone.index; for (const timelineName in boneMap) { const timelineMap = boneMap[timelineName]; const frames = timelineMap.length; if (frames === 0) continue; switch (timelineName) { case "rotate": readTimeline12(timelines, timelineMap, new RotateTimeline(frames, frames, boneIndex), 0, 1); break; case "translate": readTimeline22(timelines, timelineMap, new TranslateTimeline(frames, frames << 1, boneIndex), "x", "y", 0, scale); break; case "translatex": readTimeline12(timelines, timelineMap, new TranslateXTimeline(frames, frames, boneIndex), 0, scale); break; case "translatey": readTimeline12(timelines, timelineMap, new TranslateYTimeline(frames, frames, boneIndex), 0, scale); break; case "scale": readTimeline22(timelines, timelineMap, new ScaleTimeline(frames, frames << 1, boneIndex), "x", "y", 1, 1); break; case "scalex": readTimeline12(timelines, timelineMap, new ScaleXTimeline(frames, frames, boneIndex), 1, 1); break; case "scaley": readTimeline12(timelines, timelineMap, new ScaleYTimeline(frames, frames, boneIndex), 1, 1); break; case "shear": readTimeline22(timelines, timelineMap, new ShearTimeline(frames, frames << 1, boneIndex), "x", "y", 0, 1); break; case "shearx": readTimeline12(timelines, timelineMap, new ShearXTimeline(frames, frames, boneIndex), 0, 1); break; case "sheary": readTimeline12(timelines, timelineMap, new ShearYTimeline(frames, frames, boneIndex), 0, 1); break; case "inherit": { const timeline = new InheritTimeline(frames, bone.index); for (let frame = 0; frame < timelineMap.length; frame++) { const aFrame = timelineMap[frame]; timeline.setFrame(frame, getValue(aFrame, "time", 0), Utils.enumValue(Inherit, getValue(aFrame, "inherit", "Normal"))); } timelines.push(timeline); break; } default: throw new Error(`Invalid timeline type for a bone: ${timelineMap.name} (${boneMap.name})`); } } } } if (map.ik) { for (const constraintName in map.ik) { const constraintMap = map.ik[constraintName]; let keyMap = constraintMap[0]; if (!keyMap) continue; const constraint = skeletonData.findConstraint(constraintName, IkConstraintData); if (!constraint) throw new Error(`IK Constraint not found: ${constraintName}`); const timeline = new IkConstraintTimeline( constraintMap.length, constraintMap.length << 1, skeletonData.constraints.indexOf(constraint) ); let time = getValue(keyMap, "time", 0); let mix = getValue(keyMap, "mix", 1); let softness = getValue(keyMap, "softness", 0) * scale; for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, mix, softness, getValue(keyMap, "bendPositive", true) ? 1 : -1, getValue(keyMap, "compress", false), getValue(keyMap, "stretch", false)); const nextMap = constraintMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const mix2 = getValue(nextMap, "mix", 1); const softness2 = getValue(nextMap, "softness", 0) * scale; const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, mix, mix2, 1); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, softness, softness2, scale); } time = time2; mix = mix2; softness = softness2; keyMap = nextMap; } timelines.push(timeline); } } if (map.transform) { for (const constraintName in map.transform) { const timelineMap = map.transform[constraintName]; let keyMap = timelineMap[0]; if (!keyMap) continue; const constraint = skeletonData.findConstraint(constraintName, TransformConstraintData); if (!constraint) throw new Error(`Transform constraint not found: ${constraintName}`); const timeline = new TransformConstraintTimeline( timelineMap.length, timelineMap.length * 6, skeletonData.constraints.indexOf(constraint) ); let time = getValue(keyMap, "time", 0); let mixRotate = getValue(keyMap, "mixRotate", 1); let mixX = getValue(keyMap, "mixX", 1), mixY = getValue(keyMap, "mixY", mixX); let mixScaleX = getValue(keyMap, "mixScaleX", 1), mixScaleY = getValue(keyMap, "mixScaleY", 1); let mixShearY = getValue(keyMap, "mixShearY", 1); for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY); const nextMap = timelineMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const mixRotate2 = getValue(nextMap, "mixRotate", 1); const mixX2 = getValue(nextMap, "mixX", 1), mixY2 = getValue(nextMap, "mixY", mixX2); const mixScaleX2 = getValue(nextMap, "mixScaleX", 1), mixScaleY2 = getValue(nextMap, "mixScaleY", 1); const mixShearY2 = getValue(nextMap, "mixShearY", 1); const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, mixX, mixX2, 1); bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, mixY, mixY2, 1); bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, mixScaleX, mixScaleX2, 1); bezier = readCurve(curve, timeline, bezier, frame, 4, time, time2, mixScaleY, mixScaleY2, 1); bezier = readCurve(curve, timeline, bezier, frame, 5, time, time2, mixShearY, mixShearY2, 1); } time = time2; mixRotate = mixRotate2; mixX = mixX2; mixY = mixY2; mixScaleX = mixScaleX2; mixScaleY = mixScaleY2; mixShearY = mixShearY2; keyMap = nextMap; } timelines.push(timeline); } } if (map.path) { for (const constraintName in map.path) { const constraintMap = map.path[constraintName]; const constraint = skeletonData.findConstraint(constraintName, PathConstraintData); if (!constraint) throw new Error(`Path constraint not found: ${constraintName}`); const index = skeletonData.constraints.indexOf(constraint); for (const timelineName in constraintMap) { const timelineMap = constraintMap[timelineName]; let keyMap = timelineMap[0]; if (!keyMap) continue; const frames = timelineMap.length; switch (timelineName) { case "position": { const timeline = new PathConstraintPositionTimeline(frames, frames, index); readTimeline12(timelines, timelineMap, timeline, 0, constraint.positionMode === 0 /* Fixed */ ? scale : 1); break; } case "spacing": { const timeline = new PathConstraintSpacingTimeline(frames, frames, index); readTimeline12(timelines, timelineMap, timeline, 0, constraint.spacingMode === 0 /* Length */ || constraint.spacingMode === 1 /* Fixed */ ? scale : 1); break; } case "mix": { const timeline = new PathConstraintMixTimeline(frames, frames * 3, index); let time = getValue(keyMap, "time", 0); let mixRotate = getValue(keyMap, "mixRotate", 1); let mixX = getValue(keyMap, "mixX", 1); let mixY = getValue(keyMap, "mixY", mixX); for (let frame = 0, bezier = 0; ; frame++) { timeline.setFrame(frame, time, mixRotate, mixX, mixY); const nextMap = timelineMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const mixRotate2 = getValue(nextMap, "mixRotate", 1); const mixX2 = getValue(nextMap, "mixX", 1); const mixY2 = getValue(nextMap, "mixY", mixX2); const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, mixX, mixX2, 1); bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, mixY, mixY2, 1); } time = time2; mixRotate = mixRotate2; mixX = mixX2; mixY = mixY2; keyMap = nextMap; } timelines.push(timeline); break; } } } } } if (map.physics) { for (const constraintName in map.physics) { const constraintMap = map.physics[constraintName]; let index = -1; if (constraintName.length > 0) { const constraint = skeletonData.findConstraint(constraintName, PhysicsConstraintData); if (!constraint) throw new Error(`Physics constraint not found: ${constraintName}`); index = skeletonData.constraints.indexOf(constraint); } for (const timelineName in constraintMap) { const timelineMap = constraintMap[timelineName]; let keyMap = timelineMap[0]; if (!keyMap) continue; const frames = timelineMap.length; let timeline; let defaultValue = 0; if (timelineName === "reset") { const resetTimeline = new PhysicsConstraintResetTimeline(frames, index); for (let frame = 0; keyMap != null; keyMap = timelineMap[frame + 1], frame++) resetTimeline.setFrame(frame, getValue(keyMap, "time", 0)); timelines.push(resetTimeline); continue; } switch (timelineName) { case "inertia": timeline = new PhysicsConstraintInertiaTimeline(frames, frames, index); break; case "strength": timeline = new PhysicsConstraintStrengthTimeline(frames, frames, index); break; case "damping": timeline = new PhysicsConstraintDampingTimeline(frames, frames, index); break; case "mass": timeline = new PhysicsConstraintMassTimeline(frames, frames, index); break; case "wind": timeline = new PhysicsConstraintWindTimeline(frames, frames, index); break; case "gravity": timeline = new PhysicsConstraintGravityTimeline(frames, frames, index); break; case "mix": { defaultValue = 1; timeline = new PhysicsConstraintMixTimeline(frames, frames, index); break; } default: continue; } readTimeline12(timelines, timelineMap, timeline, defaultValue, 1); } } } if (map.slider) { for (const constraintName in map.slider) { const constraintMap = map.slider[constraintName]; const constraint = skeletonData.findConstraint(constraintName, SliderData); if (!constraint) throw new Error(`Slider not found: ${constraintName}`); const index = skeletonData.constraints.indexOf(constraint); for (const timelineName in constraintMap) { const timelineMap = constraintMap[timelineName]; const keyMap = timelineMap[0]; if (!keyMap) continue; const frames = timelineMap.length; switch (timelineName) { case "time": readTimeline12(timelines, timelineMap, new SliderTimeline(frames, frames, index), 1, 1); break; case "mix": readTimeline12(timelines, timelineMap, new SliderMixTimeline(frames, frames, index), 1, 1); break; } } } } if (map.attachments) { for (const attachmentsName in map.attachments) { const attachmentsMap = map.attachments[attachmentsName]; const skin = skeletonData.findSkin(attachmentsName); if (!skin) throw new Error(`Skin not found: ${attachmentsName}`); for (const slotMapName in attachmentsMap) { const slotMap = attachmentsMap[slotMapName]; const slot = skeletonData.findSlot(slotMapName); if (!slot) throw new Error(`Attachment slot not found: ${slotMapName}`); const slotIndex = slot.index; for (const attachmentMapName in slotMap) { const attachmentMap = slotMap[attachmentMapName]; const attachment = skin.getAttachment(slotIndex, attachmentMapName); if (!attachment) throw new Error(`Timeline attachment not found: ${attachmentMapName}`); for (const timelineMapName in attachmentMap) { const timelineMap = attachmentMap[timelineMapName]; let keyMap = timelineMap[0]; if (!keyMap) continue; if (timelineMapName === "deform") { const weighted = attachment.bones; const vertices = attachment.vertices; const deformLength = weighted ? vertices.length / 3 * 2 : vertices.length; const timeline = new DeformTimeline(timelineMap.length, timelineMap.length, slotIndex, attachment); let time = getValue(keyMap, "time", 0); for (let frame = 0, bezier = 0; ; frame++) { let deform; const verticesValue = getValue(keyMap, "vertices", null); if (!verticesValue) deform = weighted ? Utils.newFloatArray(deformLength) : vertices; else { deform = Utils.newFloatArray(deformLength); const start = getValue(keyMap, "offset", 0); Utils.arrayCopy(verticesValue, 0, deform, start, verticesValue.length); if (scale !== 1) { for (let i = start, n = i + verticesValue.length; i < n; i++) deform[i] *= scale; } if (!weighted) { for (let i = 0; i < deformLength; i++) deform[i] += vertices[i]; } } timeline.setFrame(frame, time, deform); const nextMap = timelineMap[frame + 1]; if (!nextMap) { timeline.shrink(bezier); break; } const time2 = getValue(nextMap, "time", 0); const curve = keyMap.curve; if (curve) bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, 0, 1, 1); time = time2; keyMap = nextMap; } timelines.push(timeline); } else if (timelineMapName === "sequence") { const timeline = new SequenceTimeline(timelineMap.length, slotIndex, attachment); let lastDelay = 0; for (let frame = 0; frame < timelineMap.length; frame++) { const delay = getValue(keyMap, "delay", lastDelay); const time = getValue(keyMap, "time", 0); const mode = SequenceMode[getValue(keyMap, "mode", "hold")]; const index = getValue(keyMap, "index", 0); timeline.setFrame(frame, time, mode, index, delay); lastDelay = delay; keyMap = timelineMap[frame + 1]; } timelines.push(timeline); } } } } } } if (map.drawOrder) { const timeline = new DrawOrderTimeline(map.drawOrder.length); const slotCount = skeletonData.slots.length; let frame = 0; for (const drawOrderMap of map.drawOrder) { timeline.setFrame(frame++, getValue(drawOrderMap, "time", 0), readDrawOrder2(skeletonData, drawOrderMap, slotCount, null)); } timelines.push(timeline); } if (map.drawOrderFolder) { for (const timelineMap of map.drawOrderFolder) { const slotEntries = getValue(timelineMap, "slots", []); const folderSlots = new Array(slotEntries.length); let ii = 0; for (const slotEntry of slotEntries) { const slot = skeletonData.findSlot(slotEntry); if (!slot) throw new Error(`Draw order folder slot not found: ${slotEntry}`); folderSlots[ii++] = slot.index; } const drawOrderFolderEntries = getValue(timelineMap, "keys", []); const timeline = new DrawOrderFolderTimeline(drawOrderFolderEntries.length, folderSlots, skeletonData.slots.length); let frame = 0; for (const drawOrderFolderMap of drawOrderFolderEntries) { timeline.setFrame(frame++, getValue(drawOrderFolderMap, "time", 0), readDrawOrder2(skeletonData, drawOrderFolderMap, folderSlots.length, folderSlots)); } timelines.push(timeline); } } if (map.events) { const timeline = new EventTimeline(map.events.length); let frame = 0; for (let i = 0; i < map.events.length; i++, frame++) { const eventMap = map.events[i]; const data = skeletonData.findEvent(eventMap.name); if (!data) throw new Error(`Event not found: ${eventMap.name}`); const setup = data.setupPose; const event = new Event(Utils.toSinglePrecision(getValue(eventMap, "time", 0)), data); event.intValue = getValue(eventMap, "int", setup.intValue); event.floatValue = getValue(eventMap, "float", setup.floatValue); event.stringValue = getValue(eventMap, "string", setup.stringValue); if (event.data.audioPath) { event.volume = getValue(eventMap, "volume", setup.volume); event.balance = getValue(eventMap, "balance", setup.volume); } timeline.setFrame(frame, event); } timelines.push(timeline); } let duration = 0; for (let i = 0, n = timelines.length; i < n; i++) duration = Math.max(duration, timelines[i].getDuration()); const animation = new Animation(name, timelines, duration); const color = getValue(map, "color", null); if (color !== null) animation.color.setFromString(color); skeletonData.animations.push(animation); } }; var LinkedMesh2 = class { source; skin; slotIndex; sourceIndex; mesh; inheritTimelines; constructor(mesh, skin, slotIndex, sourceIndex, source, inheritTimelines) { this.mesh = mesh; this.skin = skin; this.slotIndex = slotIndex; this.sourceIndex = sourceIndex; this.source = source; this.inheritTimelines = inheritTimelines; } }; function readTimeline12(timelines, keys, timeline, defaultValue, scale) { let keyMap = keys[0]; let time = keyMap.time ?? 0; let value = (keyMap.value ?? defaultValue) * scale; let bezier = 0; for (let frame = 0; ; frame++) { timeline.setFrame(frame, time, value); const nextMap = keys[frame + 1]; if (!nextMap) { timeline.shrink(bezier); timelines.push(timeline); return; } const time2 = nextMap.time ?? 0; const value2 = (nextMap.value ?? defaultValue) * scale; if (keyMap.curve) bezier = readCurve(keyMap.curve, timeline, bezier, frame, 0, time, time2, value, value2, scale); time = time2; value = value2; keyMap = nextMap; } } function readTimeline22(timelines, keys, timeline, name1, name2, defaultValue, scale) { let keyMap = keys[0]; let time = keyMap.time ?? 0; let value1 = (keyMap[name1] ?? defaultValue) * scale; let value2 = (keyMap[name2] ?? defaultValue) * scale; let bezier = 0; for (let frame = 0; ; frame++) { timeline.setFrame(frame, time, value1, value2); const nextMap = keys[frame + 1]; if (!nextMap) { timeline.shrink(bezier); timelines.push(timeline); return; } const time2 = nextMap.time ?? 0; const nvalue1 = (nextMap[name1] ?? defaultValue) * scale; const nvalue2 = (nextMap[name2] ?? defaultValue) * scale; const curve = keyMap.curve; if (curve) { bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, value1, nvalue1, scale); bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, value2, nvalue2, scale); } time = time2; value1 = nvalue1; value2 = nvalue2; keyMap = nextMap; } } function readDrawOrder2(skeletonData, keys, slotCount, folderSlots) { const changes = keys.offsets; if (!changes) return null; const drawOrder = new Array(slotCount).fill(-1); const unchanged = new Array(slotCount - changes.length); let originalIndex = 0, unchangedIndex = 0; for (const offsetMap of changes) { const slot = skeletonData.findSlot(offsetMap.slot); if (slot == null) throw new Error(`Draw order slot not found: ${offsetMap.slot}`); let index = 0; if (!folderSlots) index = slot.index; else { index = -1; for (let i = 0; i < slotCount; i++) { if (folderSlots[i] === slot.index) { index = i; break; } } if (index === -1) throw new Error(`Slot not in folder: ${offsetMap.slot}`); } while (originalIndex !== index) unchanged[unchangedIndex++] = originalIndex++; drawOrder[originalIndex + offsetMap.offset] = originalIndex++; } while (originalIndex < slotCount) unchanged[unchangedIndex++] = originalIndex++; for (let i = slotCount - 1; i >= 0; i--) if (drawOrder[i] === -1) drawOrder[i] = unchanged[--unchangedIndex]; return drawOrder; } function readCurve(curve, timeline, bezier, frame, value, time1, time2, value1, value2, scale) { if (curve === "stepped") { timeline.setStepped(frame); return bezier; } const i = value << 2; const cx1 = curve[i]; const cy1 = curve[i + 1] * scale; const cx2 = curve[i + 2]; const cy2 = curve[i + 3] * scale; timeline.setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); return bezier + 1; } function getValue(map, property, defaultValue) { return map[property] !== void 0 ? map[property] : defaultValue; } // spine-core/src/SkeletonPhysicsMovement.ts var SkeletonPhysicsMovement = class { /** * Creates a movement tracker for a skeleton displayed by a host runtime object. * @param skeleton The skeleton whose physics constraints receive inherited movement. * @param adapter Runtime-specific hooks used to read and convert the host object's transform. * @param options Initial movement inheritance values. */ constructor(skeleton, adapter, options = {}) { this.skeleton = skeleton; this.adapter = adapter; this.positionInheritanceFactorX = options.positionInheritanceX ?? 0; this.positionInheritanceFactorY = options.positionInheritanceY ?? 0; this.rotationInheritanceFactor = options.rotationInheritance ?? 0; } positionInheritanceFactorX = 0; positionInheritanceFactorY = 0; rotationInheritanceFactor = 0; hasLastTransform = false; lastX = 0; lastY = 0; lastZ = 0; lastRotation = 0; currentTransform = { x: 0, y: 0, z: 0, rotation: 0 }; currentPosition = { x: 0, y: 0, z: 0 }; lastPosition = { x: 0, y: 0, z: 0 }; /** Horizontal position inheritance factor. `0` disables horizontal position inheritance. */ get positionInheritanceX() { return this.positionInheritanceFactorX; } /** Vertical position inheritance factor. `0` disables vertical position inheritance. */ get positionInheritanceY() { return this.positionInheritanceFactorY; } /** * Sets how much host object translation is inherited by skeleton physics constraints. * Use `(1, 1)` for normal inheritance, or `(0, 0)` to disable position inheritance. * @param x The horizontal position inheritance factor. * @param y The vertical position inheritance factor. */ setPositionInheritance(x, y) { const wasDisabled = this.positionInheritanceFactorX === 0 && this.positionInheritanceFactorY === 0; const isEnabled = x !== 0 || y !== 0; this.positionInheritanceFactorX = x; this.positionInheritanceFactorY = y; if (wasDisabled && isEnabled) this.resetPosition(); } /** Rotation inheritance factor. `0` disables rotation inheritance. */ get rotationInheritance() { return this.rotationInheritanceFactor; } /** * Sets how much host object rotation is inherited by skeleton physics constraints. * @param value The rotation inheritance factor. */ set rotationInheritance(value) { const wasDisabled = this.rotationInheritanceFactor === 0; this.rotationInheritanceFactor = value; if (wasDisabled && value !== 0) this.resetRotation(); } /** Resets the previous position used to calculate inherited translation. */ resetPosition() { const transform = this.currentTransform; const readRotation = !this.hasLastTransform && this.rotationInheritanceFactor !== 0; this.adapter.readTransform(transform, readRotation); this.lastX = transform.x; this.lastY = transform.y; this.lastZ = transform.z; if (readRotation) this.lastRotation = transform.rotation; this.hasLastTransform = true; } /** Resets the previous rotation used to calculate inherited rotation. */ resetRotation() { const transform = this.currentTransform; this.adapter.readTransform(transform, true); this.lastRotation = transform.rotation; if (!this.hasLastTransform) { this.lastX = transform.x; this.lastY = transform.y; this.lastZ = transform.z; } this.hasLastTransform = true; } /** Resets both previous position and previous rotation. */ resetTransform() { const transform = this.currentTransform; this.adapter.readTransform(transform, true); this.setLastTransform(transform.x, transform.y, transform.z, transform.rotation); } /** * Applies host object transform movement since the previous call to the skeleton's physics constraints. * * The first call records the current transform as the baseline and does not apply movement. */ applyTransformMovement() { const inheritPosition = this.positionInheritanceFactorX !== 0 || this.positionInheritanceFactorY !== 0; const inheritRotation = this.rotationInheritanceFactor !== 0; if (!inheritPosition && !inheritRotation) return; const transform = this.currentTransform; this.adapter.readTransform(transform, inheritRotation); const { x, y, z } = transform; const currentRotation = inheritRotation ? transform.rotation : this.lastRotation; const positionChanged = x !== this.lastX || y !== this.lastY || z !== this.lastZ; if (this.hasLastTransform) { if (!positionChanged && currentRotation === this.lastRotation) return; if (inheritPosition && positionChanged) this.applyPositionMovement(x, y, z); if (inheritRotation && currentRotation !== this.lastRotation) this.applyRotationMovement(currentRotation); } this.setLastTransform(x, y, z, currentRotation); } applyPositionMovement(currentX, currentY, currentZ) { const currentPosition = this.currentPosition; currentPosition.x = currentX; currentPosition.y = currentY; currentPosition.z = currentZ; this.adapter.worldToSkeleton(currentPosition); const lastPosition = this.lastPosition; lastPosition.x = this.lastX; lastPosition.y = this.lastY; lastPosition.z = this.lastZ; this.adapter.worldToSkeleton(lastPosition); this.skeleton.physicsTranslate( (currentPosition.x - lastPosition.x) * this.positionInheritanceFactorX, (currentPosition.y - lastPosition.y) * this.positionInheritanceFactorY ); } applyRotationMovement(currentRotation) { const rotationFactor = this.rotationInheritanceFactor; if (rotationFactor === 0) return; this.skeleton.physicsRotate(0, 0, this.getRotationDelta(currentRotation, this.lastRotation) * rotationFactor); } setLastTransform(x, y, z, rotation) { this.lastX = x; this.lastY = y; this.lastZ = z; this.lastRotation = rotation; this.hasLastTransform = true; } getRotationDelta(current, previous) { let delta = current - previous; delta = (delta + 180) % 360 - 180; return delta < -180 ? delta + 360 : delta; } }; // spine-core/src/SkeletonRendererCore.ts var SkeletonRendererCore = class { commandPool = new CommandPool(); worldVertices = new Float32Array(12 * 1024); quadIndices = new Uint16Array([0, 1, 2, 2, 3, 0]); clipping = new SkeletonClipping(); renderCommands = []; render(skeleton, pma = false, inColor, stride = 2, slotZOffset = 0) { this.commandPool.reset(); this.renderCommands.length = 0; const clipper = this.clipping; let z = 0; const drawOrder = skeleton.drawOrder.appliedPose; for (let i = 0, n = drawOrder.length; i < n; i++) { const slot = drawOrder[i]; if (!slot.bone.active) { clipper.clipEnd(slot); continue; } const pose = slot.appliedPose; const attachment = pose.attachment; if (!attachment) { clipper.clipEnd(slot); continue; } const slotColor = pose.color; const alpha = slotColor.a; if (alpha === 0 && !(attachment instanceof ClippingAttachment)) { clipper.clipEnd(slot); continue; } let vertices; let verticesCount; let uvs; let indices; let indicesCount; let attachmentColor; let texture; if (attachment instanceof RegionAttachment) { attachmentColor = attachment.color; if (attachmentColor.a === 0) { clipper.clipEnd(slot); continue; } const sequence = attachment.sequence; const sequenceIndex = sequence.resolveIndex(pose); attachment.computeWorldVertices(slot, attachment.getOffsets(pose), this.worldVertices, 0, stride); vertices = this.worldVertices; verticesCount = 4; uvs = sequence.getUVs(sequenceIndex); indices = this.quadIndices; indicesCount = 6; texture = sequence.regions[sequenceIndex]?.texture; } else if (attachment instanceof MeshAttachment) { attachmentColor = attachment.color; if (attachmentColor.a === 0) { clipper.clipEnd(slot); continue; } if (this.worldVertices.length < attachment.worldVerticesLength) this.worldVertices = new Float32Array(attachment.worldVerticesLength); attachment.computeWorldVertices(skeleton, slot, 0, attachment.worldVerticesLength, this.worldVertices, 0, stride); vertices = this.worldVertices; verticesCount = attachment.worldVerticesLength >> 1; const sequence = attachment.sequence; const sequenceIndex = sequence.resolveIndex(pose); uvs = sequence.getUVs(sequenceIndex); indices = attachment.triangles; indicesCount = indices.length; texture = sequence.regions[sequenceIndex]?.texture; } else if (attachment instanceof ClippingAttachment) { clipper.clipEnd(slot); clipper.clipStart(skeleton, slot, attachment); continue; } else { clipper.clipEnd(slot); continue; } if (!texture) { clipper.clipEnd(slot); continue; } const skelColor = skeleton.color; let color, darkColor; if (pma) { let a; if (inColor) { a = Math.floor(inColor[3] * skelColor.a * slotColor.a * attachmentColor.a * 255); const r = Math.floor(a * inColor[0] * skelColor.r * slotColor.r * attachmentColor.r); const g = Math.floor(a * inColor[1] * skelColor.g * slotColor.g * attachmentColor.g); const b = Math.floor(a * inColor[2] * skelColor.b * slotColor.b * attachmentColor.b); color = a << 24 | r << 16 | g << 8 | b; } else { a = Math.floor(skelColor.a * slotColor.a * attachmentColor.a * 255); const r = Math.floor(a * skelColor.r * slotColor.r * attachmentColor.r); const g = Math.floor(a * skelColor.g * slotColor.g * attachmentColor.g); const b = Math.floor(a * skelColor.b * slotColor.b * attachmentColor.b); color = a << 24 | r << 16 | g << 8 | b; } darkColor = 4278190080; if (pose.darkColor) { const { r, g, b } = pose.darkColor; darkColor = 4278190080 | Math.floor(r * a) << 16 | Math.floor(g * a) << 8 | Math.floor(b * a); } } else { if (inColor) { const a = Math.floor(inColor[3] * skelColor.a * slotColor.a * attachmentColor.a * 255); const r = Math.floor(inColor[0] * skelColor.r * slotColor.r * attachmentColor.r * 255); const g = Math.floor(inColor[1] * skelColor.g * slotColor.g * attachmentColor.g * 255); const b = Math.floor(inColor[2] * skelColor.b * slotColor.b * attachmentColor.b * 255); color = a << 24 | r << 16 | g << 8 | b; } else { const a = Math.floor(skelColor.a * slotColor.a * attachmentColor.a * 255); const r = Math.floor(skelColor.r * slotColor.r * attachmentColor.r * 255); const g = Math.floor(skelColor.g * slotColor.g * attachmentColor.g * 255); const b = Math.floor(skelColor.b * slotColor.b * attachmentColor.b * 255); color = a << 24 | r << 16 | g << 8 | b; } darkColor = 0; if (pose.darkColor) { const { r, g, b } = pose.darkColor; darkColor = Math.floor(r * 255) << 16 | Math.floor(g * 255) << 8 | Math.floor(b * 255); } } if (clipper.isClipping()) { clipper.clipTrianglesUnpacked(vertices, 0, indices, indicesCount, uvs, stride); vertices = clipper.clippedVerticesTyped; verticesCount = clipper.clippedVerticesLength / stride; uvs = clipper.clippedUVsTyped; indices = clipper.clippedTrianglesTyped; indicesCount = clipper.clippedTrianglesLength; } const cmd = this.commandPool.getCommand(verticesCount, indicesCount, stride); cmd.blendMode = slot.data.blendMode; cmd.texture = texture; cmd.positions.set(vertices.subarray(0, verticesCount * stride)); if (stride >= 3) { for (let j = 2, n2 = verticesCount * stride; j < n2; j += stride) cmd.positions[j] = z; } cmd.uvs.set(uvs.subarray(0, verticesCount << 1)); for (let j = 0; j < verticesCount; j++) { cmd.colors[j] = color; cmd.darkColors[j] = darkColor; } if (indices instanceof Uint16Array) { cmd.indices.set(indices.subarray(0, indicesCount)); } else { cmd.indices.set(indices.slice(0, indicesCount)); } this.renderCommands.push(cmd); z += slotZOffset; clipper.clipEnd(slot); } clipper.clipEnd(); return this.batchCommands(stride); } batchSubCommands(commands, first, last, numVertices, numIndices, stride) { const firstCmd = commands[first]; const batched = this.commandPool.getCommand(numVertices, numIndices, stride); batched.blendMode = firstCmd.blendMode; batched.texture = firstCmd.texture; let positionsOffset = 0; let uvsOffset = 0; let colorsOffset = 0; let indicesOffset = 0; let vertexOffset = 0; for (let i = first; i <= last; i++) { const cmd = commands[i]; batched.positions.set(cmd.positions, positionsOffset); positionsOffset += cmd.numVertices * stride; batched.uvs.set(cmd.uvs, uvsOffset); uvsOffset += cmd.numVertices << 1; batched.colors.set(cmd.colors, colorsOffset); batched.darkColors.set(cmd.darkColors, colorsOffset); colorsOffset += cmd.numVertices; for (let j = 0; j < cmd.numIndices; j++) batched.indices[indicesOffset + j] = cmd.indices[j] + vertexOffset; indicesOffset += cmd.numIndices; vertexOffset += cmd.numVertices; } return batched; } batchCommands(stride) { if (this.renderCommands.length === 0) return void 0; let root; let last; let first = this.renderCommands[0]; let startIndex = 0; let i = 1; let numVertices = first.numVertices; let numIndices = first.numIndices; while (i <= this.renderCommands.length) { const cmd = i < this.renderCommands.length ? this.renderCommands[i] : null; if (cmd && cmd.numVertices === 0 && cmd.numIndices === 0) { i++; continue; } const canBatch = cmd !== null && cmd.texture === first.texture && cmd.blendMode === first.blendMode && cmd.colors[0] === first.colors[0] && cmd.darkColors[0] === first.darkColors[0] && numIndices + cmd.numIndices < 65535; if (canBatch) { numVertices += cmd.numVertices; numIndices += cmd.numIndices; } else { const batched = this.batchSubCommands( this.renderCommands, startIndex, i - 1, numVertices, numIndices, stride ); if (!last) { root = last = batched; } else { last.next = batched; last = batched; } if (i === this.renderCommands.length) break; first = this.renderCommands[i]; startIndex = i; numVertices = first.numVertices; numIndices = first.numIndices; } i++; } return root; } }; var CommandPool = class { pool = []; inUse = []; getCommand(numVertices, numIndices, stride) { let cmd; for (const c of this.pool) { if (c._positions.length >= numVertices * stride && c._indices.length >= numIndices) { cmd = c; break; } } if (!cmd) { const _positions = new Float32Array(numVertices * stride); const _uvs = new Float32Array(numVertices << 1); const _colors = new Uint32Array(numVertices); const _darkColors = new Uint32Array(numVertices); const _indices = new Uint16Array(numIndices); cmd = { positions: _positions, uvs: _uvs, colors: _colors, darkColors: _darkColors, indices: _indices, _positions, _uvs, _colors, _darkColors, _indices, numVertices, numIndices, blendMode: 0 /* Normal */, texture: null }; } else { this.pool.splice(this.pool.indexOf(cmd), 1); cmd.next = void 0; cmd.numVertices = numVertices; cmd.numIndices = numIndices; cmd.positions = cmd._positions.subarray(0, numVertices * stride); cmd.uvs = cmd._uvs.subarray(0, numVertices << 1); cmd.colors = cmd._colors.subarray(0, numVertices); cmd.darkColors = cmd._darkColors.subarray(0, numVertices); cmd.indices = cmd._indices.subarray(0, numIndices); } this.inUse.push(cmd); return cmd; } reset() { this.pool.push(...this.inUse); this.inUse.length = 0; } }; // spine-pixi-v7/src/assets/AtlasLoader.ts import { Assets, checkExtension, copySearchParams, LoaderParserPriority } from "@pixi/assets"; import { ALPHA_MODES, BaseTexture, ExtensionType, extensions, settings, utils } from "@pixi/core"; // spine-pixi-v7/src/SpineTexture.ts import { BLEND_MODES, MIPMAP_MODES, Texture as PixiTexture, SCALE_MODES, WRAP_MODES } from "@pixi/core"; var SpineTexture = class _SpineTexture extends Texture { static textureMap = /* @__PURE__ */ new Map(); static from(texture) { if (_SpineTexture.textureMap.has(texture)) { return _SpineTexture.textureMap.get(texture); } return new _SpineTexture(texture); } texture; constructor(image) { super(image.resource.source); this.texture = PixiTexture.from(image); } setFilters(minFilter, _magFilter) { this.texture.baseTexture.scaleMode = _SpineTexture.toPixiTextureFilter(minFilter); this.texture.baseTexture.mipmap = _SpineTexture.toPixiMipMap(minFilter); } setWraps(uWrap, _vWrap) { this.texture.baseTexture.wrapMode = _SpineTexture.toPixiTextureWrap(uWrap); } dispose() { this.texture.destroy(); } static toPixiTextureFilter(filter) { switch (filter) { case 9728 /* Nearest */: case 9986 /* MipMapNearestLinear */: case 9984 /* MipMapNearestNearest */: return SCALE_MODES.NEAREST; case 9729 /* Linear */: case 9987 /* MipMapLinearLinear */: // TextureFilter.MipMapLinearLinear == TextureFilter.MipMap case 9985 /* MipMapLinearNearest */: return SCALE_MODES.LINEAR; default: throw new Error(`Unknown texture filter: ${String(filter)}`); } } static toPixiMipMap(filter) { switch (filter) { case 9728 /* Nearest */: case 9729 /* Linear */: return MIPMAP_MODES.OFF; case 9986 /* MipMapNearestLinear */: case 9984 /* MipMapNearestNearest */: case 9987 /* MipMapLinearLinear */: // TextureFilter.MipMapLinearLinear == TextureFilter.MipMap case 9985 /* MipMapLinearNearest */: return MIPMAP_MODES.ON; default: throw new Error(`Unknown texture filter: ${String(filter)}`); } } static toPixiTextureWrap(wrap) { switch (wrap) { case 33071 /* ClampToEdge */: return WRAP_MODES.CLAMP; case 33648 /* MirroredRepeat */: return WRAP_MODES.MIRRORED_REPEAT; case 10497 /* Repeat */: return WRAP_MODES.REPEAT; default: throw new Error(`Unknown texture wrap: ${String(wrap)}`); } } static toPixiBlending(blend) { switch (blend) { case 0 /* Normal */: return BLEND_MODES.NORMAL; case 1 /* Additive */: return BLEND_MODES.ADD; case 2 /* Multiply */: return BLEND_MODES.MULTIPLY; case 3 /* Screen */: return BLEND_MODES.SCREEN; default: throw new Error(`Unknown blendMode: ${String(blend)}`); } } }; // spine-pixi-v7/src/assets/AtlasLoader.ts var loaderName = "spineTextureAtlasLoader"; var spineTextureAtlasLoader = { extension: ExtensionType.Asset, resolver: { test: (value) => checkExtension(value, ".atlas"), parse: (value) => { const split = value.split("."); return { resolution: parseFloat(settings.RETINA_PREFIX?.exec(value)?.[1] ?? "1"), format: split[split.length - 2], src: value }; } }, loader: { name: loaderName, extension: { type: ExtensionType.LoadParser, priority: LoaderParserPriority.Normal, name: loaderName }, test(url) { return checkExtension(url, ".atlas"); }, async load(url) { const response = await settings.ADAPTER.fetch(url); if (!response.ok) throw new Error(`[${loaderName}] Failed to fetch ${url}: ${response.status} ${response.statusText}`); return await response.text(); }, testParse(asset, options) { const isExtensionRight = checkExtension(options.src, ".atlas"); const isString = typeof asset === "string"; const isExplicitLoadParserSet = options.loadParser === loaderName; return Promise.resolve((isExtensionRight || isExplicitLoadParserSet) && isString); }, unload(atlas) { atlas.dispose(); }, async parse(asset, options, loader) { const metadata = options.data || {}; let basePath = utils.path.dirname(options.src); if (basePath && basePath.lastIndexOf("/") !== basePath.length - 1) { basePath += "/"; } const retval = new TextureAtlas(asset); if (metadata.images instanceof BaseTexture || typeof metadata.images === "string") { const pixiTexture = metadata.images; metadata.images = {}; metadata.images[retval.pages[0].name] = pixiTexture; } const textureLoadingPromises = []; let oldPreferCreateImageBitmap = true; for (const parser of loader.parsers) { if (parser.name === "loadTextures") { oldPreferCreateImageBitmap = parser.config?.preferCreateImageBitmap; break; } } Assets.setPreferences({ preferCreateImageBitmap: false }); for (const page of retval.pages) { const pageName = page.name; const providedPage = metadata?.images ? metadata.images[pageName] : void 0; if (providedPage instanceof BaseTexture) { page.setTexture(SpineTexture.from(providedPage)); } else { const url = providedPage ?? utils.path.normalize([...basePath.split(utils.path.sep), pageName].join(utils.path.sep)); const assetsToLoadIn = { src: copySearchParams(url, options.src), data: { ...metadata.imageMetadata, ...{ alphaMode: page.pma ? ALPHA_MODES.PMA : ALPHA_MODES.UNPACK } } }; const pixiPromise = loader.load(assetsToLoadIn).then((texture) => { page.setTexture(SpineTexture.from(texture.baseTexture)); }); textureLoadingPromises.push(pixiPromise); } } await Promise.all(textureLoadingPromises); Assets.setPreferences({ preferCreateImageBitmap: oldPreferCreateImageBitmap }); return retval; } } }; extensions.add(spineTextureAtlasLoader); // spine-pixi-v7/src/assets/SkeletonLoader.ts import { checkExtension as checkExtension2, LoaderParserPriority as LoaderParserPriority2 } from "@pixi/assets"; import { ExtensionType as ExtensionType2, extensions as extensions2, settings as settings2 } from "@pixi/core"; var loaderName2 = "spineSkeletonLoader"; function isJson(resource) { return resource.hasOwnProperty("bones"); } function isBuffer(resource) { return resource instanceof Uint8Array; } var spineLoaderExtension = { extension: ExtensionType2.Asset, loader: { name: loaderName2, extension: { type: ExtensionType2.LoadParser, priority: LoaderParserPriority2.Normal, name: loaderName2 }, test(url) { return checkExtension2(url, ".skel"); }, async load(url) { const response = await settings2.ADAPTER.fetch(url); if (!response.ok) throw new Error(`[${loaderName2}] Failed to fetch ${url}: ${response.status} ${response.statusText}`); return new Uint8Array(await response.arrayBuffer()); }, testParse(asset, options) { const isJsonSpineModel = checkExtension2(options.src, ".json") && isJson(asset); const isBinarySpineModel = checkExtension2(options.src, ".skel") && isBuffer(asset); const isExplicitLoadParserSet = options.loadParser === loaderName2; return Promise.resolve(isJsonSpineModel || isBinarySpineModel || isExplicitLoadParserSet); } } }; extensions2.add(spineLoaderExtension); // spine-pixi-v7/src/darkTintMesh/DarkTintMesh.ts import { Mesh } from "@pixi/mesh"; // spine-pixi-v7/src/darkTintMesh/DarkTintGeom.ts import { Buffer, Geometry, TYPES } from "@pixi/core"; var DarkTintGeometry = class extends Geometry { /** * @param {boolean} [_static=false] - Optimization flag, where `false` * is updated every frame, `true` doesn't change frame-to-frame. */ constructor(_static = false) { super(); const verticesBuffer = new Buffer(void 0); const uvsBuffer = new Buffer(void 0, true); const indexBuffer = new Buffer(void 0, true, true); this.addAttribute("aVertexPosition", verticesBuffer, 2, false, TYPES.FLOAT); this.addAttribute("aTextureCoord", uvsBuffer, 2, false, TYPES.FLOAT); this.addIndex(indexBuffer); } }; // spine-pixi-v7/src/darkTintMesh/DarkTintMaterial.ts import { Color as Color2, Matrix, Program, Shader, Texture as Texture2, TextureMatrix } from "@pixi/core"; var vertex = ` attribute vec2 aVertexPosition; attribute vec2 aTextureCoord; uniform mat3 projectionMatrix; uniform mat3 translationMatrix; uniform mat3 uTextureMatrix; varying vec2 vTextureCoord; void main(void) { gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0); vTextureCoord = (uTextureMatrix * vec3(aTextureCoord, 1.0)).xy; } `; var fragment = ` varying vec2 vTextureCoord; uniform vec4 uColor; uniform vec4 uDarkColor; uniform sampler2D uSampler; void main(void) { vec4 texColor = texture2D(uSampler, vTextureCoord); gl_FragColor.a = texColor.a * uColor.a; gl_FragColor.rgb = ((texColor.a - 1.0) * uDarkColor.a + 1.0 - texColor.rgb) * uDarkColor.rgb + texColor.rgb * uColor.rgb; } `; var DarkTintMaterial = class extends Shader { uvMatrix; batchable; pluginName; // eslint-disable-next-line @typescript-eslint/naming-convention _tintRGB; // eslint-disable-next-line @typescript-eslint/naming-convention _darkTintRGB; /** * Only do update if tint or alpha changes. * @private * @default false */ _colorDirty; _alpha; _tintColor; _darkTintColor; constructor(texture) { const uniforms = { uSampler: texture ?? Texture2.EMPTY, alpha: 1, uTextureMatrix: Matrix.IDENTITY, uColor: new Float32Array([1, 1, 1, 1]), uDarkColor: new Float32Array([0, 0, 0, 0]) }; const options = { tint: 16777215, darkTint: 0, alpha: 1, pluginName: "darkTintBatch" }; super(Program.from(vertex, fragment), uniforms); this._colorDirty = false; this.uvMatrix = new TextureMatrix(uniforms.uSampler); this.batchable = true; this.pluginName = options.pluginName; this._tintColor = new Color2(options.tint); this._darkTintColor = new Color2(options.darkTint); this._tintRGB = this._tintColor.toLittleEndianNumber(); this._darkTintRGB = this._darkTintColor.toLittleEndianNumber(); this._alpha = options.alpha; this._colorDirty = true; } get texture() { return this.uniforms.uSampler; } set texture(value) { if (this.uniforms.uSampler !== value) { if (!this.uniforms.uSampler.baseTexture.alphaMode !== !value.baseTexture.alphaMode) { this._colorDirty = true; } this.uniforms.uSampler = value; this.uvMatrix.texture = value; } } set alpha(value) { if (value === this._alpha) { return; } this._alpha = value; this._colorDirty = true; } get alpha() { return this._alpha; } set tint(value) { if (value === this.tint) { return; } this._tintColor.setValue(value); this._tintRGB = this._tintColor.toLittleEndianNumber(); this._colorDirty = true; } get tint() { return this._tintColor.value; } set darkTint(value) { if (value === this.darkTint) { return; } this._darkTintColor.setValue(value); this._darkTintRGB = this._darkTintColor.toLittleEndianNumber(); this._colorDirty = true; } get darkTint() { return this._darkTintColor.value; } get tintValue() { return this._tintColor.toNumber(); } get darkTintValue() { return this._darkTintColor.toNumber(); } /** Gets called automatically by the Mesh. Intended to be overridden for custom {@link PIXI.MeshMaterial} objects. */ update() { if (this._colorDirty) { this._colorDirty = false; Color2.shared.setValue(this._tintColor).premultiply(this._alpha, true).toArray(this.uniforms.uColor); Color2.shared.setValue(this._darkTintColor).premultiply(this._alpha, true).premultiply(1, false).toArray(this.uniforms.uDarkColor); } if (this.uvMatrix.update()) { this.uniforms.uTextureMatrix = this.uvMatrix.mapCoord; } } }; // spine-pixi-v7/src/darkTintMesh/DarkTintMesh.ts var DarkTintMesh = class extends Mesh { // eslint-disable-next-line @typescript-eslint/naming-convention _darkTintRGB = 0; constructor(texture) { super(new DarkTintGeometry(), new DarkTintMaterial(texture), void 0, void 0); } get darkTint() { return "darkTint" in this.shader ? this.shader.darkTint : null; } set darkTint(value) { this.shader.darkTint = value; } get darkTintValue() { return this.shader.darkTintValue; } // eslint-disable-next-line @typescript-eslint/naming-convention _renderToBatch(renderer) { const geometry = this.geometry; const shader = this.shader; if (shader.uvMatrix) { shader.uvMatrix.update(); this.calculateUvs(); } this.calculateVertices(); this.indices = geometry.indexBuffer.data; this._tintRGB = shader._tintRGB; this._darkTintRGB = shader._darkTintRGB; this._texture = shader.texture; const pluginName = this.material.pluginName; renderer.batch.setObjectRenderer(renderer.plugins[pluginName]); renderer.plugins[pluginName].render(this); } }; // spine-pixi-v7/src/DarkSlotMesh.ts var DarkSlotMesh = class _DarkSlotMesh extends DarkTintMesh { name = ""; static auxColor = [0, 0, 0, 0]; constructor() { super(); } updateFromSpineData(slotTexture, slotBlendMode, slotName, finalVertices, finalVerticesLength, finalIndices, finalIndicesLength, darkTint) { this.texture = slotTexture.texture; const vertLenght = finalVerticesLength / (darkTint ? 12 : 8) * 2; const textureCoord = this.geometry.getBuffer("aTextureCoord"); if (textureCoord.data?.length !== vertLenght) { textureCoord.data = new Float32Array(vertLenght); } const vertexCoord = this.geometry.getBuffer("aVertexPosition"); if (vertexCoord.data?.length !== vertLenght) { vertexCoord.data = new Float32Array(vertLenght); } let vertIndex = 0; const textureCoordData = textureCoord.data; const vertexCoordData = vertexCoord.data; for (let i = 0; i < finalVerticesLength; i += darkTint ? 12 : 8) { let auxi = i; vertexCoordData[vertIndex] = finalVertices[auxi++]; vertexCoordData[vertIndex + 1] = finalVertices[auxi++]; auxi += 4; textureCoordData[vertIndex] = finalVertices[auxi++]; textureCoordData[vertIndex + 1] = finalVertices[auxi++]; vertIndex += 2; } if (darkTint) { _DarkSlotMesh.auxColor[0] = finalVertices[8]; _DarkSlotMesh.auxColor[1] = finalVertices[9]; _DarkSlotMesh.auxColor[2] = finalVertices[10]; _DarkSlotMesh.auxColor[3] = finalVertices[11]; this.darkTint = _DarkSlotMesh.auxColor; _DarkSlotMesh.auxColor[0] = finalVertices[2]; _DarkSlotMesh.auxColor[1] = finalVertices[3]; _DarkSlotMesh.auxColor[2] = finalVertices[4]; _DarkSlotMesh.auxColor[3] = finalVertices[5]; this.tint = _DarkSlotMesh.auxColor; } else { _DarkSlotMesh.auxColor[0] = finalVertices[2]; _DarkSlotMesh.auxColor[1] = finalVertices[3]; _DarkSlotMesh.auxColor[2] = finalVertices[4]; _DarkSlotMesh.auxColor[3] = finalVertices[5]; this.tint = _DarkSlotMesh.auxColor; } this.blendMode = SpineTexture.toPixiBlending(slotBlendMode); this.alpha = _DarkSlotMesh.auxColor[3]; const indexBuffer = this.geometry.indexBuffer; if (indexBuffer.data.length !== finalIndices.length) { indexBuffer.data = new Uint32Array(finalIndices); } else { const indexBufferData = indexBuffer.data; for (let i = 0; i < finalIndicesLength; i++) { indexBufferData[i] = finalIndices[i]; } } this.name = slotName; textureCoord.update(); vertexCoord.update(); indexBuffer.update(); } }; // spine-pixi-v7/src/darkTintMesh/DarkTintBatchGeom.ts import { Buffer as Buffer2, Geometry as Geometry2, TYPES as TYPES2 } from "@pixi/core"; var DarkTintBatchGeometry = class extends Geometry2 { // eslint-disable-next-line @typescript-eslint/naming-convention _buffer; // eslint-disable-next-line @typescript-eslint/naming-convention _indexBuffer; /** * @param {boolean} [_static=false] - Optimization flag, where `false` * is updated every frame, `true` doesn't change frame-to-frame. */ constructor(_static = false) { super(); this._buffer = new Buffer2(void 0, _static, false); this._indexBuffer = new Buffer2(void 0, _static, true); this.addAttribute("aVertexPosition", this._buffer, 2, false, TYPES2.FLOAT).addAttribute("aTextureCoord", this._buffer, 2, false, TYPES2.FLOAT).addAttribute("aColor", this._buffer, 4, true, TYPES2.UNSIGNED_BYTE).addAttribute("aDarkColor", this._buffer, 4, true, TYPES2.UNSIGNED_BYTE).addAttribute("aTextureId", this._buffer, 1, true, TYPES2.FLOAT).addIndex(this._indexBuffer); } }; // spine-pixi-v7/src/darkTintMesh/DarkTintRenderer.ts import { BatchRenderer, BatchShaderGenerator, Color as Color3, ExtensionType as ExtensionType3, extensions as extensions3 } from "@pixi/core"; var vertex2 = ` precision highp float; attribute vec2 aVertexPosition; attribute vec2 aTextureCoord; attribute vec4 aColor; attribute vec4 aDarkColor; attribute float aTextureId; uniform mat3 projectionMatrix; uniform mat3 translationMatrix; uniform vec4 tint; varying vec2 vTextureCoord; varying vec4 vColor; varying vec4 vDarkColor; varying float vTextureId; void main(void){ gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0); vTextureCoord = aTextureCoord; vTextureId = aTextureId; vColor = aColor * tint; vDarkColor = aDarkColor * tint; } `; var fragment2 = ` varying vec2 vTextureCoord; varying vec4 vColor; varying vec4 vDarkColor; varying float vTextureId; uniform sampler2D uSamplers[%count%]; void main(void){ vec4 color; %forloop% gl_FragColor.a = color.a * vColor.a; gl_FragColor.rgb = ((color.a - 1.0) * vDarkColor.a + 1.0 - color.rgb) * vDarkColor.rgb + color.rgb * vColor.rgb; } `; var DarkTintRenderer = class extends BatchRenderer { static extension = { name: "darkTintBatch", type: ExtensionType3.RendererPlugin }; constructor(renderer) { super(renderer); this.shaderGenerator = new BatchShaderGenerator(vertex2, fragment2); this.geometryClass = DarkTintBatchGeometry; this.vertexSize = 7; } packInterleavedGeometry(element, attributeBuffer, indexBuffer, aIndex, iIndex) { const { uint32View, float32View } = attributeBuffer; const packedVertices = aIndex / this.vertexSize; const uvs = element.uvs; const indicies = element.indices; const vertexData = element.vertexData; const textureId = element._texture.baseTexture._batchLocation; const worldAlpha = Math.min(element.worldAlpha, 1); const argb = Color3.shared.setValue(element._tintRGB).toPremultiplied(worldAlpha, true); const darkargb = Color3.shared.setValue(element._darkTintRGB).premultiply(worldAlpha, true).toPremultiplied(1, false); for (let i = 0; i < vertexData.length; i += 2) { float32View[aIndex++] = vertexData[i]; float32View[aIndex++] = vertexData[i + 1]; float32View[aIndex++] = uvs[i]; float32View[aIndex++] = uvs[i + 1]; uint32View[aIndex++] = argb; uint32View[aIndex++] = darkargb; float32View[aIndex++] = textureId; } for (let i = 0; i < indicies.length; i++) { indexBuffer[iIndex++] = packedVertices + indicies[i]; } } }; extensions3.add(DarkTintRenderer); // spine-pixi-v7/src/SlotMesh.ts import { Texture as Texture3 } from "@pixi/core"; import { Mesh as Mesh2, MeshGeometry, MeshMaterial } from "@pixi/mesh"; var SlotMesh = class _SlotMesh extends Mesh2 { name = ""; static auxColor = [0, 0, 0, 0]; warnedTwoTint = false; constructor() { const geometry = new MeshGeometry(); geometry.getBuffer("aVertexPosition").static = false; geometry.getBuffer("aTextureCoord").static = false; const meshMaterial = new MeshMaterial(Texture3.EMPTY); super(geometry, meshMaterial); } updateFromSpineData(slotTexture, slotBlendMode, slotName, finalVertices, finalVerticesLength, finalIndices, finalIndicesLength, darkTint) { this.texture = slotTexture.texture; const vertLenght = finalVerticesLength / (darkTint ? 12 : 8) * 2; const textureCoord = this.geometry.getBuffer("aTextureCoord"); if (textureCoord.data?.length !== vertLenght) { textureCoord.data = new Float32Array(vertLenght); } const vertexCoord = this.geometry.getBuffer("aVertexPosition"); if (vertexCoord.data?.length !== vertLenght) { vertexCoord.data = new Float32Array(vertLenght); } let vertIndex = 0; const textureCoordData = textureCoord.data; const vertexCoordData = vertexCoord.data; for (let i = 0; i < finalVerticesLength; i += darkTint ? 12 : 8) { let auxi = i; vertexCoordData[vertIndex] = finalVertices[auxi++]; vertexCoordData[vertIndex + 1] = finalVertices[auxi++]; auxi += 4; textureCoordData[vertIndex] = finalVertices[auxi++]; textureCoordData[vertIndex + 1] = finalVertices[auxi++]; vertIndex += 2; } if (darkTint && !this.warnedTwoTint) { console.warn("DarkTint is not enabled by default. To enable use a DarkSlotMesh factory while creating the Spine object."); this.warnedTwoTint = true; } _SlotMesh.auxColor[0] = finalVertices[2]; _SlotMesh.auxColor[1] = finalVertices[3]; _SlotMesh.auxColor[2] = finalVertices[4]; _SlotMesh.auxColor[3] = finalVertices[5]; this.tint = _SlotMesh.auxColor; this.alpha = _SlotMesh.auxColor[3]; this.blendMode = SpineTexture.toPixiBlending(slotBlendMode); const indexBuffer = this.geometry.indexBuffer; if (indexBuffer.data.length !== finalIndices.length) { indexBuffer.data = new Uint32Array(finalIndices); } else { const indexBufferData = indexBuffer.data; for (let i = 0; i < finalIndicesLength; i++) { indexBufferData[i] = finalIndices[i]; } } this.name = slotName; textureCoord.update(); vertexCoord.update(); indexBuffer.update(); } }; // spine-pixi-v7/src/Spine.ts import { Assets as Assets2 } from "@pixi/assets"; import { Point, Ticker } from "@pixi/core"; import { Bounds, Container } from "@pixi/display"; import { Graphics } from "@pixi/graphics"; import "@pixi/events"; var AABBRectangleBoundsProvider = class { constructor(x, y, width, height) { this.x = x; this.y = y; this.width = width; this.height = height; } calculateBounds() { return { x: this.x, y: this.y, width: this.width, height: this.height }; } }; var SetupPoseBoundsProvider = class { /** * @param clipping If true, clipping attachments are used to compute the bounds. False, by default. */ constructor(clipping = false) { this.clipping = clipping; } calculateBounds(gameObject) { if (!gameObject.skeleton) return { x: 0, y: 0, width: 0, height: 0 }; const skeleton = new Skeleton(gameObject.skeleton.data); skeleton.setupPose(); skeleton.updateWorldTransform(2 /* update */); const bounds = skeleton.getBoundsRect(this.clipping ? new SkeletonClipping() : void 0); return bounds.width === Number.NEGATIVE_INFINITY ? { x: 0, y: 0, width: 0, height: 0 } : bounds; } }; var SkinsAndAnimationBoundsProvider = class { /** * @param animation The animation to use for calculating the bounds. If null, the setup pose is used. * @param skins The skins to use for calculating the bounds. If empty, the default skin is used. * @param timeStep The time step to use for calculating the bounds. A smaller time step means more precision, but slower calculation. * @param clipping If true, clipping attachments are used to compute the bounds. False, by default. */ constructor(animation, skins = [], timeStep = 0.05, clipping = false) { this.animation = animation; this.skins = skins; this.timeStep = timeStep; this.clipping = clipping; } calculateBounds(gameObject) { if (!gameObject.skeleton || !gameObject.state) return { x: 0, y: 0, width: 0, height: 0 }; const animationState = new AnimationState(gameObject.state.data); const skeleton = new Skeleton(gameObject.skeleton.data); const clipper = this.clipping ? new SkeletonClipping() : void 0; const data = skeleton.data; if (this.skins.length > 0) { const customSkin = new Skin("custom-skin"); for (const skinName of this.skins) { const skin = data.findSkin(skinName); if (skin == null) continue; customSkin.addSkin(skin); } skeleton.setSkin(customSkin); } skeleton.setupPose(); const animation = this.animation != null ? data.findAnimation(this.animation) : null; if (animation == null) { skeleton.updateWorldTransform(2 /* update */); const bounds = skeleton.getBoundsRect(clipper); return bounds.width === Number.NEGATIVE_INFINITY ? { x: 0, y: 0, width: 0, height: 0 } : bounds; } else { let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY; animationState.clearTracks(); animationState.setAnimation(0, animation, false); const steps = Math.max(animation.duration / this.timeStep, 1); for (let i = 0; i < steps; i++) { const delta = i > 0 ? this.timeStep : 0; animationState.update(delta); animationState.apply(skeleton); skeleton.update(delta); skeleton.updateWorldTransform(2 /* update */); const bounds2 = skeleton.getBoundsRect(clipper); minX = Math.min(minX, bounds2.x); minY = Math.min(minY, bounds2.y); maxX = Math.max(maxX, bounds2.x + bounds2.width); maxY = Math.max(maxY, bounds2.y + bounds2.height); } const bounds = { x: minX, y: minY, width: maxX - minX, height: maxY - minY }; return bounds.width === Number.NEGATIVE_INFINITY ? { x: 0, y: 0, width: 0, height: 0 } : bounds; } } }; var Spine = class _Spine extends Container { /** The skeleton for this Spine game object. */ skeleton; /** The animation state for this Spine game object. */ state; /** Tracks this Pixi container's world movement and applies it to skeleton physics constraints. */ skeletonPhysics; darkTint = false; hasNeverUpdated = true; _debug = void 0; get debug() { return this._debug; } /** Pass a {@link SpineDebugRenderer} or create your own {@link ISpineDebugRenderer} to render bones, meshes, ... * @example spineGO.debug = new SpineDebugRenderer(); */ set debug(value) { if (this._debug) { this._debug.unregisterSpine(this); } if (value) { value.registerSpine(this); } this._debug = value; } slotMeshFactory = () => new SlotMesh(); beforeUpdateWorldTransforms = () => { }; afterUpdateWorldTransforms = () => { }; _autoUpdate = false; _ticker = Ticker.shared; get autoUpdate() { return this._autoUpdate; } /** When `true`, the Spine AnimationState and the Skeleton will be automatically updated using the {@link ticker}. */ set autoUpdate(value) { if (value && !this._autoUpdate) { this._ticker.add(this.internalUpdate, this); } else if (!value && this._autoUpdate) { this._ticker.remove(this.internalUpdate, this); } this._autoUpdate = value; } /** The ticker to use when {@link autoUpdate} is `true`. Defaults to {@link Ticker.shared}. */ get ticker() { return this._ticker; } /** Sets the ticker to use when {@link autoUpdate} is `true`. If `autoUpdate` is already `true`, the update callback will be moved from the old ticker to the new one. */ set ticker(value) { value = value ?? Ticker.shared; if (this._ticker === value) return; if (this._autoUpdate) { this._ticker.remove(this.internalUpdate, this); value.add(this.internalUpdate, this); } this._ticker = value; } meshesCache = /* @__PURE__ */ new Map(); static vectorAux = new Vector2(); static clipper = new SkeletonClipping(); static QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0]; static VERTEX_SIZE = 2 + 2 + 4; static DARK_VERTEX_SIZE = 2 + 2 + 4 + 4; lightColor = new Color(); darkColor = new Color(); clippingVertAux = new Float32Array(6); _boundsProvider; /** The bounds provider to use. If undefined the bounds will be dynamic, calculated when requested and based on the current frame. */ get boundsProvider() { return this._boundsProvider; } set boundsProvider(value) { this._boundsProvider = value; if (value) { this._boundsSpineID = -1; this._boundsSpineDirty = true; this.interactiveChildren = false; } else { this.interactiveChildren = true; this.hitArea = null; } if (!this.hasNeverUpdated) { this.calculateBounds(); } } _boundsPoint = new Point(); _boundsSpineID = -1; _boundsSpineDirty = true; constructor(options) { super(); if (options instanceof SkeletonData) options = { skeletonData: options }; else if ("skeleton" in options) options = new.target.createOptions(options); const { autoUpdate = true, boundsProvider, darkTint, skeletonData, ticker } = options; this.skeleton = new Skeleton(skeletonData); this.skeletonPhysics = new SkeletonPhysicsMovement(this.skeleton, { readTransform: (out, readRotation) => this.readPhysicsTransform(out, readRotation), worldToSkeleton: (point) => this.pixiWorldCoordinatesToSkeleton(point) }); this.state = new AnimationState(new AnimationStateData(skeletonData)); if (ticker) this._ticker = ticker; this.autoUpdate = autoUpdate; this.boundsProvider = boundsProvider; this.darkTint = darkTint === void 0 ? this.skeleton.slots.some((slot) => !!slot.data.setupPose.darkColor) : darkTint; if (this.darkTint) this.slotMeshFactory = () => new DarkSlotMesh(); } /** If {@link Spine.autoUpdate} is `false`, this method allows to update the AnimationState and the Skeleton with the given delta. */ update(deltaSeconds) { this.internalUpdate(0, deltaSeconds); } internalUpdate(_deltaFrame, deltaSeconds) { this.hasNeverUpdated = false; const delta = deltaSeconds ?? this._ticker.deltaMS / 1e3; this.state.update(delta); this.state.apply(this.skeleton); this.skeletonPhysics.applyTransformMovement(); this.beforeUpdateWorldTransforms(this); this.skeleton.update(delta); this.skeleton.updateWorldTransform(2 /* update */); this.afterUpdateWorldTransforms(this); } readPhysicsTransform(out, readRotation) { const transform = this.worldTransform; out.x = transform.tx; out.y = transform.ty; out.z = 0; if (!readRotation) return; let rotation = 0; for (let object = this; object; object = object.parent) { rotation += object.rotation + (object.skew.y - object.skew.x) / 2; } out.rotation = rotation * 180 / Math.PI; } /** Render the meshes based on the current skeleton state, render debug information, then call {@link Container.updateTransform}. */ updateTransform() { this.renderMeshes(); this.sortChildren(); this.debug?.renderDebug(this); super.updateTransform(); } /** Destroy Spine game object elements, then call the {@link Container.destroy} with the given options */ destroy(options) { if (this.autoUpdate) this.autoUpdate = false; this._ticker = null; for (const [, mesh] of this.meshesCache) { mesh?.destroy(); } this.state.clearListeners(); this.debug = void 0; this.meshesCache.clear(); this.slotsObject.clear(); for (const maskKey in this.clippingSlotToPixiMasks) { const mask = this.clippingSlotToPixiMasks[maskKey]; mask.destroy(); delete this.clippingSlotToPixiMasks[maskKey]; } super.destroy(options); } /** * Unloads this Spine object's cached {@link SkeletonData}. * * Existing Spine objects that use this SkeletonData continue to work. Future Spine objects created with the same * skeleton, atlas, and scale will parse a new SkeletonData. * @returns `true` if the cached SkeletonData was removed, otherwise `false`. */ unloadFromCache() { const skeletonData = this.skeleton?.data; if (!skeletonData) return false; const cacheKey = _Spine.skeletonDataCacheKeys.get(skeletonData); if (!cacheKey || _Spine.skeletonCache[cacheKey] !== skeletonData) return false; delete _Spine.skeletonCache[cacheKey]; _Spine.skeletonDataCacheKeys.delete(skeletonData); return true; } resetMeshes() { for (const [, mesh] of this.meshesCache) { mesh.zIndex = -1; mesh.visible = false; } } _calculateBounds() { if (this.hasNeverUpdated) { this.internalUpdate(0, 0); this.renderMeshes(); } } /** * Check the existence of a mesh for the given slot. * If you want to manually handle which meshes go on which slot and how you cache, overwrite this method. */ hasMeshForSlot(slot) { return this.meshesCache.has(slot); } /** * Search the mesh corresponding to the given slot or create it, if it does not exists. * If you want to manually handle which meshes go on which slot and how you cache, overwrite this method. */ getMeshForSlot(slot) { let mesh = this.hasMeshForSlot(slot) ? this.meshesCache.get(slot) : null; if (!mesh) { mesh = this.slotMeshFactory(); this.addChild(mesh); this.meshesCache.set(slot, mesh); } else { mesh.visible = true; } return mesh; } slotsObject = /* @__PURE__ */ new Map(); getSlotFromRef(slotRef) { let slot; if (typeof slotRef === "number") slot = this.skeleton.slots[slotRef]; else if (typeof slotRef === "string") slot = this.skeleton.findSlot(slotRef); else slot = slotRef; if (!slot) throw new Error(`No slot found with the given slot reference: ${slotRef}`); return slot; } /** * Add a pixi Container as a child of the Spine object. * The Container will be rendered coherently with the draw order of the slot. * If an attachment is active on the slot, the pixi Container will be rendered on top of it. * If the Container is already attached to the given slot, nothing will happen. * If the Container is already attached to another slot, it will be removed from that slot * before adding it to the given one. * If another Container is already attached to this slot, the old one will be removed from this * slot before adding it to the current one. * @param slotRef - The slot index, or the slot name, or the Slot where the pixi object will be added to. * @param pixiObject - The pixi Container to add. * @param options - Optional settings for the attachment. * @param options.followAttachmentTimeline - If true, the attachment will follow the slot's attachment timeline. * @param options.followSlotColor - If true, the container tint will follow the skeleton and slot colors. */ addSlotObject(slotRef, pixiObject, options) { const slot = this.getSlotFromRef(slotRef); const oldPixiObject = this.slotsObject.get(slot)?.container; if (oldPixiObject && oldPixiObject === pixiObject) return; for (const [otherSlot, { container: oldPixiObjectAnotherSlot }] of this.slotsObject) { if (otherSlot !== slot && oldPixiObjectAnotherSlot === pixiObject) { this.removeSlotObject(otherSlot, pixiObject); break; } } if (oldPixiObject) this.removeChild(oldPixiObject); this.slotsObject.set(slot, { container: pixiObject, followAttachmentTimeline: options?.followAttachmentTimeline || false, followSlotColor: options?.followSlotColor || false }); this.addChild(pixiObject); } /** * Return the Container connected to the given slot, if any. * Otherwise return undefined * @param pixiObject - The slot index, or the slot name, or the Slot to get the Container from. * @returns a Container if any, undefined otherwise. */ getSlotObject(slotRef) { const element = this.slotsObject.get(this.getSlotFromRef(slotRef)); return element ? element.container : void 0; } /** * Remove a slot object from the given slot. * If `pixiObject` is passed and attached to the given slot, remove it from the slot. * If `pixiObject` is not passed and the given slot has an attached Container, remove it from the slot. * @param slotRef - The slot index, or the slot name, or the Slot where the pixi object will be remove from. * @param pixiObject - Optional, The pixi Container to remove. */ removeSlotObject(slotRef, pixiObject) { const slot = this.getSlotFromRef(slotRef); const slotObject = this.slotsObject.get(slot)?.container; if (!slotObject) return; if (pixiObject && pixiObject !== slotObject) return; this.removeChild(slotObject); this.slotsObject.delete(slot); } /** * Removes all PixiJS containers attached to any slot. */ removeSlotObjects() { for (const [, slotObject] of this.slotsObject) { slotObject.container.removeFromParent(); } this.slotsObject.clear(); } verticesCache = Utils.newFloatArray(1024); clippingSlotToPixiMasks = {}; pixiMaskCleanup(slot) { const mask = this.clippingSlotToPixiMasks[slot.data.name]; if (mask) { delete this.clippingSlotToPixiMasks[slot.data.name]; mask.destroy(); } } updateSlotObject(element, slot, zIndex) { const { container: slotObject, followAttachmentTimeline } = element; const pose = slot.appliedPose; const followAttachmentValue = followAttachmentTimeline ? Boolean(pose.attachment) : true; const drawOrder = this.skeleton.drawOrder.appliedPose; slotObject.visible = drawOrder.includes(slot) && followAttachmentValue; if (slotObject.visible) { const applied = slot.bone.appliedPose; const matrix = slotObject.localTransform; matrix.a = applied.a; matrix.b = applied.c; matrix.c = -applied.b; matrix.d = -applied.d; matrix.tx = applied.worldX; matrix.ty = applied.worldY; slotObject.transform.setFromMatrix(matrix); slotObject.zIndex = zIndex + 1; slotObject.alpha = this.skeleton.color.a * pose.color.a; if (element.followSlotColor) { this.setSlotObjectTint( slotObject, 255 * this.skeleton.color.r * pose.color.r << 16 | 255 * this.skeleton.color.g * pose.color.g << 8 | 255 * this.skeleton.color.b * pose.color.b ); } } } setSlotObjectTint(slotObject, tint) { const tintable = slotObject; if ("tint" in tintable) tintable.tint = tint; for (const child of tintable.children ?? []) { this.setSlotObjectTint(child, tint); } } updateAndSetPixiMask(pixiMaskSource, pixiObject) { if (_Spine.clipper.isClipping() && pixiMaskSource) { let mask = this.clippingSlotToPixiMasks[pixiMaskSource.slot.data.name]; if (!mask) { mask = new Graphics(); this.clippingSlotToPixiMasks[pixiMaskSource.slot.data.name] = mask; this.addChild(mask); } if (!pixiMaskSource.computed) { pixiMaskSource.computed = true; const clippingAttachment = pixiMaskSource.slot.appliedPose.attachment; const worldVerticesLength = clippingAttachment.worldVerticesLength; if (this.clippingVertAux.length < worldVerticesLength) this.clippingVertAux = new Float32Array(worldVerticesLength); clippingAttachment.computeWorldVertices(this.skeleton, pixiMaskSource.slot, 0, worldVerticesLength, this.clippingVertAux, 0, 2); mask.clear().lineStyle(0).beginFill(0); mask.moveTo(this.clippingVertAux[0], this.clippingVertAux[1]); for (let i = 2; i < worldVerticesLength; i += 2) { mask.lineTo(this.clippingVertAux[i], this.clippingVertAux[i + 1]); } mask.finishPoly(); } pixiObject.mask = mask; } else if (pixiObject.mask) { pixiObject.mask = null; } } /* * Colors in pixi are premultiplied. * Pixi blending modes are modified to work with premultiplied colors. We cannot create custom blending modes. * Textures are loaded as premultiplied (see assers/atlasLoader.ts: alphaMode: `page.pma ? ALPHA_MODES.PMA : ALPHA_MODES.UNPACK`): * - textures non premultiplied are premultiplied on GPU on upload * - textures premultiplied are uploaded on GPU as is since they are already premultiplied * * We need to take this into consideration and calculates final colors for both light and dark color as if textures were always premultiplied. * This implies for example that alpha for dark tint is always 1. This is way in DarkTintRenderer we have only the alpha of the light color. * If we ever want to load texture as non premultiplied on GPU, we must add a new dark alpha parameter to the TintMaterial and set the alpha. */ renderMeshes() { this.resetMeshes(); let triangles = null; let uvs = null; let pixiMaskSource = null; const drawOrder = this.skeleton.drawOrder.appliedPose; const slots = drawOrder; for (let i = 0, n = drawOrder.length, slotObjectsCounter = 0; i < n; i++) { const slot = slots[i]; const pixiObject = this.slotsObject.get(slot); const zIndex = i + slotObjectsCounter; if (pixiObject) { this.updateSlotObject(pixiObject, slot, zIndex + 1); slotObjectsCounter++; this.updateAndSetPixiMask(pixiMaskSource, pixiObject.container); } const pose = slot.appliedPose; const useDarkColor = !!pose.darkColor; const vertexSize = useDarkColor ? _Spine.DARK_VERTEX_SIZE : _Spine.VERTEX_SIZE; if (!slot.bone.active) { _Spine.clipper.clipEnd(slot); this.pixiMaskCleanup(slot); continue; } const attachment = pose.attachment; let attachmentColor; let texture; let numFloats = 0; const skeleton = this.skeleton; if (attachment instanceof RegionAttachment) { const region = attachment; attachmentColor = region.color; numFloats = vertexSize * 4; const sequence = attachment.sequence; const sequenceIndex = sequence.resolveIndex(pose); attachment.computeWorldVertices(slot, attachment.getOffsets(pose), this.verticesCache, 0, vertexSize); triangles = _Spine.QUAD_TRIANGLES; uvs = sequence.getUVs(sequenceIndex); texture = sequence.regions[sequenceIndex]?.texture; } else if (attachment instanceof MeshAttachment) { const mesh = attachment; attachmentColor = mesh.color; numFloats = (mesh.worldVerticesLength >> 1) * vertexSize; if (numFloats > this.verticesCache.length) { this.verticesCache = Utils.newFloatArray(numFloats); } mesh.computeWorldVertices(skeleton, slot, 0, mesh.worldVerticesLength, this.verticesCache, 0, vertexSize); triangles = mesh.triangles; const sequence = attachment.sequence; const sequenceIndex = sequence.resolveIndex(pose); uvs = sequence.getUVs(sequenceIndex); texture = sequence.regions[sequenceIndex]?.texture; } else if (attachment instanceof ClippingAttachment) { _Spine.clipper.clipStart(skeleton, slot, attachment); pixiMaskSource = { slot, computed: false }; continue; } else { if (this.hasMeshForSlot(slot)) { this.getMeshForSlot(slot).visible = false; } _Spine.clipper.clipEnd(slot); this.pixiMaskCleanup(slot); continue; } if (texture != null) { const skeletonColor = skeleton.color; const slotColor = pose.color; const alpha = skeletonColor.a * slotColor.a * attachmentColor.a; this.lightColor.set( skeletonColor.r * slotColor.r * attachmentColor.r, skeletonColor.g * slotColor.g * attachmentColor.g, skeletonColor.b * slotColor.b * attachmentColor.b, alpha ); if (pose.darkColor != null) { this.darkColor.set( pose.darkColor.r, pose.darkColor.g, pose.darkColor.b, 1 ); } else { this.darkColor.set(0, 0, 0, 1); } let finalVertices; let finalVerticesLength; let finalIndices; let finalIndicesLength; if (_Spine.clipper.isClipping() && _Spine.clipper.clipTriangles(this.verticesCache, triangles, triangles.length, uvs, this.lightColor, this.darkColor, useDarkColor, vertexSize)) { finalVertices = _Spine.clipper.clippedVertices; finalVerticesLength = finalVertices.length; finalIndices = _Spine.clipper.clippedTriangles; finalIndicesLength = finalIndices.length; } else { const verts = this.verticesCache; for (let v = 2, u = 0, n2 = numFloats; v < n2; v += vertexSize, u += 2) { let tempV = v; verts[tempV++] = this.lightColor.r; verts[tempV++] = this.lightColor.g; verts[tempV++] = this.lightColor.b; verts[tempV++] = this.lightColor.a; verts[tempV++] = uvs[u]; verts[tempV++] = uvs[u + 1]; if (useDarkColor) { verts[tempV++] = this.darkColor.r; verts[tempV++] = this.darkColor.g; verts[tempV++] = this.darkColor.b; verts[tempV++] = this.darkColor.a; } } finalVertices = this.verticesCache; finalVerticesLength = numFloats; finalIndices = triangles; finalIndicesLength = triangles.length; } if (finalVerticesLength === 0 || finalIndicesLength === 0) { _Spine.clipper.clipEnd(slot); continue; } const mesh = this.getMeshForSlot(slot); mesh.renderable = true; mesh.zIndex = zIndex; mesh.updateFromSpineData(texture, slot.data.blendMode, slot.data.name, finalVertices, finalVerticesLength, finalIndices, finalIndicesLength, useDarkColor); } _Spine.clipper.clipEnd(slot); this.pixiMaskCleanup(slot); } _Spine.clipper.clipEnd(); } calculateBounds() { if (!this._boundsProvider) { super.calculateBounds(); return; } const transform = this.transform; if (this._boundsSpineID === transform._worldID) return; this.updateBounds(); const bounds = this._localBounds; const p = this._boundsPoint; p.set(bounds.minX, bounds.minY); transform.worldTransform.apply(p, p); this._bounds.minX = p.x; this._bounds.minY = p.y; p.set(bounds.maxX, bounds.maxY); transform.worldTransform.apply(p, p); this._bounds.maxX = p.x; this._bounds.maxY = p.y; } updateBounds() { if (!this._boundsProvider || !this._boundsSpineDirty) return; this._boundsSpineDirty = false; if (!this._localBounds) { this._localBounds = new Bounds(); } const boundsSpine = this._boundsProvider.calculateBounds(this); const bounds = this._localBounds; bounds.clear(); bounds.minX = boundsSpine.x; bounds.minY = boundsSpine.y; bounds.maxX = boundsSpine.x + boundsSpine.width; bounds.maxY = boundsSpine.y + boundsSpine.height; this.hitArea = this._localBounds.getRectangle(); } /** * Set the position of the bone given in input through a {@link IPointData}. * @param bone: the bone name or the bone instance to set the position * @param outPos: the new position of the bone. * @throws {Error}: if the given bone is not found in the skeleton, an error is thrown */ setBonePosition(bone, position) { const actualBone = typeof bone === "string" ? this.skeleton.findBone(bone) : bone; if (!actualBone) throw Error(`Cannot set bone position, bone ${String(bone)} not found`); _Spine.vectorAux.set(position.x, position.y); const applied = actualBone.appliedPose; if (actualBone.parent) { const aux = actualBone.parent.appliedPose.worldToLocal(_Spine.vectorAux); applied.x = aux.x; applied.y = aux.y; } else { applied.x = _Spine.vectorAux.x; applied.y = _Spine.vectorAux.y; } } /** * Return the position of the bone given in input into an {@link IPointData}. * @param bone: the bone name or the bone instance to get the position from * @param outPos: an optional {@link IPointData} to use to return the bone position, rathern than instantiating a new object. * @returns {IPointData | undefined}: the position of the bone, or undefined if no matching bone is found in the skeleton */ getBonePosition(bone, outPos) { const actualBone = typeof bone === "string" ? this.skeleton.findBone(bone) : bone; if (!actualBone) { console.error(`Cannot get bone position! Bone ${String(bone)} not found`); return outPos; } if (!outPos) { outPos = { x: 0, y: 0 }; } outPos.x = actualBone.appliedPose.worldX; outPos.y = actualBone.appliedPose.worldY; return outPos; } /** Converts a point from the skeleton coordinate system to the Pixi world coordinate system. */ skeletonToPixiWorldCoordinates(point) { this.worldTransform.apply(point, point); } /** Converts a point from the Pixi world coordinate system to the skeleton coordinate system. */ pixiWorldCoordinatesToSkeleton(point) { this.worldTransform.applyInverse(point, point); } /** Converts a point from the Pixi world coordinate system to the bone's local coordinate system. */ pixiWorldCoordinatesToBone(point, bone) { this.pixiWorldCoordinatesToSkeleton(point); if (bone.parent) { bone.parent.appliedPose.worldToLocal(point); } else { bone.appliedPose.worldToLocal(point); } } /** A cache containing skeleton data and atlases already loaded by {@link Spine.from}. */ static skeletonCache = /* @__PURE__ */ Object.create(null); static skeletonDataCacheKeys = /* @__PURE__ */ new WeakMap(); static getSkeletonCacheKey({ skeleton, atlas, scale = 1 }) { return `${skeleton}-${atlas}-${scale}`; } /** * Get a convenient initialization configuration for your Spine game object. * Before instantiating a Spine game object, the skeleton (`.skel` or `.json`) and the atlas text files must be loaded into the Assets. For example: * ``` * PIXI.Assets.add("sackData", "/assets/sack-pro.skel"); * PIXI.Assets.add("sackAtlas", "/assets/sack-pma.atlas"); * await PIXI.Assets.load(["sackData", "sackAtlas"]); * ``` * Once a Spine game object is created, its skeleton data is cached into {@link Spine.skeletonCache} using the key: * `${skeletonAssetName}-${atlasAssetName}-${options?.scale ?? 1}` * * @param options - Options to configure the Spine game object. See {@link SpineFromOptions} * @returns {SpineOptions} The configuration ready to be passed to the Spine constructor */ static createOptions({ skeleton, atlas, scale = 1, darkTint, autoUpdate = true, boundsProvider, allowMissingRegions, ticker }) { const cacheKey = _Spine.getSkeletonCacheKey({ skeleton, atlas, scale }); let skeletonData = _Spine.skeletonCache[cacheKey]; if (!skeletonData) { const skeletonAsset = Assets2.get(skeleton); const atlasAsset = Assets2.get(atlas); const attachmentLoader = new AtlasAttachmentLoader(atlasAsset, allowMissingRegions); const parser = skeletonAsset instanceof Uint8Array ? new SkeletonBinary(attachmentLoader) : new SkeletonJson(attachmentLoader); parser.scale = scale; skeletonData = parser.readSkeletonData(skeletonAsset); _Spine.skeletonCache[cacheKey] = skeletonData; } _Spine.skeletonDataCacheKeys.set(skeletonData, cacheKey); return { skeletonData, darkTint, autoUpdate, boundsProvider, ticker }; } /** * @deprecated Use directly the Spine constructor or {@link createOptions} to make options and customize it to pass to the constructor * Before instantiating a Spine game object, the skeleton (`.skel` or `.json`) and the atlas text files must be loaded into the Assets. For example: * ``` * PIXI.Assets.add("sackData", "/assets/sack-pro.skel"); * PIXI.Assets.add("sackAtlas", "/assets/sack-pma.atlas"); * await PIXI.Assets.load(["sackData", "sackAtlas"]); * ``` * Once a Spine game object is created, its skeleton data is cached into {@link Spine.skeletonCache} using the key: * `${skeletonAssetName}-${atlasAssetName}-${options?.scale ?? 1}` * * @param options - Options to configure the Spine game object. See {@link SpineFromOptions} * @returns {Spine} The Spine game object instantiated */ static from(options) { return new _Spine(_Spine.createOptions(options)); } get tint() { return this.skeleton.color.toRgb888(); } set tint(value) { Color.rgb888ToColor(this.skeleton.color, value); } }; Skeleton.yDown = true; // spine-pixi-v7/src/SpineDebugRenderer.ts import { Container as Container2 } from "@pixi/display"; import { Graphics as Graphics2 } from "@pixi/graphics"; import { Text } from "@pixi/text"; var SpineDebugRenderer = class { registeredSpines = /* @__PURE__ */ new Map(); drawMeshHull = true; drawMeshTriangles = true; drawBones = true; drawPaths = true; drawBoundingBoxes = true; drawClipping = true; drawRegionAttachments = true; drawEvents = true; lineWidth = 1; regionAttachmentsColor = 30975; meshHullColor = 30975; meshTrianglesColor = 16763904; clippingPolygonColor = 16711935; boundingBoxesRectColor = 65280; boundingBoxesPolygonColor = 65280; boundingBoxesCircleColor = 65280; pathsCurveColor = 16711680; pathsLineColor = 16711935; skeletonXYColor = 16711680; bonesColor = 61132; eventFontSize = 24; eventFontColor = 0; /** * The debug is attached by force to each spine object. So we need to create it inside the spine when we get the first update */ registerSpine(spine) { if (this.registeredSpines.has(spine)) { console.warn("SpineDebugRenderer.registerSpine() - this spine is already registered!", spine); return; } const debugDisplayObjects = { parentDebugContainer: new Container2(), bones: new Container2(), skeletonXY: new Graphics2(), regionAttachmentsShape: new Graphics2(), meshTrianglesLine: new Graphics2(), meshHullLine: new Graphics2(), clippingPolygon: new Graphics2(), boundingBoxesRect: new Graphics2(), boundingBoxesCircle: new Graphics2(), boundingBoxesPolygon: new Graphics2(), pathsCurve: new Graphics2(), pathsLine: new Graphics2(), eventText: new Container2(), eventCallback: { event: (_, event) => { if (this.drawEvents) { const scale = Math.abs(spine.scale.x || spine.scale.y || 1); const text = new Text(event.data.name, { fontSize: this.eventFontSize / scale, fill: this.eventFontColor, fontFamily: "monospace" }); text.scale.x = Math.sign(spine.scale.x); text.anchor.set(0.5); debugDisplayObjects.eventText.addChild(text); setTimeout(() => { if (!text.destroyed) { text.destroy(); } }, 250); } } } }; debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.bones); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.skeletonXY); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.regionAttachmentsShape); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.meshTrianglesLine); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.meshHullLine); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.clippingPolygon); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.boundingBoxesRect); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.boundingBoxesCircle); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.boundingBoxesPolygon); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.pathsCurve); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.pathsLine); debugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.eventText); debugDisplayObjects.parentDebugContainer.zIndex = 9999999; debugDisplayObjects.parentDebugContainer.accessibleChildren = false; debugDisplayObjects.parentDebugContainer.eventMode = "none"; debugDisplayObjects.parentDebugContainer.interactiveChildren = false; spine.addChild(debugDisplayObjects.parentDebugContainer); spine.state.addListener(debugDisplayObjects.eventCallback); this.registeredSpines.set(spine, debugDisplayObjects); } renderDebug(spine) { if (!this.registeredSpines.has(spine)) { this.registerSpine(spine); } const debugDisplayObjects = this.registeredSpines.get(spine); if (!debugDisplayObjects) { return; } spine.addChild(debugDisplayObjects.parentDebugContainer); debugDisplayObjects.skeletonXY.clear(); debugDisplayObjects.regionAttachmentsShape.clear(); debugDisplayObjects.meshTrianglesLine.clear(); debugDisplayObjects.meshHullLine.clear(); debugDisplayObjects.clippingPolygon.clear(); debugDisplayObjects.boundingBoxesRect.clear(); debugDisplayObjects.boundingBoxesCircle.clear(); debugDisplayObjects.boundingBoxesPolygon.clear(); debugDisplayObjects.pathsCurve.clear(); debugDisplayObjects.pathsLine.clear(); for (let len = debugDisplayObjects.bones.children.length; len > 0; len--) { debugDisplayObjects.bones.children[len - 1].destroy({ children: true, texture: true, baseTexture: true }); } const scale = Math.abs(spine.scale.x || spine.scale.y || 1); const lineWidth = this.lineWidth / scale; if (this.drawBones) { this.drawBonesFunc(spine, debugDisplayObjects, lineWidth, scale); } if (this.drawPaths) { this.drawPathsFunc(spine, debugDisplayObjects, lineWidth); } if (this.drawBoundingBoxes) { this.drawBoundingBoxesFunc(spine, debugDisplayObjects, lineWidth); } if (this.drawClipping) { this.drawClippingFunc(spine, debugDisplayObjects, lineWidth); } if (this.drawMeshHull || this.drawMeshTriangles) { this.drawMeshHullAndMeshTriangles(spine, debugDisplayObjects, lineWidth); } if (this.drawRegionAttachments) { this.drawRegionAttachmentsFunc(spine, debugDisplayObjects, lineWidth); } if (this.drawEvents) { for (const child of debugDisplayObjects.eventText.children) { child.alpha -= 0.05; child.y -= 2; } } } drawBonesFunc(spine, debugDisplayObjects, lineWidth, scale) { const skeleton = spine.skeleton; const skeletonX = skeleton.x; const skeletonY = skeleton.y; const bones = skeleton.bones; debugDisplayObjects.skeletonXY.lineStyle(lineWidth, this.skeletonXYColor, 1); for (let i = 0, len = bones.length; i < len; i++) { const bone = bones[i]; const boneLen = bone.data.length; const applied = bone.appliedPose; const starX = skeletonX + applied.worldX; const starY = skeletonY + applied.worldY; const endX = skeletonX + boneLen * applied.a + applied.worldX; const endY = skeletonY + boneLen * applied.b + applied.worldY; if (bone.data.name === "root" || bone.data.parent === null) { continue; } const w = Math.abs(starX - endX); const h = Math.abs(starY - endY); const a2 = Math.pow(w, 2); const b = h; const b2 = Math.pow(h, 2); const c = Math.sqrt(a2 + b2); const c2 = Math.pow(c, 2); const rad = Math.PI / 180; const B = Math.acos((c2 + b2 - a2) / (2 * b * c)) || 0; if (c === 0) { continue; } const gp = new Graphics2(); debugDisplayObjects.bones.addChild(gp); const refRation = c / 50 / scale; gp.beginFill(this.bonesColor, 1); gp.drawPolygon(0, 0, 0 - refRation, c - refRation * 3, 0, c - refRation, 0 + refRation, c - refRation * 3); gp.endFill(); gp.x = starX; gp.y = starY; gp.pivot.y = c; let rotation = 0; if (starX < endX && starY < endY) { rotation = -B + 180 * rad; } else if (starX > endX && starY < endY) { rotation = 180 * rad + B; } else if (starX > endX && starY > endY) { rotation = -B; } else if (starX < endX && starY > endY) { rotation = B; } else if (starY === endY && starX < endX) { rotation = 90 * rad; } else if (starY === endY && starX > endX) { rotation = -90 * rad; } else if (starX === endX && starY < endY) { rotation = 180 * rad; } else if (starX === endX && starY > endY) { rotation = 0; } gp.rotation = rotation; gp.lineStyle(lineWidth + refRation / 2.4, this.bonesColor, 1); gp.beginFill(0, 0.6); gp.drawCircle(0, c, refRation * 1.2); gp.endFill(); } const startDotSize = lineWidth * 3; debugDisplayObjects.skeletonXY.moveTo(skeletonX - startDotSize, skeletonY - startDotSize); debugDisplayObjects.skeletonXY.lineTo(skeletonX + startDotSize, skeletonY + startDotSize); debugDisplayObjects.skeletonXY.moveTo(skeletonX + startDotSize, skeletonY - startDotSize); debugDisplayObjects.skeletonXY.lineTo(skeletonX - startDotSize, skeletonY + startDotSize); } drawRegionAttachmentsFunc(spine, debugDisplayObjects, lineWidth) { const skeleton = spine.skeleton; const slots = skeleton.slots; debugDisplayObjects.regionAttachmentsShape.lineStyle(lineWidth, this.regionAttachmentsColor, 1); for (let i = 0, len = slots.length; i < len; i++) { const slot = slots[i]; const attachment = slot.appliedPose.attachment; if (attachment == null || !(attachment instanceof RegionAttachment)) { continue; } const vertices = new Float32Array(8); attachment.computeWorldVertices(slot, attachment.getOffsets(slot.appliedPose), vertices, 0, 2); debugDisplayObjects.regionAttachmentsShape.drawPolygon(Array.from(vertices.slice(0, 8))); } } drawMeshHullAndMeshTriangles(spine, debugDisplayObjects, lineWidth) { const skeleton = spine.skeleton; const slots = skeleton.slots; debugDisplayObjects.meshHullLine.lineStyle(lineWidth, this.meshHullColor, 1); debugDisplayObjects.meshTrianglesLine.lineStyle(lineWidth, this.meshTrianglesColor, 1); for (let i = 0, len = slots.length; i < len; i++) { const slot = slots[i]; if (!slot.bone.active) { continue; } const attachment = slot.appliedPose.attachment; if (attachment == null || !(attachment instanceof MeshAttachment)) { continue; } const meshAttachment = attachment; const vertices = new Float32Array(meshAttachment.worldVerticesLength); const triangles = meshAttachment.triangles; let hullLength = meshAttachment.hullLength; meshAttachment.computeWorldVertices(skeleton, slot, 0, meshAttachment.worldVerticesLength, vertices, 0, 2); if (this.drawMeshTriangles) { for (let i2 = 0, len2 = triangles.length; i2 < len2; i2 += 3) { const v1 = triangles[i2] * 2; const v2 = triangles[i2 + 1] * 2; const v3 = triangles[i2 + 2] * 2; debugDisplayObjects.meshTrianglesLine.moveTo(vertices[v1], vertices[v1 + 1]); debugDisplayObjects.meshTrianglesLine.lineTo(vertices[v2], vertices[v2 + 1]); debugDisplayObjects.meshTrianglesLine.lineTo(vertices[v3], vertices[v3 + 1]); } } if (this.drawMeshHull && hullLength > 0) { hullLength = (hullLength >> 1) * 2; let lastX = vertices[hullLength - 2]; let lastY = vertices[hullLength - 1]; for (let i2 = 0, len2 = hullLength; i2 < len2; i2 += 2) { const x = vertices[i2]; const y = vertices[i2 + 1]; debugDisplayObjects.meshHullLine.moveTo(x, y); debugDisplayObjects.meshHullLine.lineTo(lastX, lastY); lastX = x; lastY = y; } } } } drawClippingFunc(spine, debugDisplayObjects, lineWidth) { const skeleton = spine.skeleton; const slots = skeleton.slots; debugDisplayObjects.clippingPolygon.lineStyle(lineWidth, this.clippingPolygonColor, 1); for (let i = 0, len = slots.length; i < len; i++) { const slot = slots[i]; if (!slot.bone.active) { continue; } const attachment = slot.appliedPose.attachment; if (attachment == null || !(attachment instanceof ClippingAttachment)) { continue; } const clippingAttachment = attachment; const nn = clippingAttachment.worldVerticesLength; const world = new Float32Array(nn); clippingAttachment.computeWorldVertices(skeleton, slot, 0, nn, world, 0, 2); debugDisplayObjects.clippingPolygon.drawPolygon(Array.from(world)); } } drawBoundingBoxesFunc(spine, debugDisplayObjects, lineWidth) { debugDisplayObjects.boundingBoxesRect.lineStyle(lineWidth, this.boundingBoxesRectColor, 5); const bounds = new SkeletonBounds(); bounds.update(spine.skeleton, true); if (bounds.minX !== Infinity) { debugDisplayObjects.boundingBoxesRect.drawRect(bounds.minX, bounds.minY, bounds.getWidth(), bounds.getHeight()); } const polygons = bounds.polygons; const drawPolygon = (polygonVertices, _offset, count) => { debugDisplayObjects.boundingBoxesPolygon.lineStyle(lineWidth, this.boundingBoxesPolygonColor, 1); debugDisplayObjects.boundingBoxesPolygon.beginFill(this.boundingBoxesPolygonColor, 0.1); if (count < 3) { throw new Error("Polygon must contain at least 3 vertices"); } const paths = []; const dotSize = lineWidth * 2; for (let i = 0, len = polygonVertices.length; i < len; i += 2) { const x1 = polygonVertices[i]; const y1 = polygonVertices[i + 1]; debugDisplayObjects.boundingBoxesCircle.lineStyle(0); debugDisplayObjects.boundingBoxesCircle.beginFill(this.boundingBoxesCircleColor); debugDisplayObjects.boundingBoxesCircle.drawCircle(x1, y1, dotSize); debugDisplayObjects.boundingBoxesCircle.endFill(); paths.push(x1, y1); } debugDisplayObjects.boundingBoxesPolygon.drawPolygon(paths); debugDisplayObjects.boundingBoxesPolygon.endFill(); }; for (let i = 0, len = polygons.length; i < len; i++) { const polygon = polygons[i]; drawPolygon(polygon, 0, polygon.length); } } drawPathsFunc(spine, debugDisplayObjects, lineWidth) { const skeleton = spine.skeleton; const slots = skeleton.slots; debugDisplayObjects.pathsCurve.lineStyle(lineWidth, this.pathsCurveColor, 1); debugDisplayObjects.pathsLine.lineStyle(lineWidth, this.pathsLineColor, 1); for (let i = 0, len = slots.length; i < len; i++) { const slot = slots[i]; if (!slot.bone.active) { continue; } const attachment = slot.appliedPose.attachment; if (attachment == null || !(attachment instanceof PathAttachment)) { continue; } const pathAttachment = attachment; let nn = pathAttachment.worldVerticesLength; const world = new Float32Array(nn); pathAttachment.computeWorldVertices(skeleton, slot, 0, nn, world, 0, 2); let x1 = world[2]; let y1 = world[3]; let x2 = 0; let y2 = 0; if (pathAttachment.closed) { const cx1 = world[0]; const cy1 = world[1]; const cx2 = world[nn - 2]; const cy2 = world[nn - 1]; x2 = world[nn - 4]; y2 = world[nn - 3]; debugDisplayObjects.pathsCurve.moveTo(x1, y1); debugDisplayObjects.pathsCurve.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2); debugDisplayObjects.pathsLine.moveTo(x1, y1); debugDisplayObjects.pathsLine.lineTo(cx1, cy1); debugDisplayObjects.pathsLine.moveTo(x2, y2); debugDisplayObjects.pathsLine.lineTo(cx2, cy2); } nn -= 4; for (let ii = 4; ii < nn; ii += 6) { const cx1 = world[ii]; const cy1 = world[ii + 1]; const cx2 = world[ii + 2]; const cy2 = world[ii + 3]; x2 = world[ii + 4]; y2 = world[ii + 5]; debugDisplayObjects.pathsCurve.moveTo(x1, y1); debugDisplayObjects.pathsCurve.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2); debugDisplayObjects.pathsLine.moveTo(x1, y1); debugDisplayObjects.pathsLine.lineTo(cx1, cy1); debugDisplayObjects.pathsLine.moveTo(x2, y2); debugDisplayObjects.pathsLine.lineTo(cx2, cy2); x1 = x2; y1 = y2; } } } unregisterSpine(spine) { if (!this.registeredSpines.has(spine)) { console.warn("SpineDebugRenderer.unregisterSpine() - spine is not registered, can't unregister!", spine); } const debugDisplayObjects = this.registeredSpines.get(spine); if (!debugDisplayObjects) { return; } spine.state.removeListener(debugDisplayObjects.eventCallback); debugDisplayObjects.parentDebugContainer.destroy({ baseTexture: true, children: true, texture: true }); this.registeredSpines.delete(spine); } }; export { AABBRectangleBoundsProvider, ATTACH_RETAIN, ATTACH_SETUP, AlphaTimeline, Animation, AnimationState, AnimationStateAdapter, AnimationStateData, AssetCache, AssetManagerBase, AtlasAttachmentLoader, Attachment, AttachmentTimeline, BinaryInput, BlendMode, Bone, BoneData, BonePose, BoneTimeline1, BoneTimeline2, BoundingBoxAttachment, CURRENT, ClippingAttachment, Color, Constraint, ConstraintData, ConstraintTimeline1, CurveTimeline, CurveTimeline1, DarkSlotMesh, DarkTintBatchGeometry, DarkTintGeometry, DarkTintMaterial, DarkTintMesh, DarkTintRenderer, DebugUtils, DeformTimeline, Downloader, DrawOrder, DrawOrderFolderTimeline, DrawOrderTimeline, Event, EventData, EventQueue, EventTimeline, EventType, FIRST, FakeTexture, FromProperty, FromRotate, FromScaleX, FromScaleY, FromShearY, FromX, FromY, HOLD, IkConstraint, IkConstraintData, IkConstraintPose, IkConstraintTimeline, Inherit, InheritTimeline, IntSet, Interpolation, MODE, MathUtils, MeshAttachment, MixFrom, PathAttachment, PathConstraint, PathConstraintData, PathConstraintMixTimeline, PathConstraintPose, PathConstraintPositionTimeline, PathConstraintSpacingTimeline, Physics, PhysicsConstraint, PhysicsConstraintDampingTimeline, PhysicsConstraintData, PhysicsConstraintGravityTimeline, PhysicsConstraintInertiaTimeline, PhysicsConstraintMassTimeline, PhysicsConstraintMixTimeline, PhysicsConstraintPose, PhysicsConstraintResetTimeline, PhysicsConstraintStrengthTimeline, PhysicsConstraintTimeline, PhysicsConstraintWindTimeline, PointAttachment, Pool, Posed, PosedActive, PosedData, PositionMode, Pow, PowOut, Property, RGB2Timeline, RGBA2Timeline, RGBATimeline, RGBTimeline, RegionAttachment, RotateMode, RotateTimeline, SETUP, ScaleTimeline, ScaleXTimeline, ScaleYMode, ScaleYTimeline, Sequence, SequenceMode, SequenceModeValues, SequenceTimeline, SetupPoseBoundsProvider, ShearTimeline, ShearXTimeline, ShearYTimeline, Skeleton, SkeletonBinary, SkeletonBounds, SkeletonClipping, SkeletonData, SkeletonJson, SkeletonPhysicsMovement, SkeletonRendererCore, Skin, SkinEntry, SkinsAndAnimationBoundsProvider, Slider, SliderData, SliderMixTimeline, SliderPose, SliderTimeline, Slot, SlotCurveTimeline, SlotData, SlotMesh, SlotPose, SpacingMode, Spine, SpineDebugRenderer, SpineTexture, StringSet, Texture, TextureAtlas, TextureAtlasPage, TextureAtlasRegion, TextureFilter, TextureRegion, TextureWrap, TimeKeeper, Timeline, ToProperty, ToRotate, ToScaleX, ToScaleY, ToShearY, ToX, ToY, TrackEntry, TransformConstraint, TransformConstraintData, TransformConstraintPose, TransformConstraintTimeline, TranslateTimeline, TranslateXTimeline, TranslateYTimeline, Triangulator, Utils, Vector2, VertexAttachment, WindowedMean, isBoneTimeline, isConstraintTimeline, isSlotTimeline }; //# sourceMappingURL=spine-pixi-v7.mjs.map