@esotericsoftware/spine-pixi-v8 4.2.63

package/dist/SpineDebugRenderer.js

@@ -0,0 +1,473 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, 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 { Container, Graphics, Text } from 'pixi.js';
+import { ClippingAttachment, MeshAttachment, PathAttachment, RegionAttachment, SkeletonBounds } from '@esotericsoftware/spine-core';
+/**
+ * This is a debug renderer that uses PixiJS Graphics under the hood.
+ * @public
+ */
+export class SpineDebugRenderer {
+    registeredSpines = new Map();
+    drawMeshHull = true;
+    drawMeshTriangles = true;
+    drawBones = true;
+    drawPaths = true;
+    drawBoundingBoxes = true;
+    drawClipping = true;
+    drawRegionAttachments = true;
+    drawEvents = true;
+    lineWidth = 1;
+    regionAttachmentsColor = 0x0078ff;
+    meshHullColor = 0x0078ff;
+    meshTrianglesColor = 0xffcc00;
+    clippingPolygonColor = 0xff00ff;
+    boundingBoxesRectColor = 0x00ff00;
+    boundingBoxesPolygonColor = 0x00ff00;
+    boundingBoxesCircleColor = 0x00ff00;
+    pathsCurveColor = 0xff0000;
+    pathsLineColor = 0xff00ff;
+    skeletonXYColor = 0xff0000;
+    bonesColor = 0x00eecc;
+    eventFontSize = 24;
+    eventFontColor = 0x0;
+    /**
+     * 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 Container(),
+            bones: new Container(),
+            skeletonXY: new Graphics(),
+            regionAttachmentsShape: new Graphics(),
+            meshTrianglesLine: new Graphics(),
+            meshHullLine: new Graphics(),
+            clippingPolygon: new Graphics(),
+            boundingBoxesRect: new Graphics(),
+            boundingBoxesCircle: new Graphics(),
+            boundingBoxesPolygon: new Graphics(),
+            pathsCurve: new Graphics(),
+            pathsLine: new Graphics(),
+            eventText: new Container(),
+            eventCallback: {
+                event: (_, event) => {
+                    if (this.drawEvents) {
+                        const scale = Math.abs(spine.scale.x || spine.scale.y || 1);
+                        const text = new Text({
+                            text: event.data.name,
+                            style: {
+                                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;
+        // Disable screen reader and mouse input on debug objects.
+        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 should never happen. Spines are registered when you assign spine.debug
+            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, textureSource: 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.strokeStyle = { width: lineWidth, color: this.skeletonXYColor };
+        for (let i = 0, len = bones.length; i < len; i++) {
+            const bone = bones[i];
+            const boneLen = bone.data.length;
+            const starX = skeletonX + bone.worldX;
+            const starY = skeletonY + bone.worldY;
+            const endX = skeletonX + (boneLen * bone.a) + bone.worldX;
+            const endY = skeletonY + (boneLen * bone.b) + bone.worldY;
+            if (bone.data.name === 'root' || bone.data.parent === null) {
+                continue;
+            }
+            const w = Math.abs(starX - endX);
+            const h = Math.abs(starY - endY);
+            // a = w, // side length a
+            const a2 = Math.pow(w, 2); // square root of side length a
+            const b = h; // side length b
+            const b2 = Math.pow(h, 2); // square root of side length b
+            const c = Math.sqrt(a2 + b2); // side length c
+            const c2 = Math.pow(c, 2); // square root of side length c
+            const rad = Math.PI / 180;
+            // A = Math.acos([a2 + c2 - b2] / [2 * a * c]) || 0, // Angle A
+            // C = Math.acos([a2 + b2 - c2] / [2 * a * b]) || 0, // C angle
+            const B = Math.acos((c2 + b2 - a2) / (2 * b * c)) || 0; // angle of corner B
+            if (c === 0) {
+                continue;
+            }
+            const gp = new Graphics();
+            debugDisplayObjects.bones.addChild(gp);
+            // draw bone
+            const refRation = c / 50 / scale;
+            gp.context
+                .poly([0, 0, 0 - refRation, c - (refRation * 3), 0, c - refRation, 0 + refRation, c - (refRation * 3)])
+                .fill(this.bonesColor);
+            gp.x = starX;
+            gp.y = starY;
+            gp.pivot.y = c;
+            // Calculate bone rotation angle
+            let rotation = 0;
+            if (starX < endX && starY < endY) {
+                // bottom right
+                rotation = -B + (180 * rad);
+            }
+            else if (starX > endX && starY < endY) {
+                // bottom left
+                rotation = (180 * rad) + B;
+            }
+            else if (starX > endX && starY > endY) {
+                // top left
+                rotation = -B;
+            }
+            else if (starX < endX && starY > endY) {
+                // bottom left
+                rotation = B;
+            }
+            else if (starY === endY && starX < endX) {
+                // To the right
+                rotation = 90 * rad;
+            }
+            else if (starY === endY && starX > endX) {
+                // go left
+                rotation = -90 * rad;
+            }
+            else if (starX === endX && starY < endY) {
+                // down
+                rotation = 180 * rad;
+            }
+            else if (starX === endX && starY > endY) {
+                // up
+                rotation = 0;
+            }
+            gp.rotation = rotation;
+            // Draw the starting rotation point of the bone
+            gp.circle(0, c, refRation * 1.2)
+                .fill({ color: 0x000000, alpha: 0.6 })
+                .stroke({ width: lineWidth + refRation / 2.4, color: this.bonesColor });
+        }
+        // Draw the skeleton starting point "X" form
+        const startDotSize = lineWidth * 3;
+        debugDisplayObjects.skeletonXY.context
+            .moveTo(skeletonX - startDotSize, skeletonY - startDotSize)
+            .lineTo(skeletonX + startDotSize, skeletonY + startDotSize)
+            .moveTo(skeletonX + startDotSize, skeletonY - startDotSize)
+            .lineTo(skeletonX - startDotSize, skeletonY + startDotSize)
+            .stroke();
+    }
+    drawRegionAttachmentsFunc(spine, debugDisplayObjects, lineWidth) {
+        const skeleton = spine.skeleton;
+        const slots = skeleton.slots;
+        for (let i = 0, len = slots.length; i < len; i++) {
+            const slot = slots[i];
+            const attachment = slot.getAttachment();
+            if (attachment === null || !(attachment instanceof RegionAttachment)) {
+                continue;
+            }
+            const regionAttachment = attachment;
+            const vertices = new Float32Array(8);
+            regionAttachment.computeWorldVertices(slot, vertices, 0, 2);
+            debugDisplayObjects.regionAttachmentsShape.poly(Array.from(vertices.slice(0, 8)));
+        }
+        debugDisplayObjects.regionAttachmentsShape.stroke({
+            color: this.regionAttachmentsColor,
+            width: lineWidth
+        });
+    }
+    drawMeshHullAndMeshTriangles(spine, debugDisplayObjects, lineWidth) {
+        const skeleton = spine.skeleton;
+        const slots = skeleton.slots;
+        for (let i = 0, len = slots.length; i < len; i++) {
+            const slot = slots[i];
+            if (!slot.bone.active) {
+                continue;
+            }
+            const attachment = slot.getAttachment();
+            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(slot, 0, meshAttachment.worldVerticesLength, vertices, 0, 2);
+            // draw the skinned mesh (triangle)
+            if (this.drawMeshTriangles) {
+                for (let i = 0, len = triangles.length; i < len; i += 3) {
+                    const v1 = triangles[i] * 2;
+                    const v2 = triangles[i + 1] * 2;
+                    const v3 = triangles[i + 2] * 2;
+                    debugDisplayObjects.meshTrianglesLine.context
+                        .moveTo(vertices[v1], vertices[v1 + 1])
+                        .lineTo(vertices[v2], vertices[v2 + 1])
+                        .lineTo(vertices[v3], vertices[v3 + 1]);
+                }
+            }
+            // draw skin border
+            if (this.drawMeshHull && hullLength > 0) {
+                hullLength = (hullLength >> 1) * 2;
+                let lastX = vertices[hullLength - 2];
+                let lastY = vertices[hullLength - 1];
+                for (let i = 0, len = hullLength; i < len; i += 2) {
+                    const x = vertices[i];
+                    const y = vertices[i + 1];
+                    debugDisplayObjects.meshHullLine.context
+                        .moveTo(x, y)
+                        .lineTo(lastX, lastY);
+                    lastX = x;
+                    lastY = y;
+                }
+            }
+        }
+        debugDisplayObjects.meshHullLine.stroke({ width: lineWidth, color: this.meshHullColor });
+        debugDisplayObjects.meshTrianglesLine.stroke({ width: lineWidth, color: this.meshTrianglesColor });
+    }
+    drawClippingFunc(spine, debugDisplayObjects, lineWidth) {
+        const skeleton = spine.skeleton;
+        const slots = skeleton.slots;
+        for (let i = 0, len = slots.length; i < len; i++) {
+            const slot = slots[i];
+            if (!slot.bone.active) {
+                continue;
+            }
+            const attachment = slot.getAttachment();
+            if (attachment === null || !(attachment instanceof ClippingAttachment)) {
+                continue;
+            }
+            const clippingAttachment = attachment;
+            const nn = clippingAttachment.worldVerticesLength;
+            const world = new Float32Array(nn);
+            clippingAttachment.computeWorldVertices(slot, 0, nn, world, 0, 2);
+            debugDisplayObjects.clippingPolygon.poly(Array.from(world));
+        }
+        debugDisplayObjects.clippingPolygon.stroke({
+            width: lineWidth, color: this.clippingPolygonColor, alpha: 1
+        });
+    }
+    drawBoundingBoxesFunc(spine, debugDisplayObjects, lineWidth) {
+        // draw the total outline of the bounding box
+        const bounds = new SkeletonBounds();
+        bounds.update(spine.skeleton, true);
+        if (bounds.minX !== Infinity) {
+            debugDisplayObjects.boundingBoxesRect
+                .rect(bounds.minX, bounds.minY, bounds.getWidth(), bounds.getHeight())
+                .stroke({ width: lineWidth, color: this.boundingBoxesRectColor });
+        }
+        const polygons = bounds.polygons;
+        const drawPolygon = (polygonVertices, _offset, count) => {
+            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];
+                // draw the bounding box node
+                debugDisplayObjects.boundingBoxesCircle.beginFill(this.boundingBoxesCircleColor);
+                debugDisplayObjects.boundingBoxesCircle.drawCircle(x1, y1, dotSize);
+                debugDisplayObjects.boundingBoxesCircle.fill(0);
+                debugDisplayObjects.boundingBoxesCircle
+                    .circle(x1, y1, dotSize)
+                    .fill({ color: this.boundingBoxesCircleColor });
+                paths.push(x1, y1);
+            }
+            // draw the bounding box area
+            debugDisplayObjects.boundingBoxesPolygon
+                .poly(paths)
+                .fill({
+                color: this.boundingBoxesPolygonColor,
+                alpha: 0.1
+            })
+                .stroke({
+                width: lineWidth,
+                color: this.boundingBoxesPolygonColor
+            });
+        };
+        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;
+        for (let i = 0, len = slots.length; i < len; i++) {
+            const slot = slots[i];
+            if (!slot.bone.active) {
+                continue;
+            }
+            const attachment = slot.getAttachment();
+            if (attachment === null || !(attachment instanceof PathAttachment)) {
+                continue;
+            }
+            const pathAttachment = attachment;
+            let nn = pathAttachment.worldVerticesLength;
+            const world = new Float32Array(nn);
+            pathAttachment.computeWorldVertices(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];
+                // curve
+                debugDisplayObjects.pathsCurve.moveTo(x1, y1);
+                debugDisplayObjects.pathsCurve.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);
+                // handle
+                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];
+                // curve
+                debugDisplayObjects.pathsCurve.moveTo(x1, y1);
+                debugDisplayObjects.pathsCurve.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);
+                // handle
+                debugDisplayObjects.pathsLine.moveTo(x1, y1);
+                debugDisplayObjects.pathsLine.lineTo(cx1, cy1);
+                debugDisplayObjects.pathsLine.moveTo(x2, y2);
+                debugDisplayObjects.pathsLine.lineTo(cx2, cy2);
+                x1 = x2;
+                y1 = y2;
+            }
+        }
+        debugDisplayObjects.pathsCurve.stroke({ width: lineWidth, color: this.pathsCurveColor });
+        debugDisplayObjects.pathsLine.stroke({ width: lineWidth, color: this.pathsLineColor });
+    }
+    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({ textureSource: true, children: true, texture: true });
+        this.registeredSpines.delete(spine);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SpineDebugRenderer.js","sourceRoot":"","sources":["../src/SpineDebugRenderer.ts"],"names":[],"mappings":"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","sourcesContent":["/** ****************************************************************************\n * Spine Runtimes License Agreement\n * Last updated July 28, 2023. Replaces all prior versions.\n *\n * Copyright (c) 2013-2023, 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 or\n * 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 THE\n * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *****************************************************************************/\n\nimport { Container, Graphics, Text } from 'pixi.js';\nimport { Spine } from './Spine';\nimport {\n\tClippingAttachment,\n\tMeshAttachment,\n\tPathAttachment,\n\tRegionAttachment,\n\tSkeletonBounds\n} from '@esotericsoftware/spine-core';\n\nimport type { AnimationStateListener } from '@esotericsoftware/spine-core';\n\n/**\n * Make a class that extends from this interface to create your own debug renderer.\n * @public\n */\nexport interface ISpineDebugRenderer {\n\t/**\n\t * This will be called every frame, after the spine has been updated.\n\t */\n\trenderDebug: (spine: Spine) => void;\n\n\t/**\n\t *  This is called when the `spine.debug` object is set to null or when the spine is destroyed.\n\t */\n\tunregisterSpine: (spine: Spine) => void;\n\n\t/**\n\t * This is called when the `spine.debug` object is set to a new instance of a debug renderer.\n\t */\n\tregisterSpine: (spine: Spine) => void;\n}\n\ntype DebugDisplayObjects = {\n\tbones: Container;\n\tskeletonXY: Graphics;\n\tregionAttachmentsShape: Graphics;\n\tmeshTrianglesLine: Graphics;\n\tmeshHullLine: Graphics;\n\tclippingPolygon: Graphics;\n\tboundingBoxesRect: Graphics;\n\tboundingBoxesCircle: Graphics;\n\tboundingBoxesPolygon: Graphics;\n\tpathsCurve: Graphics;\n\tpathsLine: Graphics;\n\tparentDebugContainer: Container;\n\teventText: Container;\n\teventCallback: AnimationStateListener;\n};\n\n/**\n * This is a debug renderer that uses PixiJS Graphics under the hood.\n * @public\n */\nexport class SpineDebugRenderer implements ISpineDebugRenderer {\n\tprivate readonly registeredSpines: Map<Spine, DebugDisplayObjects> = new Map();\n\n\tpublic drawMeshHull = true;\n\tpublic drawMeshTriangles = true;\n\tpublic drawBones = true;\n\tpublic drawPaths = true;\n\tpublic drawBoundingBoxes = true;\n\tpublic drawClipping = true;\n\tpublic drawRegionAttachments = true;\n\tpublic drawEvents = true;\n\n\tpublic lineWidth = 1;\n\tpublic regionAttachmentsColor = 0x0078ff;\n\tpublic meshHullColor = 0x0078ff;\n\tpublic meshTrianglesColor = 0xffcc00;\n\tpublic clippingPolygonColor = 0xff00ff;\n\tpublic boundingBoxesRectColor = 0x00ff00;\n\tpublic boundingBoxesPolygonColor = 0x00ff00;\n\tpublic boundingBoxesCircleColor = 0x00ff00;\n\tpublic pathsCurveColor = 0xff0000;\n\tpublic pathsLineColor = 0xff00ff;\n\tpublic skeletonXYColor = 0xff0000;\n\tpublic bonesColor = 0x00eecc;\n\tpublic eventFontSize = 24;\n\tpublic eventFontColor = 0x0;\n\n\t/**\n\t * The debug is attached by force to each spine object.\n\t * So we need to create it inside the spine when we get the first update\n\t */\n\tpublic registerSpine (spine: Spine): void {\n\t\tif (this.registeredSpines.has(spine)) {\n\t\t\tconsole.warn('SpineDebugRenderer.registerSpine() - this spine is already registered!', spine);\n\n\t\t\treturn;\n\t\t}\n\t\tconst debugDisplayObjects: DebugDisplayObjects = {\n\t\t\tparentDebugContainer: new Container(),\n\t\t\tbones: new Container(),\n\t\t\tskeletonXY: new Graphics(),\n\t\t\tregionAttachmentsShape: new Graphics(),\n\t\t\tmeshTrianglesLine: new Graphics(),\n\t\t\tmeshHullLine: new Graphics(),\n\t\t\tclippingPolygon: new Graphics(),\n\t\t\tboundingBoxesRect: new Graphics(),\n\t\t\tboundingBoxesCircle: new Graphics(),\n\t\t\tboundingBoxesPolygon: new Graphics(),\n\t\t\tpathsCurve: new Graphics(),\n\t\t\tpathsLine: new Graphics(),\n\t\t\teventText: new Container(),\n\t\t\teventCallback: {\n\t\t\t\tevent: (_, event) => {\n\t\t\t\t\tif (this.drawEvents) {\n\t\t\t\t\t\tconst scale = Math.abs(spine.scale.x || spine.scale.y || 1);\n\t\t\t\t\t\tconst text = new Text({\n\t\t\t\t\t\t\ttext: event.data.name,\n\t\t\t\t\t\t\tstyle: {\n\t\t\t\t\t\t\t\tfontSize: this.eventFontSize / scale,\n\t\t\t\t\t\t\t\tfill: this.eventFontColor,\n\t\t\t\t\t\t\t\tfontFamily: 'monospace'\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\ttext.scale.x = Math.sign(spine.scale.x);\n\t\t\t\t\t\ttext.anchor.set(0.5);\n\t\t\t\t\t\tdebugDisplayObjects.eventText.addChild(text);\n\t\t\t\t\t\tsetTimeout(() => {\n\t\t\t\t\t\t\tif (!text.destroyed) {\n\t\t\t\t\t\t\t\ttext.destroy();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}, 250);\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t},\n\t\t};\n\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.bones);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.skeletonXY);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.regionAttachmentsShape);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.meshTrianglesLine);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.meshHullLine);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.clippingPolygon);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.boundingBoxesRect);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.boundingBoxesCircle);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.boundingBoxesPolygon);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.pathsCurve);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.pathsLine);\n\t\tdebugDisplayObjects.parentDebugContainer.addChild(debugDisplayObjects.eventText);\n\n\t\t(debugDisplayObjects.parentDebugContainer as any).zIndex = 9999999;\n\n\t\t// Disable screen reader and mouse input on debug objects.\n\t\t(debugDisplayObjects.parentDebugContainer as any).accessibleChildren = false;\n\t\t(debugDisplayObjects.parentDebugContainer as any).eventMode = 'none';\n\t\t(debugDisplayObjects.parentDebugContainer as any).interactiveChildren = false;\n\n\t\tspine.addChild(debugDisplayObjects.parentDebugContainer);\n\n\t\tspine.state.addListener(debugDisplayObjects.eventCallback);\n\n\t\tthis.registeredSpines.set(spine, debugDisplayObjects);\n\t}\n\n\tpublic renderDebug (spine: Spine): void {\n\t\tif (!this.registeredSpines.has(spine)) {\n\t\t\t// This should never happen. Spines are registered when you assign spine.debug\n\t\t\tthis.registerSpine(spine);\n\t\t}\n\n\t\tconst debugDisplayObjects = this.registeredSpines.get(spine);\n\n\t\tif (!debugDisplayObjects) {\n\t\t\treturn;\n\t\t}\n\t\tspine.addChild(debugDisplayObjects.parentDebugContainer);\n\n\t\tdebugDisplayObjects.skeletonXY.clear();\n\t\tdebugDisplayObjects.regionAttachmentsShape.clear();\n\t\tdebugDisplayObjects.meshTrianglesLine.clear();\n\t\tdebugDisplayObjects.meshHullLine.clear();\n\t\tdebugDisplayObjects.clippingPolygon.clear();\n\t\tdebugDisplayObjects.boundingBoxesRect.clear();\n\t\tdebugDisplayObjects.boundingBoxesCircle.clear();\n\t\tdebugDisplayObjects.boundingBoxesPolygon.clear();\n\t\tdebugDisplayObjects.pathsCurve.clear();\n\t\tdebugDisplayObjects.pathsLine.clear();\n\n\t\tfor (let len = debugDisplayObjects.bones.children.length; len > 0; len--) {\n\t\t\tdebugDisplayObjects.bones.children[len - 1].destroy({ children: true, texture: true, textureSource: true });\n\t\t}\n\n\t\tconst scale = Math.abs(spine.scale.x || spine.scale.y || 1);\n\t\tconst lineWidth = this.lineWidth / scale;\n\n\t\tif (this.drawBones) {\n\t\t\tthis.drawBonesFunc(spine, debugDisplayObjects, lineWidth, scale);\n\t\t}\n\n\t\tif (this.drawPaths) {\n\t\t\tthis.drawPathsFunc(spine, debugDisplayObjects, lineWidth);\n\t\t}\n\n\t\tif (this.drawBoundingBoxes) {\n\t\t\tthis.drawBoundingBoxesFunc(spine, debugDisplayObjects, lineWidth);\n\t\t}\n\n\t\tif (this.drawClipping) {\n\t\t\tthis.drawClippingFunc(spine, debugDisplayObjects, lineWidth);\n\t\t}\n\n\t\tif (this.drawMeshHull || this.drawMeshTriangles) {\n\t\t\tthis.drawMeshHullAndMeshTriangles(spine, debugDisplayObjects, lineWidth);\n\t\t}\n\n\t\tif (this.drawRegionAttachments) {\n\t\t\tthis.drawRegionAttachmentsFunc(spine, debugDisplayObjects, lineWidth);\n\t\t}\n\n\t\tif (this.drawEvents) {\n\t\t\tfor (const child of debugDisplayObjects.eventText.children) {\n\t\t\t\tchild.alpha -= 0.05;\n\t\t\t\tchild.y -= 2;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate drawBonesFunc (spine: Spine, debugDisplayObjects: DebugDisplayObjects, lineWidth: number, scale: number): void {\n\t\tconst skeleton = spine.skeleton;\n\t\tconst skeletonX = skeleton.x;\n\t\tconst skeletonY = skeleton.y;\n\t\tconst bones = skeleton.bones;\n\n\t\tdebugDisplayObjects.skeletonXY.strokeStyle = { width: lineWidth, color: this.skeletonXYColor };\n\n\t\tfor (let i = 0, len = bones.length; i < len; i++) {\n\t\t\tconst bone = bones[i];\n\t\t\tconst boneLen = bone.data.length;\n\t\t\tconst starX = skeletonX + bone.worldX;\n\t\t\tconst starY = skeletonY + bone.worldY;\n\t\t\tconst endX = skeletonX + (boneLen * bone.a) + bone.worldX;\n\t\t\tconst endY = skeletonY + (boneLen * bone.b) + bone.worldY;\n\n\t\t\tif (bone.data.name === 'root' || bone.data.parent === null) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst w = Math.abs(starX - endX);\n\t\t\tconst h = Math.abs(starY - endY);\n\t\t\t// a = w, // side length a\n\t\t\tconst a2 = Math.pow(w, 2); // square root of side length a\n\t\t\tconst b = h; // side length b\n\t\t\tconst b2 = Math.pow(h, 2); // square root of side length b\n\t\t\tconst c = Math.sqrt(a2 + b2); // side length c\n\t\t\tconst c2 = Math.pow(c, 2); // square root of side length c\n\t\t\tconst rad = Math.PI / 180;\n\t\t\t// A = Math.acos([a2 + c2 - b2] / [2 * a * c]) || 0, // Angle A\n\t\t\t// C = Math.acos([a2 + b2 - c2] / [2 * a * b]) || 0, // C angle\n\t\t\tconst B = Math.acos((c2 + b2 - a2) / (2 * b * c)) || 0; // angle of corner B\n\n\t\t\tif (c === 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst gp = new Graphics();\n\n\t\t\tdebugDisplayObjects.bones.addChild(gp);\n\n\t\t\t// draw bone\n\t\t\tconst refRation = c / 50 / scale;\n\n\t\t\tgp.context\n\t\t\t\t.poly([0, 0, 0 - refRation, c - (refRation * 3), 0, c - refRation, 0 + refRation, c - (refRation * 3)])\n\t\t\t\t.fill(this.bonesColor);\n\t\t\tgp.x = starX;\n\t\t\tgp.y = starY;\n\t\t\tgp.pivot.y = c;\n\n\t\t\t// Calculate bone rotation angle\n\t\t\tlet rotation = 0;\n\n\t\t\tif (starX < endX && starY < endY) {\n\t\t\t\t// bottom right\n\t\t\t\trotation = -B + (180 * rad);\n\t\t\t}\n\t\t\telse if (starX > endX && starY < endY) {\n\t\t\t\t// bottom left\n\t\t\t\trotation = (180 * rad) + B;\n\t\t\t}\n\t\t\telse if (starX > endX && starY > endY) {\n\t\t\t\t// top left\n\t\t\t\trotation = -B;\n\t\t\t}\n\t\t\telse if (starX < endX && starY > endY) {\n\t\t\t\t// bottom left\n\t\t\t\trotation = B;\n\t\t\t}\n\t\t\telse if (starY === endY && starX < endX) {\n\t\t\t\t// To the right\n\t\t\t\trotation = 90 * rad;\n\t\t\t}\n\t\t\telse if (starY === endY && starX > endX) {\n\t\t\t\t// go left\n\t\t\t\trotation = -90 * rad;\n\t\t\t}\n\t\t\telse if (starX === endX && starY < endY) {\n\t\t\t\t// down\n\t\t\t\trotation = 180 * rad;\n\t\t\t}\n\t\t\telse if (starX === endX && starY > endY) {\n\t\t\t\t// up\n\t\t\t\trotation = 0;\n\t\t\t}\n\t\t\tgp.rotation = rotation;\n\n\t\t\t// Draw the starting rotation point of the bone\n\t\t\tgp.circle(0, c, refRation * 1.2)\n\t\t\t\t.fill({ color: 0x000000, alpha: 0.6 })\n\t\t\t\t.stroke({ width: lineWidth + refRation / 2.4, color: this.bonesColor });\n\t\t}\n\n\t\t// Draw the skeleton starting point \"X\" form\n\t\tconst startDotSize = lineWidth * 3;\n\n\t\tdebugDisplayObjects.skeletonXY.context\n\t\t\t.moveTo(skeletonX - startDotSize, skeletonY - startDotSize)\n\t\t\t.lineTo(skeletonX + startDotSize, skeletonY + startDotSize)\n\t\t\t.moveTo(skeletonX + startDotSize, skeletonY - startDotSize)\n\t\t\t.lineTo(skeletonX - startDotSize, skeletonY + startDotSize)\n\t\t\t.stroke();\n\t}\n\n\tprivate drawRegionAttachmentsFunc (spine: Spine, debugDisplayObjects: DebugDisplayObjects, lineWidth: number): void {\n\t\tconst skeleton = spine.skeleton;\n\t\tconst slots = skeleton.slots;\n\n\t\tfor (let i = 0, len = slots.length; i < len; i++) {\n\t\t\tconst slot = slots[i];\n\t\t\tconst attachment = slot.getAttachment();\n\n\t\t\tif (attachment === null || !(attachment instanceof RegionAttachment)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst regionAttachment = attachment;\n\n\t\t\tconst vertices = new Float32Array(8);\n\n\t\t\tregionAttachment.computeWorldVertices(slot, vertices, 0, 2);\n\n\t\t\tdebugDisplayObjects.regionAttachmentsShape.poly(Array.from(vertices.slice(0, 8)));\n\t\t}\n\n\t\tdebugDisplayObjects.regionAttachmentsShape.stroke({\n\t\t\tcolor: this.regionAttachmentsColor,\n\t\t\twidth: lineWidth\n\t\t});\n\t}\n\n\tprivate drawMeshHullAndMeshTriangles (spine: Spine, debugDisplayObjects: DebugDisplayObjects, lineWidth: number): void {\n\t\tconst skeleton = spine.skeleton;\n\t\tconst slots = skeleton.slots;\n\n\t\tfor (let i = 0, len = slots.length; i < len; i++) {\n\t\t\tconst slot = slots[i];\n\n\t\t\tif (!slot.bone.active) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst attachment = slot.getAttachment();\n\n\t\t\tif (attachment === null || !(attachment instanceof MeshAttachment)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst meshAttachment = attachment;\n\n\t\t\tconst vertices = new Float32Array(meshAttachment.worldVerticesLength);\n\t\t\tconst triangles = meshAttachment.triangles;\n\t\t\tlet hullLength = meshAttachment.hullLength;\n\n\t\t\tmeshAttachment.computeWorldVertices(slot, 0, meshAttachment.worldVerticesLength, vertices, 0, 2);\n\t\t\t// draw the skinned mesh (triangle)\n\t\t\tif (this.drawMeshTriangles) {\n\t\t\t\tfor (let i = 0, len = triangles.length; i < len; i += 3) {\n\t\t\t\t\tconst v1 = triangles[i] * 2;\n\t\t\t\t\tconst v2 = triangles[i + 1] * 2;\n\t\t\t\t\tconst v3 = triangles[i + 2] * 2;\n\n\t\t\t\t\tdebugDisplayObjects.meshTrianglesLine.context\n\t\t\t\t\t\t.moveTo(vertices[v1], vertices[v1 + 1])\n\t\t\t\t\t\t.lineTo(vertices[v2], vertices[v2 + 1])\n\t\t\t\t\t\t.lineTo(vertices[v3], vertices[v3 + 1]);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// draw skin border\n\t\t\tif (this.drawMeshHull && hullLength > 0) {\n\t\t\t\thullLength = (hullLength >> 1) * 2;\n\t\t\t\tlet lastX = vertices[hullLength - 2];\n\t\t\t\tlet lastY = vertices[hullLength - 1];\n\n\t\t\t\tfor (let i = 0, len = hullLength; i < len; i += 2) {\n\t\t\t\t\tconst x = vertices[i];\n\t\t\t\t\tconst y = vertices[i + 1];\n\n\t\t\t\t\tdebugDisplayObjects.meshHullLine.context\n\t\t\t\t\t\t.moveTo(x, y)\n\t\t\t\t\t\t.lineTo(lastX, lastY);\n\t\t\t\t\tlastX = x;\n\t\t\t\t\tlastY = y;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tdebugDisplayObjects.meshHullLine.stroke({ width: lineWidth, color: this.meshHullColor });\n\t\tdebugDisplayObjects.meshTrianglesLine.stroke({ width: lineWidth, color: this.meshTrianglesColor });\n\t}\n\n\tdrawClippingFunc (spine: Spine, debugDisplayObjects: DebugDisplayObjects, lineWidth: number): void {\n\t\tconst skeleton = spine.skeleton;\n\t\tconst slots = skeleton.slots;\n\n\t\tfor (let i = 0, len = slots.length; i < len; i++) {\n\t\t\tconst slot = slots[i];\n\n\t\t\tif (!slot.bone.active) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst attachment = slot.getAttachment();\n\n\t\t\tif (attachment === null || !(attachment instanceof ClippingAttachment)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst clippingAttachment = attachment;\n\n\t\t\tconst nn = clippingAttachment.worldVerticesLength;\n\t\t\tconst world = new Float32Array(nn);\n\n\t\t\tclippingAttachment.computeWorldVertices(slot, 0, nn, world, 0, 2);\n\t\t\tdebugDisplayObjects.clippingPolygon.poly(Array.from(world));\n\t\t}\n\n\t\tdebugDisplayObjects.clippingPolygon.stroke({\n\t\t\twidth: lineWidth, color: this.clippingPolygonColor, alpha: 1\n\t\t});\n\t}\n\n\tdrawBoundingBoxesFunc (spine: Spine, debugDisplayObjects: DebugDisplayObjects, lineWidth: number): void {\n\t\t// draw the total outline of the bounding box\n\t\tconst bounds = new SkeletonBounds();\n\t\tbounds.update(spine.skeleton, true);\n\n\t\tif (bounds.minX !== Infinity) {\n\t\t\tdebugDisplayObjects.boundingBoxesRect\n\t\t\t\t.rect(bounds.minX, bounds.minY, bounds.getWidth(), bounds.getHeight())\n\t\t\t\t.stroke({ width: lineWidth, color: this.boundingBoxesRectColor });\n\t\t}\n\n\t\tconst polygons = bounds.polygons;\n\t\tconst drawPolygon = (polygonVertices: ArrayLike<number>, _offset: unknown, count: number): void => {\n\t\t\tif (count < 3) {\n\t\t\t\tthrow new Error('Polygon must contain at least 3 vertices');\n\t\t\t}\n\t\t\tconst paths: number[] = [];\n\t\t\tconst dotSize = lineWidth * 2;\n\n\t\t\tfor (let i = 0, len = polygonVertices.length; i < len; i += 2) {\n\t\t\t\tconst x1 = polygonVertices[i];\n\t\t\t\tconst y1 = polygonVertices[i + 1];\n\n\t\t\t\t// draw the bounding box node\n\t\t\t\tdebugDisplayObjects.boundingBoxesCircle.beginFill(this.boundingBoxesCircleColor);\n\t\t\t\tdebugDisplayObjects.boundingBoxesCircle.drawCircle(x1, y1, dotSize);\n\t\t\t\tdebugDisplayObjects.boundingBoxesCircle.fill(0);\n\n\t\t\t\tdebugDisplayObjects.boundingBoxesCircle\n\t\t\t\t\t.circle(x1, y1, dotSize)\n\t\t\t\t\t.fill({ color: this.boundingBoxesCircleColor })\n\n\t\t\t\tpaths.push(x1, y1);\n\t\t\t}\n\n\t\t\t// draw the bounding box area\n\t\t\tdebugDisplayObjects.boundingBoxesPolygon\n\t\t\t\t.poly(paths)\n\t\t\t\t.fill({\n\t\t\t\t\tcolor: this.boundingBoxesPolygonColor,\n\t\t\t\t\talpha: 0.1\n\t\t\t\t})\n\t\t\t\t.stroke({\n\t\t\t\t\twidth: lineWidth,\n\t\t\t\t\tcolor: this.boundingBoxesPolygonColor\n\t\t\t\t});\n\t\t};\n\n\t\tfor (let i = 0, len = polygons.length; i < len; i++) {\n\t\t\tconst polygon = polygons[i];\n\n\t\t\tdrawPolygon(polygon, 0, polygon.length);\n\t\t}\n\t}\n\n\tprivate drawPathsFunc (spine: Spine, debugDisplayObjects: DebugDisplayObjects, lineWidth: number): void {\n\t\tconst skeleton = spine.skeleton;\n\t\tconst slots = skeleton.slots;\n\n\t\tfor (let i = 0, len = slots.length; i < len; i++) {\n\t\t\tconst slot = slots[i];\n\n\t\t\tif (!slot.bone.active) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst attachment = slot.getAttachment();\n\n\t\t\tif (attachment === null || !(attachment instanceof PathAttachment)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst pathAttachment = attachment;\n\t\t\tlet nn = pathAttachment.worldVerticesLength;\n\t\t\tconst world = new Float32Array(nn);\n\n\t\t\tpathAttachment.computeWorldVertices(slot, 0, nn, world, 0, 2);\n\t\t\tlet x1 = world[2];\n\t\t\tlet y1 = world[3];\n\t\t\tlet x2 = 0;\n\t\t\tlet y2 = 0;\n\n\t\t\tif (pathAttachment.closed) {\n\t\t\t\tconst cx1 = world[0];\n\t\t\t\tconst cy1 = world[1];\n\t\t\t\tconst cx2 = world[nn - 2];\n\t\t\t\tconst cy2 = world[nn - 1];\n\n\t\t\t\tx2 = world[nn - 4];\n\t\t\t\ty2 = world[nn - 3];\n\n\t\t\t\t// curve\n\t\t\t\tdebugDisplayObjects.pathsCurve.moveTo(x1, y1);\n\t\t\t\tdebugDisplayObjects.pathsCurve.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);\n\n\t\t\t\t// handle\n\t\t\t\tdebugDisplayObjects.pathsLine.moveTo(x1, y1);\n\t\t\t\tdebugDisplayObjects.pathsLine.lineTo(cx1, cy1);\n\t\t\t\tdebugDisplayObjects.pathsLine.moveTo(x2, y2);\n\t\t\t\tdebugDisplayObjects.pathsLine.lineTo(cx2, cy2);\n\t\t\t}\n\t\t\tnn -= 4;\n\t\t\tfor (let ii = 4; ii < nn; ii += 6) {\n\t\t\t\tconst cx1 = world[ii];\n\t\t\t\tconst cy1 = world[ii + 1];\n\t\t\t\tconst cx2 = world[ii + 2];\n\t\t\t\tconst cy2 = world[ii + 3];\n\n\t\t\t\tx2 = world[ii + 4];\n\t\t\t\ty2 = world[ii + 5];\n\t\t\t\t// curve\n\t\t\t\tdebugDisplayObjects.pathsCurve.moveTo(x1, y1);\n\t\t\t\tdebugDisplayObjects.pathsCurve.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);\n\n\t\t\t\t// handle\n\t\t\t\tdebugDisplayObjects.pathsLine.moveTo(x1, y1);\n\t\t\t\tdebugDisplayObjects.pathsLine.lineTo(cx1, cy1);\n\t\t\t\tdebugDisplayObjects.pathsLine.moveTo(x2, y2);\n\t\t\t\tdebugDisplayObjects.pathsLine.lineTo(cx2, cy2);\n\t\t\t\tx1 = x2;\n\t\t\t\ty1 = y2;\n\t\t\t}\n\t\t}\n\n\t\tdebugDisplayObjects.pathsCurve.stroke({ width: lineWidth, color: this.pathsCurveColor });\n\t\tdebugDisplayObjects.pathsLine.stroke({ width: lineWidth, color: this.pathsLineColor });\n\t}\n\n\tpublic unregisterSpine (spine: Spine): void {\n\t\tif (!this.registeredSpines.has(spine)) {\n\t\t\tconsole.warn('SpineDebugRenderer.unregisterSpine() - spine is not registered, can\\'t unregister!', spine);\n\t\t}\n\t\tconst debugDisplayObjects = this.registeredSpines.get(spine);\n\n\t\tif (!debugDisplayObjects) {\n\t\t\treturn;\n\t\t}\n\n\t\tspine.state.removeListener(debugDisplayObjects.eventCallback);\n\n\t\tdebugDisplayObjects.parentDebugContainer.destroy({ textureSource: true, children: true, texture: true });\n\t\tthis.registeredSpines.delete(spine);\n\t}\n}\n"]}

package/dist/SpinePipe.d.ts

@@ -0,0 +1,45 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, 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 { ExtensionType, InstructionSet, type Renderer, type RenderPipe } from 'pixi.js';
+import { Spine } from './Spine';
+export declare class SpinePipe implements RenderPipe<Spine> {
+    /** @ignore */
+    static extension: {
+        readonly type: readonly [ExtensionType.WebGLPipes, ExtensionType.WebGPUPipes, ExtensionType.CanvasPipes];
+        readonly name: "spine";
+    };
+    renderer: Renderer;
+    private gpuSpineData;
+    constructor(renderer: Renderer);
+    validateRenderable(spine: Spine): boolean;
+    addRenderable(spine: Spine, instructionSet: InstructionSet): void;
+    updateRenderable(spine: Spine): void;
+    destroyRenderable(spine: Spine): void;
+    destroy(): void;
+}