@esotericsoftware/spine-core 4.2.116 → 4.3.0

package/dist/BonePose.js

@@ -0,0 +1,426 @@
+/******************************************************************************
+ * 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 { Inherit } from "./BoneData.js";
+import { MathUtils } from "./Utils.js";
+/** The applied local pose and world transform for a bone. This is the {@link Bone.getPose} with constraints applied and the
+ * world transform computed by {@link Skeleton.updateWorldTransform} and {@link updateWorldTransform}.
+ *
+ * If the world transform is changed, call {@link updateLocalTransform} before using the local transform. The local
+ * transform may be needed by other code (eg to apply another constraint).
+ *
+ * After changing the world transform, call {@link updateWorldTransform} on every descendant bone. It may be more
+ * convenient to modify the local transform instead, then call {@link Skeleton.updateWorldTransform} to update the world
+ * transforms for all bones and apply constraints. */
+export class BonePose {
+    bone;
+    /** The local x translation. */
+    x = 0;
+    /** The local y translation. */
+    y = 0;
+    /** The local rotation in degrees, counter clockwise. */
+    rotation = 0;
+    /** The local scaleX. */
+    scaleX = 0;
+    /** The local scaleY. */
+    scaleY = 0;
+    /** The local shearX. */
+    shearX = 0;
+    /** The local shearY. */
+    shearY = 0;
+    inherit = Inherit.Normal;
+    /** The world transform `[a b][c d]` x-axis x component. */
+    a = 0;
+    /** The world transform `[a b][c d]` y-axis x component. */
+    b = 0;
+    /** The world transform `[a b][c d]` x-axis y component. */
+    c = 0;
+    /** The world transform `[a b][c d]` y-axis y component. */
+    d = 0;
+    /** The world X position. If changed, {@link updateLocalTransform} should be called. */
+    worldY = 0;
+    /** The world Y position. If changed, {@link updateLocalTransform} should be called. */
+    worldX = 0;
+    world = 0;
+    local = 0;
+    set(pose) {
+        if (pose == null)
+            throw new Error("pose cannot be null.");
+        this.x = pose.x;
+        this.y = pose.y;
+        this.rotation = pose.rotation;
+        this.scaleX = pose.scaleX;
+        this.scaleY = pose.scaleY;
+        this.shearX = pose.shearX;
+        this.shearY = pose.shearY;
+        this.inherit = pose.inherit;
+    }
+    setPosition(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    setScale(scaleOrX, scaleY) {
+        this.scaleX = scaleOrX;
+        this.scaleY = scaleY === undefined ? scaleOrX : scaleY;
+    }
+    /** Determines how parent world transforms affect this bone. */
+    getInherit() {
+        return this.inherit;
+    }
+    setInherit(inherit) {
+        if (inherit == null)
+            throw new Error("inherit cannot be null.");
+        this.inherit = inherit;
+    }
+    /** Called by {@link Skeleton.updateCache} to compute the world transform, if needed. */
+    update(skeleton, physics) {
+        if (this.world !== skeleton._update)
+            this.updateWorldTransform(skeleton);
+    }
+    /** Computes the world transform using the parent bone's world transform and this applied local pose. Child bones are not
+     * updated.
+     *
+     * See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
+     * Runtimes Guide. */
+    updateWorldTransform(skeleton) {
+        if (this.local === skeleton._update)
+            this.updateLocalTransform(skeleton);
+        else
+            this.world = skeleton._update;
+        const rotation = this.rotation;
+        const scaleX = this.scaleX;
+        const scaleY = this.scaleY;
+        const shearX = this.shearX;
+        const shearY = this.shearY;
+        if (!this.bone.parent) { // Root bone.
+            const sx = skeleton.scaleX, sy = skeleton.scaleY;
+            const rx = (rotation + shearX) * MathUtils.degRad;
+            const ry = (rotation + 90 + shearY) * MathUtils.degRad;
+            this.a = Math.cos(rx) * scaleX * sx;
+            this.b = Math.cos(ry) * scaleY * sx;
+            this.c = Math.sin(rx) * scaleX * sy;
+            this.d = Math.sin(ry) * scaleY * sy;
+            this.worldX = this.x * sx + skeleton.x;
+            this.worldY = this.y * sy + skeleton.y;
+            return;
+        }
+        const parent = this.bone.parent.appliedPose;
+        let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
+        this.worldX = pa * this.x + pb * this.y + parent.worldX;
+        this.worldY = pc * this.x + pd * this.y + parent.worldY;
+        switch (this.inherit) {
+            case Inherit.Normal: {
+                const rx = (rotation + shearX) * MathUtils.degRad;
+                const ry = (rotation + 90 + shearY) * MathUtils.degRad;
+                const la = Math.cos(rx) * scaleX;
+                const lb = Math.cos(ry) * scaleY;
+                const lc = Math.sin(rx) * scaleX;
+                const ld = Math.sin(ry) * scaleY;
+                this.a = pa * la + pb * lc;
+                this.b = pa * lb + pb * ld;
+                this.c = pc * la + pd * lc;
+                this.d = pc * lb + pd * ld;
+                return;
+            }
+            case Inherit.OnlyTranslation: {
+                const rx = (rotation + shearX) * MathUtils.degRad;
+                const ry = (rotation + 90 + shearY) * MathUtils.degRad;
+                this.a = Math.cos(rx) * scaleX;
+                this.b = Math.cos(ry) * scaleY;
+                this.c = Math.sin(rx) * scaleX;
+                this.d = Math.sin(ry) * scaleY;
+                break;
+            }
+            case Inherit.NoRotationOrReflection: {
+                const sx = 1 / skeleton.scaleX, sy = 1 / skeleton.scaleY;
+                pa *= sx;
+                pc *= sy;
+                let s = pa * pa + pc * pc;
+                let prx = 0;
+                if (s > 0.0001) {
+                    s = Math.abs(pa * pd * sy - pb * sx * pc) / s;
+                    pb = pc * s;
+                    pd = pa * s;
+                    prx = MathUtils.atan2Deg(pc, pa);
+                }
+                else {
+                    pa = 0;
+                    pc = 0;
+                    prx = 90 - MathUtils.atan2Deg(pd, pb);
+                }
+                const rx = (rotation + shearX - prx) * MathUtils.degRad;
+                const ry = (rotation + shearY - prx + 90) * MathUtils.degRad;
+                const la = Math.cos(rx) * scaleX;
+                const lb = Math.cos(ry) * scaleY;
+                const lc = Math.sin(rx) * scaleX;
+                const ld = Math.sin(ry) * scaleY;
+                this.a = pa * la - pb * lc;
+                this.b = pa * lb - pb * ld;
+                this.c = pc * la + pd * lc;
+                this.d = pc * lb + pd * ld;
+                break;
+            }
+            case Inherit.NoScale:
+            case Inherit.NoScaleOrReflection: {
+                let r = rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
+                let za = (pa * cos + pb * sin) / skeleton.scaleX;
+                let zc = (pc * cos + pd * sin) / skeleton.scaleY;
+                let s = Math.sqrt(za * za + zc * zc);
+                if (s > 0.00001)
+                    s = 1 / s;
+                za *= s;
+                zc *= s;
+                s = Math.sqrt(za * za + zc * zc);
+                if (this.inherit === Inherit.NoScale && (pa * pd - pb * pc < 0) !== (skeleton.scaleX < 0 !== skeleton.scaleY < 0))
+                    s = -s;
+                r = Math.PI / 2 + Math.atan2(zc, za);
+                const zb = Math.cos(r) * s;
+                const zd = Math.sin(r) * s;
+                const rx = shearX * MathUtils.degRad;
+                const ry = (90 + shearY) * MathUtils.degRad;
+                const la = Math.cos(rx) * scaleX;
+                const lb = Math.cos(ry) * scaleY;
+                const lc = Math.sin(rx) * scaleX;
+                const ld = Math.sin(ry) * scaleY;
+                this.a = za * la + zb * lc;
+                this.b = za * lb + zb * ld;
+                this.c = zc * la + zd * lc;
+                this.d = zc * lb + zd * ld;
+                break;
+            }
+        }
+        this.a *= skeleton.scaleX;
+        this.b *= skeleton.scaleX;
+        this.c *= skeleton.scaleY;
+        this.d *= skeleton.scaleY;
+    }
+    /** Computes the local transform values from the world transform.
+     *
+     * If the world transform is modified (by a constraint, {@link rotateWorld}, etc) then this method should be called so
+     * the local transform matches the world transform. The local transform may be needed by other code (eg to apply another
+     * constraint).
+     *
+     * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The local transform after
+     * calling this method is equivalent to the local transform used to compute the world transform, but may not be identical. */
+    updateLocalTransform(skeleton) {
+        this.local = 0;
+        this.world = skeleton._update;
+        if (!this.bone.parent) {
+            this.x = this.worldX - skeleton.x;
+            this.y = this.worldY - skeleton.y;
+            const a = this.a, b = this.b, c = this.c, d = this.d;
+            this.rotation = MathUtils.atan2Deg(c, a);
+            this.scaleX = Math.sqrt(a * a + c * c);
+            this.scaleY = Math.sqrt(b * b + d * d);
+            this.shearX = 0;
+            this.shearY = MathUtils.atan2Deg(a * b + c * d, a * d - b * c);
+            return;
+        }
+        const parent = this.bone.parent.appliedPose;
+        let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
+        let pid = 1 / (pa * pd - pb * pc);
+        let ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid;
+        const dx = this.worldX - parent.worldX, dy = this.worldY - parent.worldY;
+        this.x = (dx * ia - dy * ib);
+        this.y = (dy * id - dx * ic);
+        let ra, rb, rc, rd;
+        if (this.inherit === Inherit.OnlyTranslation) {
+            ra = this.a;
+            rb = this.b;
+            rc = this.c;
+            rd = this.d;
+        }
+        else {
+            switch (this.inherit) {
+                case Inherit.NoRotationOrReflection: {
+                    const s = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
+                    pb = -pc * skeleton.scaleX * s / skeleton.scaleY;
+                    pd = pa * skeleton.scaleY * s / skeleton.scaleX;
+                    pid = 1 / (pa * pd - pb * pc);
+                    ia = pd * pid;
+                    ib = pb * pid;
+                    break;
+                }
+                case Inherit.NoScale:
+                case Inherit.NoScaleOrReflection: {
+                    let r = this.rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
+                    pa = (pa * cos + pb * sin) / skeleton.scaleX;
+                    pc = (pc * cos + pd * sin) / skeleton.scaleY;
+                    let s = Math.sqrt(pa * pa + pc * pc);
+                    if (s > 0.00001)
+                        s = 1 / s;
+                    pa *= s;
+                    pc *= s;
+                    s = Math.sqrt(pa * pa + pc * pc);
+                    if (this.inherit === Inherit.NoScale && pid < 0 !== (skeleton.scaleX < 0 !== skeleton.scaleY < 0))
+                        s = -s;
+                    r = MathUtils.PI / 2 + Math.atan2(pc, pa);
+                    pb = Math.cos(r) * s;
+                    pd = Math.sin(r) * s;
+                    pid = 1 / (pa * pd - pb * pc);
+                    ia = pd * pid;
+                    ib = pb * pid;
+                    ic = pc * pid;
+                    id = pa * pid;
+                }
+            }
+            ra = ia * this.a - ib * this.c;
+            rb = ia * this.b - ib * this.d;
+            rc = id * this.c - ic * this.a;
+            rd = id * this.d - ic * this.b;
+        }
+        this.shearX = 0;
+        this.scaleX = Math.sqrt(ra * ra + rc * rc);
+        if (this.scaleX > 0.0001) {
+            const det = ra * rd - rb * rc;
+            this.scaleY = det / this.scaleX;
+            this.shearY = -MathUtils.atan2Deg(ra * rb + rc * rd, det);
+            this.rotation = MathUtils.atan2Deg(rc, ra);
+        }
+        else {
+            this.scaleX = 0;
+            this.scaleY = Math.sqrt(rb * rb + rd * rd);
+            this.shearY = 0;
+            this.rotation = 90 - MathUtils.atan2Deg(rd, rb);
+        }
+    }
+    /** If the world transform has been modified by constraints and the local transform no longer matches,
+     * {@link updateLocalTransform} is called. Call this after {@link Skeleton.updateWorldTransform} before
+     * using the applied local transform. */
+    validateLocalTransform(skeleton) {
+        if (this.local === skeleton._update)
+            this.updateLocalTransform(skeleton);
+    }
+    modifyLocal(skeleton) {
+        if (this.local === skeleton._update)
+            this.updateLocalTransform(skeleton);
+        this.world = 0;
+        this.resetWorld(skeleton._update);
+    }
+    modifyWorld(update) {
+        this.local = update;
+        this.world = update;
+        this.resetWorld(update);
+    }
+    resetWorld(update) {
+        const children = this.bone.children;
+        for (let i = 0, n = children.length; i < n; i++) {
+            const child = children[i].appliedPose;
+            if (child.world === update) {
+                child.world = 0;
+                child.local = 0;
+                child.resetWorld(update);
+            }
+        }
+    }
+    /** The world rotation for the X axis, calculated using {@link a} and {@link c}. This is the direction the bone is
+     * pointing. */
+    getWorldRotationX() {
+        return MathUtils.atan2Deg(this.c, this.a);
+    }
+    /** The world rotation for the Y axis, calculated using {@link b} and {@link d}. */
+    getWorldRotationY() {
+        return MathUtils.atan2Deg(this.d, this.b);
+    }
+    /** The magnitude (always positive) of the world scale X, calculated using {@link a} and {@link c}. */
+    getWorldScaleX() {
+        return Math.sqrt(this.a * this.a + this.c * this.c);
+    }
+    /** The magnitude (always positive) of the world scale Y, calculated using {@link b} and {@link d}. */
+    getWorldScaleY() {
+        return Math.sqrt(this.b * this.b + this.d * this.d);
+    }
+    // public Matrix3 getWorldTransform (Matrix3 worldTransform) {
+    // 	if (worldTransform == null) throw new IllegalArgumentException("worldTransform cannot be null.");
+    // 	float[] val = worldTransform.val;
+    // 	val[M00] = a;
+    // 	val[M01] = b;
+    // 	val[M10] = c;
+    // 	val[M11] = d;
+    // 	val[M02] = worldX;
+    // 	val[M12] = worldY;
+    // 	val[M20] = 0;
+    // 	val[M21] = 0;
+    // 	val[M22] = 1;
+    // 	return worldTransform;
+    // }
+    /** Transforms a point from world coordinates to the bone's local coordinates. */
+    worldToLocal(world) {
+        if (world == null)
+            throw new Error("world cannot be null.");
+        const det = this.a * this.d - this.b * this.c;
+        const x = world.x - this.worldX, y = world.y - this.worldY;
+        world.x = (x * this.d - y * this.b) / det;
+        world.y = (y * this.a - x * this.c) / det;
+        return world;
+    }
+    /** Transforms a point from the bone's local coordinates to world coordinates. */
+    localToWorld(local) {
+        if (local == null)
+            throw new Error("local cannot be null.");
+        const x = local.x, y = local.y;
+        local.x = x * this.a + y * this.b + this.worldX;
+        local.y = x * this.c + y * this.d + this.worldY;
+        return local;
+    }
+    /** Transforms a point from world coordinates to the parent bone's local coordinates. */
+    worldToParent(world) {
+        if (world == null)
+            throw new Error("world cannot be null.");
+        return this.bone.parent == null ? world : this.bone.parent.appliedPose.worldToLocal(world);
+    }
+    /** Transforms a point from the parent bone's coordinates to world coordinates. */
+    parentToWorld(world) {
+        if (world == null)
+            throw new Error("world cannot be null.");
+        return this.bone.parent == null ? world : this.bone.parent.appliedPose.localToWorld(world);
+    }
+    /** Transforms a world rotation to a local rotation. */
+    worldToLocalRotation(worldRotation) {
+        worldRotation *= MathUtils.degRad;
+        const sin = Math.sin(worldRotation), cos = Math.cos(worldRotation);
+        return MathUtils.atan2Deg(this.a * sin - this.c * cos, this.d * cos - this.b * sin) + this.rotation - this.shearX;
+    }
+    /** Transforms a local rotation to a world rotation. */
+    localToWorldRotation(localRotation) {
+        localRotation = (localRotation - this.rotation - this.shearX) * MathUtils.degRad;
+        const sin = Math.sin(localRotation), cos = Math.cos(localRotation);
+        return MathUtils.atan2Deg(cos * this.c + sin * this.d, cos * this.a + sin * this.b);
+    }
+    /** Rotates the world transform the specified amount. */
+    rotateWorld(degrees) {
+        degrees *= MathUtils.degRad;
+        const sin = Math.sin(degrees), cos = Math.cos(degrees);
+        const ra = this.a, rb = this.b;
+        this.a = cos * ra - sin * this.c;
+        this.b = cos * rb - sin * this.d;
+        this.c = sin * ra + cos * this.c;
+        this.d = sin * rb + cos * this.d;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BonePose.js","sourceRoot":"","sources":["../src/BonePose.ts"],"names":[],"mappings":"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","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 type { Bone } from \"./Bone.js\";\nimport { Inherit } from \"./BoneData.js\";\nimport type { Physics } from \"./Physics.js\";\nimport type { Pose } from \"./Pose.js\";\nimport type { Skeleton } from \"./Skeleton.js\";\nimport type { Update } from \"./Update.js\";\nimport { MathUtils, type Vector2 } from \"./Utils.js\";\n\n/** The applied local pose and world transform for a bone. This is the {@link Bone.getPose} with constraints applied and the\n * world transform computed by {@link Skeleton.updateWorldTransform} and {@link updateWorldTransform}.\n *\n * If the world transform is changed, call {@link updateLocalTransform} before using the local transform. The local\n * transform may be needed by other code (eg to apply another constraint).\n *\n * After changing the world transform, call {@link updateWorldTransform} on every descendant bone. It may be more\n * convenient to modify the local transform instead, then call {@link Skeleton.updateWorldTransform} to update the world\n * transforms for all bones and apply constraints. */\nexport class BonePose implements Pose<BonePose>, Update {\n\tbone!: Bone;\n\n\t/** The local x translation. */\n\tx = 0;\n\n\t/** The local y translation. */\n\ty = 0;\n\n\t/** The local rotation in degrees, counter clockwise. */\n\trotation = 0;\n\n\t/** The local scaleX. */\n\tscaleX = 0;\n\n\t/** The local scaleY. */\n\tscaleY = 0;\n\n\t/** The local shearX. */\n\tshearX = 0;\n\n\t/** The local shearY. */\n\tshearY = 0;\n\n\tinherit = Inherit.Normal;\n\n\t/** The world transform `[a b][c d]` x-axis x component. */\n\ta = 0;\n\n\t/** The world transform `[a b][c d]` y-axis x component. */\n\tb = 0;\n\n\t/** The world transform `[a b][c d]` x-axis y component. */\n\tc = 0;\n\n\t/** The world transform `[a b][c d]` y-axis y component. */\n\td = 0;\n\n\t/** The world X position. If changed, {@link updateLocalTransform} should be called. */\n\tworldY = 0;\n\n\t/** The world Y position. If changed, {@link updateLocalTransform} should be called. */\n\tworldX = 0;\n\n\tworld = 0;\n\tlocal = 0;\n\n\tset (pose: BonePose): void {\n\t\tif (pose == null) throw new Error(\"pose cannot be null.\");\n\t\tthis.x = pose.x;\n\t\tthis.y = pose.y;\n\t\tthis.rotation = pose.rotation;\n\t\tthis.scaleX = pose.scaleX;\n\t\tthis.scaleY = pose.scaleY;\n\t\tthis.shearX = pose.shearX;\n\t\tthis.shearY = pose.shearY;\n\t\tthis.inherit = pose.inherit;\n\t}\n\n\tsetPosition (x: number, y: number): void {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t}\n\n\tsetScale (scaleX: number, scaleY: number): void;\n\tsetScale (scale: number): void;\n\tsetScale (scaleOrX: number, scaleY?: number): void {\n\t\tthis.scaleX = scaleOrX;\n\t\tthis.scaleY = scaleY === undefined ? scaleOrX : scaleY;\n\t}\n\n\t/** Determines how parent world transforms affect this bone. */\n\tpublic getInherit (): Inherit {\n\t\treturn this.inherit;\n\t}\n\n\tpublic setInherit (inherit: Inherit): void {\n\t\tif (inherit == null) throw new Error(\"inherit cannot be null.\");\n\t\tthis.inherit = inherit;\n\t}\n\n\t/** Called by {@link Skeleton.updateCache} to compute the world transform, if needed. */\n\tpublic update (skeleton: Skeleton, physics: Physics): void {\n\t\tif (this.world !== skeleton._update) this.updateWorldTransform(skeleton);\n\t}\n\n\t/** Computes the world transform using the parent bone's world transform and this applied local pose. Child bones are not\n\t * updated.\n\t *\n\t * See <a href=\"https://esotericsoftware.com/spine-runtime-skeletons#World-transforms\">World transforms</a> in the Spine\n\t * Runtimes Guide. */\n\tupdateWorldTransform (skeleton: Skeleton): void {\n\t\tif (this.local === skeleton._update)\n\t\t\tthis.updateLocalTransform(skeleton);\n\t\telse\n\t\t\tthis.world = skeleton._update;\n\n\t\tconst rotation = this.rotation;\n\t\tconst scaleX = this.scaleX;\n\t\tconst scaleY = this.scaleY;\n\t\tconst shearX = this.shearX;\n\t\tconst shearY = this.shearY;\n\t\tif (!this.bone.parent) { // Root bone.\n\t\t\tconst sx = skeleton.scaleX, sy = skeleton.scaleY;\n\t\t\tconst rx = (rotation + shearX) * MathUtils.degRad;\n\t\t\tconst ry = (rotation + 90 + shearY) * MathUtils.degRad;\n\t\t\tthis.a = Math.cos(rx) * scaleX * sx;\n\t\t\tthis.b = Math.cos(ry) * scaleY * sx;\n\t\t\tthis.c = Math.sin(rx) * scaleX * sy;\n\t\t\tthis.d = Math.sin(ry) * scaleY * sy;\n\t\t\tthis.worldX = this.x * sx + skeleton.x;\n\t\t\tthis.worldY = this.y * sy + skeleton.y;\n\t\t\treturn;\n\t\t}\n\n\t\tconst parent = this.bone.parent.appliedPose;\n\t\tlet pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;\n\t\tthis.worldX = pa * this.x + pb * this.y + parent.worldX;\n\t\tthis.worldY = pc * this.x + pd * this.y + parent.worldY;\n\n\t\tswitch (this.inherit) {\n\t\t\tcase Inherit.Normal: {\n\t\t\t\tconst rx = (rotation + shearX) * MathUtils.degRad;\n\t\t\t\tconst ry = (rotation + 90 + shearY) * MathUtils.degRad;\n\t\t\t\tconst la = Math.cos(rx) * scaleX;\n\t\t\t\tconst lb = Math.cos(ry) * scaleY;\n\t\t\t\tconst lc = Math.sin(rx) * scaleX;\n\t\t\t\tconst ld = Math.sin(ry) * scaleY;\n\t\t\t\tthis.a = pa * la + pb * lc;\n\t\t\t\tthis.b = pa * lb + pb * ld;\n\t\t\t\tthis.c = pc * la + pd * lc;\n\t\t\t\tthis.d = pc * lb + pd * ld;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcase Inherit.OnlyTranslation: {\n\t\t\t\tconst rx = (rotation + shearX) * MathUtils.degRad;\n\t\t\t\tconst ry = (rotation + 90 + shearY) * MathUtils.degRad;\n\t\t\t\tthis.a = Math.cos(rx) * scaleX;\n\t\t\t\tthis.b = Math.cos(ry) * scaleY;\n\t\t\t\tthis.c = Math.sin(rx) * scaleX;\n\t\t\t\tthis.d = Math.sin(ry) * scaleY;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase Inherit.NoRotationOrReflection: {\n\t\t\t\tconst sx = 1 / skeleton.scaleX, sy = 1 / skeleton.scaleY;\n\t\t\t\tpa *= sx;\n\t\t\t\tpc *= sy;\n\t\t\t\tlet s = pa * pa + pc * pc;\n\t\t\t\tlet prx = 0;\n\t\t\t\tif (s > 0.0001) {\n\t\t\t\t\ts = Math.abs(pa * pd * sy - pb * sx * pc) / s;\n\t\t\t\t\tpb = pc * s;\n\t\t\t\t\tpd = pa * s;\n\t\t\t\t\tprx = MathUtils.atan2Deg(pc, pa);\n\t\t\t\t} else {\n\t\t\t\t\tpa = 0;\n\t\t\t\t\tpc = 0;\n\t\t\t\t\tprx = 90 - MathUtils.atan2Deg(pd, pb);\n\t\t\t\t}\n\t\t\t\tconst rx = (rotation + shearX - prx) * MathUtils.degRad;\n\t\t\t\tconst ry = (rotation + shearY - prx + 90) * MathUtils.degRad;\n\t\t\t\tconst la = Math.cos(rx) * scaleX;\n\t\t\t\tconst lb = Math.cos(ry) * scaleY;\n\t\t\t\tconst lc = Math.sin(rx) * scaleX;\n\t\t\t\tconst ld = Math.sin(ry) * scaleY;\n\t\t\t\tthis.a = pa * la - pb * lc;\n\t\t\t\tthis.b = pa * lb - pb * ld;\n\t\t\t\tthis.c = pc * la + pd * lc;\n\t\t\t\tthis.d = pc * lb + pd * ld;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase Inherit.NoScale:\n\t\t\tcase Inherit.NoScaleOrReflection: {\n\t\t\t\tlet r = rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);\n\t\t\t\tlet za = (pa * cos + pb * sin) / skeleton.scaleX;\n\t\t\t\tlet zc = (pc * cos + pd * sin) / skeleton.scaleY;\n\t\t\t\tlet s = Math.sqrt(za * za + zc * zc);\n\t\t\t\tif (s > 0.00001) s = 1 / s;\n\t\t\t\tza *= s;\n\t\t\t\tzc *= s;\n\t\t\t\ts = Math.sqrt(za * za + zc * zc);\n\t\t\t\tif (this.inherit === Inherit.NoScale && (pa * pd - pb * pc < 0) !== (skeleton.scaleX < 0 !== skeleton.scaleY < 0)) s = -s;\n\t\t\t\tr = Math.PI / 2 + Math.atan2(zc, za);\n\t\t\t\tconst zb = Math.cos(r) * s;\n\t\t\t\tconst zd = Math.sin(r) * s;\n\t\t\t\tconst rx = shearX * MathUtils.degRad;\n\t\t\t\tconst ry = (90 + shearY) * MathUtils.degRad;\n\t\t\t\tconst la = Math.cos(rx) * scaleX;\n\t\t\t\tconst lb = Math.cos(ry) * scaleY;\n\t\t\t\tconst lc = Math.sin(rx) * scaleX;\n\t\t\t\tconst ld = Math.sin(ry) * scaleY;\n\t\t\t\tthis.a = za * la + zb * lc;\n\t\t\t\tthis.b = za * lb + zb * ld;\n\t\t\t\tthis.c = zc * la + zd * lc;\n\t\t\t\tthis.d = zc * lb + zd * ld;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tthis.a *= skeleton.scaleX;\n\t\tthis.b *= skeleton.scaleX;\n\t\tthis.c *= skeleton.scaleY;\n\t\tthis.d *= skeleton.scaleY;\n\t}\n\n\t/** Computes the local transform values from the world transform.\n\t *\n\t * If the world transform is modified (by a constraint, {@link rotateWorld}, etc) then this method should be called so\n\t * the local transform matches the world transform. The local transform may be needed by other code (eg to apply another\n\t * constraint).\n\t *\n\t * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The local transform after\n\t * calling this method is equivalent to the local transform used to compute the world transform, but may not be identical. */\n\tpublic updateLocalTransform (skeleton: Skeleton): void {\n\t\tthis.local = 0;\n\t\tthis.world = skeleton._update;\n\n\t\tif (!this.bone.parent) {\n\t\t\tthis.x = this.worldX - skeleton.x;\n\t\t\tthis.y = this.worldY - skeleton.y;\n\t\t\tconst a = this.a, b = this.b, c = this.c, d = this.d;\n\t\t\tthis.rotation = MathUtils.atan2Deg(c, a);\n\t\t\tthis.scaleX = Math.sqrt(a * a + c * c);\n\t\t\tthis.scaleY = Math.sqrt(b * b + d * d);\n\t\t\tthis.shearX = 0;\n\t\t\tthis.shearY = MathUtils.atan2Deg(a * b + c * d, a * d - b * c);\n\t\t\treturn;\n\t\t}\n\n\t\tconst parent = this.bone.parent.appliedPose;\n\t\tlet pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;\n\t\tlet pid = 1 / (pa * pd - pb * pc);\n\t\tlet ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid;\n\t\tconst dx = this.worldX - parent.worldX, dy = this.worldY - parent.worldY;\n\t\tthis.x = (dx * ia - dy * ib);\n\t\tthis.y = (dy * id - dx * ic);\n\n\t\tlet ra: number, rb: number, rc: number, rd: number;\n\t\tif (this.inherit === Inherit.OnlyTranslation) {\n\t\t\tra = this.a;\n\t\t\trb = this.b;\n\t\t\trc = this.c;\n\t\t\trd = this.d;\n\t\t} else {\n\t\t\tswitch (this.inherit) {\n\t\t\t\tcase Inherit.NoRotationOrReflection: {\n\t\t\t\t\tconst s = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);\n\t\t\t\t\tpb = -pc * skeleton.scaleX * s / skeleton.scaleY;\n\t\t\t\t\tpd = pa * skeleton.scaleY * s / skeleton.scaleX;\n\t\t\t\t\tpid = 1 / (pa * pd - pb * pc);\n\t\t\t\t\tia = pd * pid;\n\t\t\t\t\tib = pb * pid;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tcase Inherit.NoScale:\n\t\t\t\tcase Inherit.NoScaleOrReflection: {\n\t\t\t\t\tlet r = this.rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);\n\t\t\t\t\tpa = (pa * cos + pb * sin) / skeleton.scaleX;\n\t\t\t\t\tpc = (pc * cos + pd * sin) / skeleton.scaleY;\n\t\t\t\t\tlet s = Math.sqrt(pa * pa + pc * pc);\n\t\t\t\t\tif (s > 0.00001) s = 1 / s;\n\t\t\t\t\tpa *= s;\n\t\t\t\t\tpc *= s;\n\t\t\t\t\ts = Math.sqrt(pa * pa + pc * pc);\n\t\t\t\t\tif (this.inherit === Inherit.NoScale && pid < 0 !== (skeleton.scaleX < 0 !== skeleton.scaleY < 0)) s = -s;\n\t\t\t\t\tr = MathUtils.PI / 2 + Math.atan2(pc, pa);\n\t\t\t\t\tpb = Math.cos(r) * s;\n\t\t\t\t\tpd = Math.sin(r) * s;\n\t\t\t\t\tpid = 1 / (pa * pd - pb * pc);\n\t\t\t\t\tia = pd * pid;\n\t\t\t\t\tib = pb * pid;\n\t\t\t\t\tic = pc * pid;\n\t\t\t\t\tid = pa * pid;\n\t\t\t\t}\n\t\t\t}\n\t\t\tra = ia * this.a - ib * this.c;\n\t\t\trb = ia * this.b - ib * this.d;\n\t\t\trc = id * this.c - ic * this.a;\n\t\t\trd = id * this.d - ic * this.b;\n\t\t}\n\n\t\tthis.shearX = 0;\n\t\tthis.scaleX = Math.sqrt(ra * ra + rc * rc);\n\t\tif (this.scaleX > 0.0001) {\n\t\t\tconst det = ra * rd - rb * rc;\n\t\t\tthis.scaleY = det / this.scaleX;\n\t\t\tthis.shearY = -MathUtils.atan2Deg(ra * rb + rc * rd, det);\n\t\t\tthis.rotation = MathUtils.atan2Deg(rc, ra);\n\t\t} else {\n\t\t\tthis.scaleX = 0;\n\t\t\tthis.scaleY = Math.sqrt(rb * rb + rd * rd);\n\t\t\tthis.shearY = 0;\n\t\t\tthis.rotation = 90 - MathUtils.atan2Deg(rd, rb);\n\t\t}\n\t}\n\n\t/** If the world transform has been modified by constraints and the local transform no longer matches,\n\t * {@link updateLocalTransform} is called. Call this after {@link Skeleton.updateWorldTransform} before\n\t * using the applied local transform. */\n\tpublic validateLocalTransform (skeleton: Skeleton): void {\n\t\tif (this.local === skeleton._update) this.updateLocalTransform(skeleton);\n\t}\n\n\tmodifyLocal (skeleton: Skeleton): void {\n\t\tif (this.local === skeleton._update) this.updateLocalTransform(skeleton);\n\t\tthis.world = 0;\n\t\tthis.resetWorld(skeleton._update);\n\t}\n\n\tmodifyWorld (update: number): void {\n\t\tthis.local = update;\n\t\tthis.world = update;\n\t\tthis.resetWorld(update);\n\t}\n\n\tprivate resetWorld (update: number): void {\n\t\tconst children = this.bone.children;\n\t\tfor (let i = 0, n = children.length; i < n; i++) {\n\t\t\tconst child = children[i].appliedPose;\n\t\t\tif (child.world === update) {\n\t\t\t\tchild.world = 0;\n\t\t\t\tchild.local = 0;\n\t\t\t\tchild.resetWorld(update);\n\t\t\t}\n\t\t}\n\t}\n\n\t/** The world rotation for the X axis, calculated using {@link a} and {@link c}. This is the direction the bone is\n\t * pointing. */\n\tpublic getWorldRotationX (): number {\n\t\treturn MathUtils.atan2Deg(this.c, this.a);\n\t}\n\n\t/** The world rotation for the Y axis, calculated using {@link b} and {@link d}. */\n\tpublic getWorldRotationY (): number {\n\t\treturn MathUtils.atan2Deg(this.d, this.b);\n\t}\n\n\t/** The magnitude (always positive) of the world scale X, calculated using {@link a} and {@link c}. */\n\tpublic getWorldScaleX (): number {\n\t\treturn Math.sqrt(this.a * this.a + this.c * this.c);\n\t}\n\n\t/** The magnitude (always positive) of the world scale Y, calculated using {@link b} and {@link d}. */\n\tpublic getWorldScaleY (): number {\n\t\treturn Math.sqrt(this.b * this.b + this.d * this.d);\n\t}\n\n\t// public Matrix3 getWorldTransform (Matrix3 worldTransform) {\n\t// \tif (worldTransform == null) throw new IllegalArgumentException(\"worldTransform cannot be null.\");\n\t// \tfloat[] val = worldTransform.val;\n\t// \tval[M00] = a;\n\t// \tval[M01] = b;\n\t// \tval[M10] = c;\n\t// \tval[M11] = d;\n\t// \tval[M02] = worldX;\n\t// \tval[M12] = worldY;\n\t// \tval[M20] = 0;\n\t// \tval[M21] = 0;\n\t// \tval[M22] = 1;\n\t// \treturn worldTransform;\n\t// }\n\n\t/** Transforms a point from world coordinates to the bone's local coordinates. */\n\tpublic worldToLocal (world: Vector2): Vector2 {\n\t\tif (world == null) throw new Error(\"world cannot be null.\");\n\t\tconst det = this.a * this.d - this.b * this.c;\n\t\tconst x = world.x - this.worldX, y = world.y - this.worldY;\n\t\tworld.x = (x * this.d - y * this.b) / det;\n\t\tworld.y = (y * this.a - x * this.c) / det;\n\t\treturn world;\n\t}\n\n\t/** Transforms a point from the bone's local coordinates to world coordinates. */\n\tpublic localToWorld (local: Vector2): Vector2 {\n\t\tif (local == null) throw new Error(\"local cannot be null.\");\n\t\tconst x = local.x, y = local.y;\n\t\tlocal.x = x * this.a + y * this.b + this.worldX;\n\t\tlocal.y = x * this.c + y * this.d + this.worldY;\n\t\treturn local;\n\t}\n\n\t/** Transforms a point from world coordinates to the parent bone's local coordinates. */\n\tpublic worldToParent (world: Vector2): Vector2 {\n\t\tif (world == null) throw new Error(\"world cannot be null.\");\n\t\treturn this.bone.parent == null ? world : this.bone.parent.appliedPose.worldToLocal(world);\n\t}\n\n\t/** Transforms a point from the parent bone's coordinates to world coordinates. */\n\tpublic parentToWorld (world: Vector2): Vector2 {\n\t\tif (world == null) throw new Error(\"world cannot be null.\");\n\t\treturn this.bone.parent == null ? world : this.bone.parent.appliedPose.localToWorld(world);\n\t}\n\n\t/** Transforms a world rotation to a local rotation. */\n\tpublic worldToLocalRotation (worldRotation: number): number {\n\t\tworldRotation *= MathUtils.degRad;\n\t\tconst sin = Math.sin(worldRotation), cos = Math.cos(worldRotation);\n\t\treturn MathUtils.atan2Deg(this.a * sin - this.c * cos, this.d * cos - this.b * sin) + this.rotation - this.shearX;\n\t}\n\n\t/** Transforms a local rotation to a world rotation. */\n\tlocalToWorldRotation (localRotation: number): number {\n\t\tlocalRotation = (localRotation - this.rotation - this.shearX) * MathUtils.degRad;\n\t\tconst sin = Math.sin(localRotation), cos = Math.cos(localRotation);\n\t\treturn MathUtils.atan2Deg(cos * this.c + sin * this.d, cos * this.a + sin * this.b);\n\t}\n\n\t/** Rotates the world transform the specified amount. */\n\trotateWorld (degrees: number) {\n\t\tdegrees *= MathUtils.degRad;\n\t\tconst sin = Math.sin(degrees), cos = Math.cos(degrees);\n\t\tconst ra = this.a, rb = this.b;\n\t\tthis.a = cos * ra - sin * this.c;\n\t\tthis.b = cos * rb - sin * this.d;\n\t\tthis.c = sin * ra + cos * this.c;\n\t\tthis.d = sin * rb + cos * this.d;\n\t}\n}\n"]}

package/dist/Constraint.d.ts

@@ -0,0 +1,41 @@
+/******************************************************************************
+ * 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 { ConstraintData } from "./ConstraintData.js";
+import type { Physics } from "./Physics.js";
+import type { Pose } from "./Pose.js";
+import { PosedActive } from "./PosedActive.js";
+import type { Skeleton } from "./Skeleton.js";
+import type { Update } from "./Update.js";
+export declare abstract class Constraint<T extends Constraint<T, D, P>, D extends ConstraintData<T, P>, P extends Pose<P>> extends PosedActive<D, P> implements Update {
+    constructor(data: D, pose: P, constrained: P);
+    abstract copy(skeleton: Skeleton): T;
+    abstract sort(skeleton: Skeleton): void;
+    abstract update(skeleton: Skeleton, physics: Physics): void;
+    isSourceActive(): boolean;
+}

package/dist/Constraint.js

@@ -0,0 +1,38 @@
+/******************************************************************************
+ * 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 { PosedActive } from "./PosedActive.js";
+export class Constraint extends PosedActive {
+    constructor(data, pose, constrained) {
+        super(data, pose, constrained);
+    }
+    isSourceActive() {
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29uc3RyYWludC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9Db25zdHJhaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7K0VBMkIrRTtBQUsvRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFJL0MsTUFBTSxPQUFnQixVQUlyQixTQUFRLFdBQWlCO0lBRXpCLFlBQWEsSUFBTyxFQUFFLElBQU8sRUFBRSxXQUFjO1FBQzVDLEtBQUssQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFRRCxjQUFjO1FBQ2IsT0FBTyxJQUFJLENBQUM7SUFDYixDQUFDO0NBQ0QiLCJzb3VyY2VzQ29udGVudCI6WyIvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqXG4gKiBTcGluZSBSdW50aW1lcyBMaWNlbnNlIEFncmVlbWVudFxuICogTGFzdCB1cGRhdGVkIEFwcmlsIDUsIDIwMjUuIFJlcGxhY2VzIGFsbCBwcmlvciB2ZXJzaW9ucy5cbiAqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTMtMjAyNSwgRXNvdGVyaWMgU29mdHdhcmUgTExDXG4gKlxuICogSW50ZWdyYXRpb24gb2YgdGhlIFNwaW5lIFJ1bnRpbWVzIGludG8gc29mdHdhcmUgb3Igb3RoZXJ3aXNlIGNyZWF0aW5nXG4gKiBkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBTcGluZSBSdW50aW1lcyBpcyBwZXJtaXR0ZWQgdW5kZXIgdGhlIHRlcm1zIGFuZFxuICogY29uZGl0aW9ucyBvZiBTZWN0aW9uIDIgb2YgdGhlIFNwaW5lIEVkaXRvciBMaWNlbnNlIEFncmVlbWVudDpcbiAqIGh0dHA6Ly9lc290ZXJpY3NvZnR3YXJlLmNvbS9zcGluZS1lZGl0b3ItbGljZW5zZVxuICpcbiAqIE90aGVyd2lzZSwgaXQgaXMgcGVybWl0dGVkIHRvIGludGVncmF0ZSB0aGUgU3BpbmUgUnVudGltZXMgaW50byBzb2Z0d2FyZVxuICogb3Igb3RoZXJ3aXNlIGNyZWF0ZSBkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBTcGluZSBSdW50aW1lcyAoY29sbGVjdGl2ZWx5LFxuICogXCJQcm9kdWN0c1wiKSwgcHJvdmlkZWQgdGhhdCBlYWNoIHVzZXIgb2YgdGhlIFByb2R1Y3RzIG11c3Qgb2J0YWluIHRoZWlyIG93blxuICogU3BpbmUgRWRpdG9yIGxpY2Vuc2UgYW5kIHJlZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9kdWN0cyBpbiBhbnkgZm9ybSBtdXN0XG4gKiBpbmNsdWRlIHRoaXMgbGljZW5zZSBhbmQgY29weXJpZ2h0IG5vdGljZS5cbiAqXG4gKiBUSEUgU1BJTkUgUlVOVElNRVMgQVJFIFBST1ZJREVEIEJZIEVTT1RFUklDIFNPRlRXQVJFIExMQyBcIkFTIElTXCIgQU5EIEFOWVxuICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRFxuICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRVxuICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgRVNPVEVSSUMgU09GVFdBUkUgTExDIEJFIExJQUJMRSBGT1IgQU5ZXG4gKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFU1xuICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTLFxuICogQlVTSU5FU1MgSU5URVJSVVBUSU9OLCBPUiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUykgSE9XRVZFUiBDQVVTRUQgQU5EXG4gKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVFxuICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GXG4gKiBUSEUgU1BJTkUgUlVOVElNRVMsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuXG4gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovXG5cbmltcG9ydCB0eXBlIHsgQ29uc3RyYWludERhdGEgfSBmcm9tIFwiLi9Db25zdHJhaW50RGF0YS5qc1wiO1xuaW1wb3J0IHR5cGUgeyBQaHlzaWNzIH0gZnJvbSBcIi4vUGh5c2ljcy5qc1wiO1xuaW1wb3J0IHR5cGUgeyBQb3NlIH0gZnJvbSBcIi4vUG9zZS5qc1wiO1xuaW1wb3J0IHsgUG9zZWRBY3RpdmUgfSBmcm9tIFwiLi9Qb3NlZEFjdGl2ZS5qc1wiO1xuaW1wb3J0IHR5cGUgeyBTa2VsZXRvbiB9IGZyb20gXCIuL1NrZWxldG9uLmpzXCI7XG5pbXBvcnQgdHlwZSB7IFVwZGF0ZSB9IGZyb20gXCIuL1VwZGF0ZS5qc1wiO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQ29uc3RyYWludDxcblx0VCBleHRlbmRzIENvbnN0cmFpbnQ8VCwgRCwgUD4sXG5cdEQgZXh0ZW5kcyBDb25zdHJhaW50RGF0YTxULCBQPixcblx0UCBleHRlbmRzIFBvc2U8UD4+XG5cdGV4dGVuZHMgUG9zZWRBY3RpdmU8RCwgUD4gaW1wbGVtZW50cyBVcGRhdGUge1xuXG5cdGNvbnN0cnVjdG9yIChkYXRhOiBELCBwb3NlOiBQLCBjb25zdHJhaW5lZDogUCkge1xuXHRcdHN1cGVyKGRhdGEsIHBvc2UsIGNvbnN0cmFpbmVkKTtcblx0fVxuXG5cdGFic3RyYWN0IGNvcHkgKHNrZWxldG9uOiBTa2VsZXRvbik6IFQ7XG5cblx0YWJzdHJhY3Qgc29ydCAoc2tlbGV0b246IFNrZWxldG9uKTogdm9pZDtcblxuXHRhYnN0cmFjdCB1cGRhdGUgKHNrZWxldG9uOiBTa2VsZXRvbiwgcGh5c2ljczogUGh5c2ljcyk6IHZvaWQ7XG5cblx0aXNTb3VyY2VBY3RpdmUgKCk6IGJvb2xlYW4ge1xuXHRcdHJldHVybiB0cnVlO1xuXHR9XG59XG4iXX0=

package/dist/ConstraintData.d.ts

@@ -26,10 +26,12 @@
  * (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 { Constraint } from "./Constraint.js";
+import type { Pose } from "./Pose.js";
+import { PosedData } from "./PosedData.js";
+import type { Skeleton } from "./Skeleton.js";
 /** The base class for all constraint datas. */
-export declare abstract class ConstraintData {
-    name: string;
-    order: number;
-    skinRequired: boolean;
-    constructor(name: string, order: number, skinRequired: boolean);
+export declare abstract class ConstraintData<T extends Constraint<T, ConstraintData<T, P>, P>, P extends Pose<P>> extends PosedData<P> {
+    constructor(name: string, setup: P);
+    abstract create(skeleton: Skeleton): T;
 }