@esotericsoftware/spine-core 4.2.117 → 4.3.1

package/dist/SkeletonRendererCore.d.ts

@@ -0,0 +1,58 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated April 5, 2025. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2025, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import type { Skeleton } from "./Skeleton.js";
+import { BlendMode } from "./SlotData.js";
+export declare class SkeletonRendererCore {
+    private commandPool;
+    private worldVertices;
+    private quadIndices;
+    private clipping;
+    private renderCommands;
+    render(skeleton: Skeleton, pma?: boolean, inColor?: [number, number, number, number], stride?: number): RenderCommand | undefined;
+    private batchSubCommands;
+    private batchCommands;
+}
+interface RenderCommand {
+    positions: Float32Array;
+    uvs: Float32Array;
+    colors: Uint32Array;
+    darkColors: Uint32Array;
+    indices: Uint16Array;
+    _positions: Float32Array;
+    _uvs: Float32Array;
+    _colors: Uint32Array;
+    _darkColors: Uint32Array;
+    _indices: Uint16Array;
+    numVertices: number;
+    numIndices: number;
+    blendMode: BlendMode;
+    texture: any;
+    next?: RenderCommand;
+}
+export {};

package/dist/SkeletonRendererCore.js

@@ -0,0 +1,310 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated April 5, 2025. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2025, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { ClippingAttachment, MeshAttachment, RegionAttachment } from "./attachments/index.js";
+import { SkeletonClipping } from "./SkeletonClipping.js";
+import { BlendMode } from "./SlotData.js";
+export class SkeletonRendererCore {
+    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) {
+        this.commandPool.reset();
+        this.renderCommands.length = 0;
+        const clipper = this.clipping;
+        const drawOrder = skeleton.drawOrder.appliedPose;
+        for (let i = 0; i < skeleton.slots.length; i++) {
+            const slot = drawOrder[i];
+            const attachment = slot.appliedPose.attachment;
+            if (!attachment) {
+                clipper.clipEnd(slot);
+                continue;
+            }
+            const pose = slot.appliedPose;
+            const slotColor = pose.color;
+            const alpha = slotColor.a;
+            if ((alpha === 0 || !slot.bone.active) && !(attachment instanceof ClippingAttachment)) {
+                clipper.clipEnd(slot);
+                continue;
+            }
+            let vertices;
+            let verticesCount;
+            let uvs;
+            let indices;
+            let indicesCount;
+            let attachmentColor;
+            // biome-ignore lint/suspicious/noExplicitAny: texture depends on the runtime
+            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.clipStart(skeleton, slot, attachment);
+                continue;
+            }
+            else {
+                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 = 0xff000000;
+                if (pose.darkColor) {
+                    const { r, g, b } = pose.darkColor;
+                    darkColor = 0xff000000 |
+                        (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));
+            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);
+            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;
+            // cannot fast copy - indices need vertex offset adjustment
+            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 undefined;
+        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 < 0xffff;
+            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;
+    }
+}
+class CommandPool {
+    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: BlendMode.Normal,
+                texture: null
+            };
+        }
+        else {
+            this.pool.splice(this.pool.indexOf(cmd), 1);
+            cmd.next = undefined;
+            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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SkeletonRendererCore.js","sourceRoot":"","sources":["../src/SkeletonRendererCore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE9F,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C,MAAM,OAAO,oBAAoB;IACxB,WAAW,GAAG,IAAI,WAAW,EAAE,CAAC;IAChC,aAAa,GAAG,IAAI,YAAY,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;IAC5C,WAAW,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAClD,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;IAClC,cAAc,GAAoB,EAAE,CAAC;IAE7C,MAAM,CAAE,QAAkB,EAAE,GAAG,GAAG,KAAK,EAAE,OAA0C,EAAE,MAAM,GAAG,CAAC;QAC9F,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC;QAE/B,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAE9B,MAAM,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC;QACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAChD,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;YAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC;YAE/C,IAAI,CAAC,UAAU,EAAE,CAAC;gBACjB,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBACtB,SAAS;YACV,CAAC;YAED,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;YAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC;YAC7B,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC;YAC1B,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,UAAU,YAAY,kBAAkB,CAAC,EAAE,CAAC;gBACvF,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBACtB,SAAS;YACV,CAAC;YAED,IAAI,QAAyB,CAAC;YAC9B,IAAI,aAAqB,CAAC;YAC1B,IAAI,GAAoB,CAAC;YACzB,IAAI,OAA+B,CAAC;YACpC,IAAI,YAAoB,CAAC;YACzB,IAAI,eAAsB,CAAC;YAC3B,6EAA6E;YAC7E,IAAI,OAAY,CAAC;YAEjB,IAAI,UAAU,YAAY,gBAAgB,EAAE,CAAC;gBAC5C,eAAe,GAAG,UAAU,CAAC,KAAK,CAAC;gBAEnC,IAAI,eAAe,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC7B,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBACtB,SAAS;gBACV,CAAC;gBAED,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;gBACrC,MAAM,aAAa,GAAG,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAClD,UAAU,CAAC,oBAAoB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;gBAElG,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC;gBAC9B,aAAa,GAAG,CAAC,CAAC;gBAClB,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;gBACrC,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC;gBAC3B,YAAY,GAAG,CAAC,CAAC;gBACjB,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;YAEpD,CAAC;iBAAM,IAAI,UAAU,YAAY,cAAc,EAAE,CAAC;gBACjD,eAAe,GAAG,UAAU,CAAC,KAAK,CAAC;gBAEnC,IAAI,eAAe,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC7B,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBACtB,SAAS;gBACV,CAAC;gBAED,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,UAAU,CAAC,mBAAmB;oBAC7D,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC;gBAEvE,UAAU,CAAC,oBAAoB,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,CAAC,mBAAmB,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;gBAClH,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC;gBAC9B,aAAa,GAAG,UAAU,CAAC,mBAAmB,IAAI,CAAC,CAAC;gBAEpD,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;gBACrC,MAAM,aAAa,GAAG,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAElD,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;gBACrC,OAAO,GAAG,UAAU,CAAC,SAAS,CAAC;gBAC/B,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;gBAC9B,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;YAEpD,CAAC;iBAAM,IAAI,UAAU,YAAY,kBAAkB,EAAE,CAAC;gBACrD,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;gBAC9C,SAAS;YACV,CAAC;iBAAM,CAAC;gBACP,SAAS;YACV,CAAC;YAED,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC;YACjC,IAAI,KAAa,EAAE,SAAiB,CAAC;YACrC,IAAI,GAAG,EAAE,CAAC;gBACT,IAAI,CAAS,CAAC;gBACd,IAAI,OAAO,EAAE,CAAC;oBACb,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBACjF,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;oBACrF,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;oBACrF,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;oBACrF,KAAK,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;gBAC9C,CAAC;qBAAM,CAAC;oBACP,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBACpE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;oBACxE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;oBACxE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;oBACxE,KAAK,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;gBAC9C,CAAC;gBAED,SAAS,GAAG,UAAU,CAAC;gBACvB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;oBACpB,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;oBACnC,SAAS,GAAG,UAAU;wBACrB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;wBACzB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;wBACxB,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACpB,CAAC;YACF,CAAC;iBAAM,CAAC;gBACP,IAAI,OAAO,EAAE,CAAC;oBACb,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBACvF,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBACvF,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBACvF,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBACvF,KAAK,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;gBAC9C,CAAC;qBAAM,CAAC;oBACP,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBAC1E,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBAC1E,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBAC1E,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;oBAC1E,KAAK,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;gBAC9C,CAAC;gBAED,SAAS,GAAG,CAAC,CAAC;gBACd,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;oBACpB,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;oBACnC,SAAS,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;gBAC5F,CAAC;YACF,CAAC;YAED,IAAI,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC;gBAC1B,OAAO,CAAC,qBAAqB,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC/E,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;gBACxC,aAAa,GAAG,OAAO,CAAC,qBAAqB,GAAG,MAAM,CAAC;gBACvD,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;gBAC9B,OAAO,GAAG,OAAO,CAAC,qBAAqB,CAAC;gBACxC,YAAY,GAAG,OAAO,CAAC,sBAAsB,CAAC;YAC/C,CAAC;YAED,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,aAAa,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;YAC7E,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;YACpC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC;YAEtB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC;YAChE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,aAAa,IAAI,CAAC,CAAC,CAAC,CAAC;YAEjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;gBACtB,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;YAC/B,CAAC;YAED,IAAI,OAAO,YAAY,WAAW,EAAE,CAAC;gBACpC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;YACpD,CAAC;iBAAM,CAAC;gBACP,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;YACjD,CAAC;YAED,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC9B,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;QAED,OAAO,CAAC,OAAO,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAEO,gBAAgB,CAAE,QAAyB,EAAE,KAAa,EAAE,IAAY,EAC/E,WAAmB,EAAE,UAAkB,EAAE,MAAc;QAEvD,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;QAE7E,OAAO,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;QACvC,OAAO,CAAC,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;QAEnC,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,aAAa,GAAG,CAAC,CAAC;QACtB,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,MAAM,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAExB,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;YACtD,eAAe,IAAI,GAAG,CAAC,WAAW,GAAG,MAAM,CAAC;YAE5C,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;YACpC,SAAS,IAAI,GAAG,CAAC,WAAW,IAAI,CAAC,CAAC;YAElC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YAC7C,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;YACrD,YAAY,IAAI,GAAG,CAAC,WAAW,CAAC;YAEhC,2DAA2D;YAC3D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,UAAU,EAAE,CAAC,EAAE;gBACtC,OAAO,CAAC,OAAO,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC;YAEpE,aAAa,IAAI,GAAG,CAAC,UAAU,CAAC;YAChC,YAAY,IAAI,GAAG,CAAC,WAAW,CAAC;QACjC,CAAC;QAED,OAAO,OAAO,CAAC;IAChB,CAAC;IAEO,aAAa,CAAE,MAAc;QACpC,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAEvD,IAAI,IAA+B,CAAC;QACpC,IAAI,IAA+B,CAAC;QAEpC,IAAI,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QACnC,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,IAAI,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACpC,IAAI,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QAElC,OAAO,CAAC,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;YACxC,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAE3E,IAAI,GAAG,IAAI,GAAG,CAAC,WAAW,KAAK,CAAC,IAAI,GAAG,CAAC,UAAU,KAAK,CAAC,EAAE,CAAC;gBAC1D,CAAC,EAAE,CAAC;gBACJ,SAAS;YACV,CAAC;YAED,MAAM,QAAQ,GAAG,GAAG,KAAK,IAAI;gBAC5B,GAAG,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO;gBAC7B,GAAG,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS;gBACjC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;gBACjC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;gBACzC,UAAU,GAAG,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC;YACtC,IAAI,QAAQ,EAAE,CAAC;gBACd,WAAW,IAAI,GAAG,CAAC,WAAW,CAAC;gBAC/B,UAAU,IAAI,GAAG,CAAC,UAAU,CAAC;YAC9B,CAAC;iBAAM,CAAC;gBACP,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,cAAc,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,EAC3E,WAAW,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;gBAElC,IAAI,CAAC,IAAI,EAAE,CAAC;oBACX,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC;gBACvB,CAAC;qBAAM,CAAC;oBACP,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;oBACpB,IAAI,GAAG,OAAO,CAAC;gBAChB,CAAC;gBAED,IAAI,CAAC,KAAK,IAAI,CAAC,cAAc,CAAC,MAAM;oBAAE,MAAM;gBAE5C,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;gBAC/B,UAAU,GAAG,CAAC,CAAC;gBACf,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;gBAChC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;YAC/B,CAAC;YACD,CAAC,EAAE,CAAC;QACL,CAAC;QAED,OAAO,IAAI,CAAC;IACb,CAAC;CACD;AAuBD,MAAM,WAAW;IACR,IAAI,GAAoB,EAAE,CAAC;IAC3B,KAAK,GAAoB,EAAE,CAAC;IAEpC,UAAU,CAAE,WAAmB,EAAE,UAAkB,EAAE,MAAc;QAClE,IAAI,GAA8B,CAAC;QACnC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YAC3B,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,IAAI,WAAW,GAAG,MAAM,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;gBACpF,GAAG,GAAG,CAAC,CAAC;gBACR,MAAM;YACP,CAAC;QACF,CAAC;QAED,IAAI,CAAC,GAAG,EAAE,CAAC;YACV,MAAM,UAAU,GAAG,IAAI,YAAY,CAAC,WAAW,GAAG,MAAM,CAAC,CAAC;YAC1D,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC;YAChD,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC;YAC7C,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC;YACjD,MAAM,QAAQ,GAAG,IAAI,WAAW,CAAC,UAAU,CAAC,CAAC;YAC7C,GAAG,GAAG;gBACL,SAAS,EAAE,UAAU;gBACrB,GAAG,EAAE,IAAI;gBACT,MAAM,EAAE,OAAO;gBACf,UAAU,EAAE,WAAW;gBACvB,OAAO,EAAE,QAAQ;gBACjB,UAAU;gBACV,IAAI;gBACJ,OAAO;gBACP,WAAW;gBACX,QAAQ;gBACR,WAAW;gBACX,UAAU;gBACV,SAAS,EAAE,SAAS,CAAC,MAAM;gBAC3B,OAAO,EAAE,IAAI;aACb,CAAC;QACH,CAAC;aAAM,CAAC;YACP,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;YAC5C,GAAG,CAAC,IAAI,GAAG,SAAS,CAAC;YACrB,GAAG,CAAC,WAAW,GAAG,WAAW,CAAC;YAC9B,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC;YAE5B,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,CAAC;YACjE,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,WAAW,IAAI,CAAC,CAAC,CAAC;YACjD,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;YAClD,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;YAC1D,GAAG,CAAC,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QACpD,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrB,OAAO,GAAG,CAAC;IACZ,CAAC;IAED,KAAK;QACJ,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IACvB,CAAC;CACD","sourcesContent":["/******************************************************************************\n * Spine Runtimes License Agreement\n * Last updated April 5, 2025. Replaces all prior versions.\n *\n * Copyright (c) 2013-2025, Esoteric Software LLC\n *\n * Integration of the Spine Runtimes into software or otherwise creating\n * derivative works of the Spine Runtimes is permitted under the terms and\n * conditions of Section 2 of the Spine Editor License Agreement:\n * http://esotericsoftware.com/spine-editor-license\n *\n * Otherwise, it is permitted to integrate the Spine Runtimes into software\n * or otherwise create derivative works of the Spine Runtimes (collectively,\n * \"Products\"), provided that each user of the Products must obtain their own\n * Spine Editor license and redistribution of the Products in any form must\n * include this license and copyright notice.\n *\n * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC \"AS IS\" AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY\n * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,\n * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND\n * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *****************************************************************************/\n\nimport { ClippingAttachment, MeshAttachment, RegionAttachment } from \"./attachments/index.js\";\nimport type { Skeleton } from \"./Skeleton.js\";\nimport { SkeletonClipping } from \"./SkeletonClipping.js\";\nimport { BlendMode } from \"./SlotData.js\";\nimport type { Color, NumberArrayLike } from \"./Utils.js\";\n\nexport class SkeletonRendererCore {\n\tprivate commandPool = new CommandPool();\n\tprivate worldVertices = new Float32Array(12 * 1024);\n\tprivate quadIndices = new Uint16Array([0, 1, 2, 2, 3, 0]);\n\tprivate clipping = new SkeletonClipping();\n\tprivate renderCommands: RenderCommand[] = [];\n\n\trender (skeleton: Skeleton, pma = false, inColor?: [number, number, number, number], stride = 2): RenderCommand | undefined {\n\t\tthis.commandPool.reset();\n\t\tthis.renderCommands.length = 0;\n\n\t\tconst clipper = this.clipping;\n\n\t\tconst drawOrder = skeleton.drawOrder.appliedPose;\n\t\tfor (let i = 0; i < skeleton.slots.length; i++) {\n\t\t\tconst slot = drawOrder[i];\n\t\t\tconst attachment = slot.appliedPose.attachment;\n\n\t\t\tif (!attachment) {\n\t\t\t\tclipper.clipEnd(slot);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst pose = slot.appliedPose;\n\t\t\tconst slotColor = pose.color;\n\t\t\tconst alpha = slotColor.a;\n\t\t\tif ((alpha === 0 || !slot.bone.active) && !(attachment instanceof ClippingAttachment)) {\n\t\t\t\tclipper.clipEnd(slot);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet vertices: NumberArrayLike;\n\t\t\tlet verticesCount: number;\n\t\t\tlet uvs: NumberArrayLike;\n\t\t\tlet indices: number[] | Uint16Array;\n\t\t\tlet indicesCount: number;\n\t\t\tlet attachmentColor: Color;\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: texture depends on the runtime\n\t\t\tlet texture: any;\n\n\t\t\tif (attachment instanceof RegionAttachment) {\n\t\t\t\tattachmentColor = attachment.color;\n\n\t\t\t\tif (attachmentColor.a === 0) {\n\t\t\t\t\tclipper.clipEnd(slot);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tconst sequence = attachment.sequence;\n\t\t\t\tconst sequenceIndex = sequence.resolveIndex(pose);\n\t\t\t\tattachment.computeWorldVertices(slot, attachment.getOffsets(pose), this.worldVertices, 0, stride);\n\n\t\t\t\tvertices = this.worldVertices;\n\t\t\t\tverticesCount = 4;\n\t\t\t\tuvs = sequence.getUVs(sequenceIndex);\n\t\t\t\tindices = this.quadIndices;\n\t\t\t\tindicesCount = 6;\n\t\t\t\ttexture = sequence.regions[sequenceIndex]?.texture;\n\n\t\t\t} else if (attachment instanceof MeshAttachment) {\n\t\t\t\tattachmentColor = attachment.color;\n\n\t\t\t\tif (attachmentColor.a === 0) {\n\t\t\t\t\tclipper.clipEnd(slot);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tif (this.worldVertices.length < attachment.worldVerticesLength)\n\t\t\t\t\tthis.worldVertices = new Float32Array(attachment.worldVerticesLength);\n\n\t\t\t\tattachment.computeWorldVertices(skeleton, slot, 0, attachment.worldVerticesLength, this.worldVertices, 0, stride);\n\t\t\t\tvertices = this.worldVertices;\n\t\t\t\tverticesCount = attachment.worldVerticesLength >> 1;\n\n\t\t\t\tconst sequence = attachment.sequence;\n\t\t\t\tconst sequenceIndex = sequence.resolveIndex(pose);\n\n\t\t\t\tuvs = sequence.getUVs(sequenceIndex);\n\t\t\t\tindices = attachment.triangles;\n\t\t\t\tindicesCount = indices.length;\n\t\t\t\ttexture = sequence.regions[sequenceIndex]?.texture;\n\n\t\t\t} else if (attachment instanceof ClippingAttachment) {\n\t\t\t\tclipper.clipStart(skeleton, slot, attachment);\n\t\t\t\tcontinue;\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst skelColor = skeleton.color;\n\t\t\tlet color: number, darkColor: number;\n\t\t\tif (pma) {\n\t\t\t\tlet a: number;\n\t\t\t\tif (inColor) {\n\t\t\t\t\ta = Math.floor(inColor[3] * skelColor.a * slotColor.a * attachmentColor.a * 255);\n\t\t\t\t\tconst r = Math.floor(a * inColor[0] * skelColor.r * slotColor.r * attachmentColor.r);\n\t\t\t\t\tconst g = Math.floor(a * inColor[1] * skelColor.g * slotColor.g * attachmentColor.g);\n\t\t\t\t\tconst b = Math.floor(a * inColor[2] * skelColor.b * slotColor.b * attachmentColor.b);\n\t\t\t\t\tcolor = (a << 24) | (r << 16) | (g << 8) | b;\n\t\t\t\t} else {\n\t\t\t\t\ta = Math.floor(skelColor.a * slotColor.a * attachmentColor.a * 255);\n\t\t\t\t\tconst r = Math.floor(a * skelColor.r * slotColor.r * attachmentColor.r);\n\t\t\t\t\tconst g = Math.floor(a * skelColor.g * slotColor.g * attachmentColor.g);\n\t\t\t\t\tconst b = Math.floor(a * skelColor.b * slotColor.b * attachmentColor.b);\n\t\t\t\t\tcolor = (a << 24) | (r << 16) | (g << 8) | b;\n\t\t\t\t}\n\n\t\t\t\tdarkColor = 0xff000000;\n\t\t\t\tif (pose.darkColor) {\n\t\t\t\t\tconst { r, g, b } = pose.darkColor;\n\t\t\t\t\tdarkColor = 0xff000000 |\n\t\t\t\t\t\t(Math.floor(r * a) << 16) |\n\t\t\t\t\t\t(Math.floor(g * a) << 8) |\n\t\t\t\t\t\tMath.floor(b * a);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (inColor) {\n\t\t\t\t\tconst a = Math.floor(inColor[3] * skelColor.a * slotColor.a * attachmentColor.a * 255);\n\t\t\t\t\tconst r = Math.floor(inColor[0] * skelColor.r * slotColor.r * attachmentColor.r * 255);\n\t\t\t\t\tconst g = Math.floor(inColor[1] * skelColor.g * slotColor.g * attachmentColor.g * 255);\n\t\t\t\t\tconst b = Math.floor(inColor[2] * skelColor.b * slotColor.b * attachmentColor.b * 255);\n\t\t\t\t\tcolor = (a << 24) | (r << 16) | (g << 8) | b;\n\t\t\t\t} else {\n\t\t\t\t\tconst a = Math.floor(skelColor.a * slotColor.a * attachmentColor.a * 255);\n\t\t\t\t\tconst r = Math.floor(skelColor.r * slotColor.r * attachmentColor.r * 255);\n\t\t\t\t\tconst g = Math.floor(skelColor.g * slotColor.g * attachmentColor.g * 255);\n\t\t\t\t\tconst b = Math.floor(skelColor.b * slotColor.b * attachmentColor.b * 255);\n\t\t\t\t\tcolor = (a << 24) | (r << 16) | (g << 8) | b;\n\t\t\t\t}\n\n\t\t\t\tdarkColor = 0;\n\t\t\t\tif (pose.darkColor) {\n\t\t\t\t\tconst { r, g, b } = pose.darkColor;\n\t\t\t\t\tdarkColor = (Math.floor(r * 255) << 16) | (Math.floor(g * 255) << 8) | Math.floor(b * 255);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (clipper.isClipping()) {\n\t\t\t\tclipper.clipTrianglesUnpacked(vertices, 0, indices, indicesCount, uvs, stride);\n\t\t\t\tvertices = clipper.clippedVerticesTyped;\n\t\t\t\tverticesCount = clipper.clippedVerticesLength / stride;\n\t\t\t\tuvs = clipper.clippedUVsTyped;\n\t\t\t\tindices = clipper.clippedTrianglesTyped;\n\t\t\t\tindicesCount = clipper.clippedTrianglesLength;\n\t\t\t}\n\n\t\t\tconst cmd = this.commandPool.getCommand(verticesCount, indicesCount, stride);\n\t\t\tcmd.blendMode = slot.data.blendMode;\n\t\t\tcmd.texture = texture;\n\n\t\t\tcmd.positions.set(vertices.subarray(0, verticesCount * stride));\n\t\t\tcmd.uvs.set(uvs.subarray(0, verticesCount << 1));\n\n\t\t\tfor (let j = 0; j < verticesCount; j++) {\n\t\t\t\tcmd.colors[j] = color;\n\t\t\t\tcmd.darkColors[j] = darkColor;\n\t\t\t}\n\n\t\t\tif (indices instanceof Uint16Array) {\n\t\t\t\tcmd.indices.set(indices.subarray(0, indicesCount));\n\t\t\t} else {\n\t\t\t\tcmd.indices.set(indices.slice(0, indicesCount));\n\t\t\t}\n\n\t\t\tthis.renderCommands.push(cmd);\n\t\t\tclipper.clipEnd(slot);\n\t\t}\n\n\t\tclipper.clipEnd();\n\t\treturn this.batchCommands(stride);\n\t}\n\n\tprivate batchSubCommands (commands: RenderCommand[], first: number, last: number,\n\t\tnumVertices: number, numIndices: number, stride: number): RenderCommand {\n\n\t\tconst firstCmd = commands[first];\n\t\tconst batched = this.commandPool.getCommand(numVertices, numIndices, stride);\n\n\t\tbatched.blendMode = firstCmd.blendMode;\n\t\tbatched.texture = firstCmd.texture;\n\n\t\tlet positionsOffset = 0;\n\t\tlet uvsOffset = 0;\n\t\tlet colorsOffset = 0;\n\t\tlet indicesOffset = 0;\n\t\tlet vertexOffset = 0;\n\n\t\tfor (let i = first; i <= last; i++) {\n\t\t\tconst cmd = commands[i];\n\n\t\t\tbatched.positions.set(cmd.positions, positionsOffset);\n\t\t\tpositionsOffset += cmd.numVertices * stride;\n\n\t\t\tbatched.uvs.set(cmd.uvs, uvsOffset);\n\t\t\tuvsOffset += cmd.numVertices << 1;\n\n\t\t\tbatched.colors.set(cmd.colors, colorsOffset);\n\t\t\tbatched.darkColors.set(cmd.darkColors, colorsOffset);\n\t\t\tcolorsOffset += cmd.numVertices;\n\n\t\t\t// cannot fast copy - indices need vertex offset adjustment\n\t\t\tfor (let j = 0; j < cmd.numIndices; j++)\n\t\t\t\tbatched.indices[indicesOffset + j] = cmd.indices[j] + vertexOffset;\n\n\t\t\tindicesOffset += cmd.numIndices;\n\t\t\tvertexOffset += cmd.numVertices;\n\t\t}\n\n\t\treturn batched;\n\t}\n\n\tprivate batchCommands (stride: number): RenderCommand | undefined {\n\t\tif (this.renderCommands.length === 0) return undefined;\n\n\t\tlet root: RenderCommand | undefined;\n\t\tlet last: RenderCommand | undefined;\n\n\t\tlet first = this.renderCommands[0];\n\t\tlet startIndex = 0;\n\t\tlet i = 1;\n\t\tlet numVertices = first.numVertices;\n\t\tlet numIndices = first.numIndices;\n\n\t\twhile (i <= this.renderCommands.length) {\n\t\t\tconst cmd = i < this.renderCommands.length ? this.renderCommands[i] : null;\n\n\t\t\tif (cmd && cmd.numVertices === 0 && cmd.numIndices === 0) {\n\t\t\t\ti++;\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst canBatch = cmd !== null &&\n\t\t\t\tcmd.texture === first.texture &&\n\t\t\t\tcmd.blendMode === first.blendMode &&\n\t\t\t\tcmd.colors[0] === first.colors[0] &&\n\t\t\t\tcmd.darkColors[0] === first.darkColors[0] &&\n\t\t\t\tnumIndices + cmd.numIndices < 0xffff;\n\t\t\tif (canBatch) {\n\t\t\t\tnumVertices += cmd.numVertices;\n\t\t\t\tnumIndices += cmd.numIndices;\n\t\t\t} else {\n\t\t\t\tconst batched = this.batchSubCommands(this.renderCommands, startIndex, i - 1,\n\t\t\t\t\tnumVertices, numIndices, stride);\n\n\t\t\t\tif (!last) {\n\t\t\t\t\troot = last = batched;\n\t\t\t\t} else {\n\t\t\t\t\tlast.next = batched;\n\t\t\t\t\tlast = batched;\n\t\t\t\t}\n\n\t\t\t\tif (i === this.renderCommands.length) break;\n\n\t\t\t\tfirst = this.renderCommands[i];\n\t\t\t\tstartIndex = i;\n\t\t\t\tnumVertices = first.numVertices;\n\t\t\t\tnumIndices = first.numIndices;\n\t\t\t}\n\t\t\ti++;\n\t\t}\n\n\t\treturn root;\n\t}\n}\n\n// values with under score is the original sized array, bigger than necessary\n// values without under score is a view of the orignal array, sized as needed\ninterface RenderCommand {\n\tpositions: Float32Array;\n\tuvs: Float32Array;\n\tcolors: Uint32Array;\n\tdarkColors: Uint32Array;\n\tindices: Uint16Array;\n\t_positions: Float32Array;\n\t_uvs: Float32Array;\n\t_colors: Uint32Array;\n\t_darkColors: Uint32Array;\n\t_indices: Uint16Array;\n\tnumVertices: number;\n\tnumIndices: number;\n\tblendMode: BlendMode;\n\t// biome-ignore lint/suspicious/noExplicitAny: texture depends on the runtime\n\ttexture: any;\n\tnext?: RenderCommand;\n}\n\nclass CommandPool {\n\tprivate pool: RenderCommand[] = [];\n\tprivate inUse: RenderCommand[] = [];\n\n\tgetCommand (numVertices: number, numIndices: number, stride: number): RenderCommand {\n\t\tlet cmd: RenderCommand | undefined;\n\t\tfor (const c of this.pool) {\n\t\t\tif (c._positions.length >= numVertices * stride && c._indices.length >= numIndices) {\n\t\t\t\tcmd = c;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (!cmd) {\n\t\t\tconst _positions = new Float32Array(numVertices * stride);\n\t\t\tconst _uvs = new Float32Array(numVertices << 1);\n\t\t\tconst _colors = new Uint32Array(numVertices);\n\t\t\tconst _darkColors = new Uint32Array(numVertices);\n\t\t\tconst _indices = new Uint16Array(numIndices);\n\t\t\tcmd = {\n\t\t\t\tpositions: _positions,\n\t\t\t\tuvs: _uvs,\n\t\t\t\tcolors: _colors,\n\t\t\t\tdarkColors: _darkColors,\n\t\t\t\tindices: _indices,\n\t\t\t\t_positions,\n\t\t\t\t_uvs,\n\t\t\t\t_colors,\n\t\t\t\t_darkColors,\n\t\t\t\t_indices,\n\t\t\t\tnumVertices,\n\t\t\t\tnumIndices,\n\t\t\t\tblendMode: BlendMode.Normal,\n\t\t\t\ttexture: null\n\t\t\t};\n\t\t} else {\n\t\t\tthis.pool.splice(this.pool.indexOf(cmd), 1);\n\t\t\tcmd.next = undefined;\n\t\t\tcmd.numVertices = numVertices;\n\t\t\tcmd.numIndices = numIndices;\n\n\t\t\tcmd.positions = cmd._positions.subarray(0, numVertices * stride);\n\t\t\tcmd.uvs = cmd._uvs.subarray(0, numVertices << 1);\n\t\t\tcmd.colors = cmd._colors.subarray(0, numVertices);\n\t\t\tcmd.darkColors = cmd._darkColors.subarray(0, numVertices);\n\t\t\tcmd.indices = cmd._indices.subarray(0, numIndices);\n\t\t}\n\n\t\tthis.inUse.push(cmd);\n\t\treturn cmd;\n\t}\n\n\treset (): void {\n\t\tthis.pool.push(...this.inUse);\n\t\tthis.inUse.length = 0;\n\t}\n}"]}

package/dist/Skin.d.ts

@@ -26,42 +26,46 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-import { Attachment } from "./attachments/Attachment.js";
-import { BoneData } from "./BoneData.js";
-import { ConstraintData } from "./ConstraintData.js";
-import { Skeleton } from "./Skeleton.js";
-import { Color, StringMap } from "./Utils.js";
+import type { Attachment } from "./attachments/Attachment.js";
+import type { BoneData } from "./BoneData.js";
+import type { ConstraintData } from "./ConstraintData.js";
+import type { Skeleton } from "./Skeleton.js";
+import { Color, type StringMap } from "./Utils.js";
 /** Stores an entry in the skin consisting of the slot index, name, and attachment **/
 export declare class SkinEntry {
+    /** The {@link Skeleton.slots} index. */
     slotIndex: number;
-    name: string;
+    placeholder: string;
+    /** The attachment for this skin entry. */
     attachment: Attachment;
-    constructor(slotIndex: number | undefined, name: string, attachment: Attachment);
+    constructor(slotIndex: number | undefined, placeholder: string, attachment: Attachment);
 }
-/** Stores attachments by slot index and attachment name.
+/** Stores attachments by slot index and placeholder name. Multiple {@link Skeleton} instances can use the same skins.
  *
- * See SkeletonData {@link SkeletonData#defaultSkin}, Skeleton {@link Skeleton#skin}, and
+ * See {@link SkeletonData.defaultSkin}, {@link Skeleton.skin}, and
  * [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide. */
 export declare class Skin {
-    /** The skin's name, which is unique across all skins in the skeleton. */
+    /** The skin's name, unique across all skins in the skeleton.
+     *
+     * See {@link SkeletonData.findSkin}. */
     name: string;
     attachments: StringMap<Attachment>[];
     bones: BoneData[];
-    constraints: ConstraintData[];
+    constraints: ConstraintData<any, any>[];
     /** The color of the skin as it was in Spine, or a default color if nonessential data was not exported. */
     color: Color;
     constructor(name: string);
     /** Adds an attachment to the skin for the specified slot index and name. */
-    setAttachment(slotIndex: number, name: string, attachment: Attachment): void;
+    setAttachment(slotIndex: number, placeholder: string, attachment: Attachment): void;
     /** Adds all attachments, bones, and constraints from the specified skin to this skin. */
     addSkin(skin: Skin): void;
     /** 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: Skin): void;
-    /** Returns the attachment for the specified slot index and name, or null. */
-    getAttachment(slotIndex: number, name: string): Attachment | null;
-    /** Removes the attachment in the skin for the specified slot index and name, if any. */
-    removeAttachment(slotIndex: number, name: string): void;
+    /** Returns the attachment for the specified slot index and placeholder, or null. */
+    getAttachment(slotIndex: number, placeholder: string): Attachment | null;
+    /** Removes the attachment in the skin for the specified slot index and placeholder, if any. */
+    removeAttachment(slotIndex: number, placeholder: string): void;
     /** Returns all attachments in this skin. */
     getAttachments(): Array<SkinEntry>;
     /** Returns all attachments in this skin for the specified slot index. */