@esotericsoftware/spine-webgl 4.3.0 → 4.3.2

package/dist/esm/spine-webgl.mjs

@@ -114,6 +114,8 @@ var Color = class _Color {
   }
 };
 var MathUtils = class _MathUtils {
+  static epsilon = 1e-5;
+  static epsilon2 = _MathUtils.epsilon * _MathUtils.epsilon;
   // biome-ignore lint/suspicious/noApproximativeNumericConstant: reference runtime
   static PI = 3.1415927;
   static PI2 = _MathUtils.PI * 2;
@@ -5911,73 +5913,70 @@ var BonePose = class {
         return;
       }
       case 1 /* OnlyTranslation */: {
+        const sx = skeleton.scaleX, sy = skeleton.scaleY;
         const rx = (rotation + shearX) * MathUtils.degRad;
         const ry = (rotation + 90 + shearY) * MathUtils.degRad;
-        this.a = Math.cos(rx) * scaleX;
-        this.b = Math.cos(ry) * scaleY;
-        this.c = Math.sin(rx) * scaleX;
-        this.d = Math.sin(ry) * scaleY;
+        this.a = Math.cos(rx) * scaleX * sx;
+        this.b = Math.cos(ry) * scaleY * sx;
+        this.c = Math.sin(rx) * scaleX * sy;
+        this.d = Math.sin(ry) * scaleY * sy;
         break;
       }
       case 2 /* NoRotationOrReflection */: {
-        const sx = 1 / skeleton.scaleX, sy = 1 / skeleton.scaleY;
-        pa *= sx;
-        pc *= sy;
+        const sx = skeleton.scaleX, sy = skeleton.scaleY, sxi = 1 / sx, syi = 1 / sy;
+        pa *= sxi;
+        pc *= syi;
         let s = pa * pa + pc * pc;
-        let prx = 0;
-        if (s > 1e-4) {
-          s = Math.abs(pa * pd * sy - pb * sx * pc) / s;
+        let r = 0;
+        if (s > MathUtils.epsilon2) {
+          s = Math.abs(pa * pd * syi - pb * sxi * pc) / s;
           pb = pc * s;
           pd = pa * s;
-          prx = MathUtils.atan2Deg(pc, pa);
+          r = rotation - MathUtils.atan2Deg(pc, pa);
         } else {
           pa = 0;
           pc = 0;
-          prx = 90 - MathUtils.atan2Deg(pd, pb);
+          r = rotation - 90 + MathUtils.atan2Deg(pd, pb);
         }
-        const rx = (rotation + shearX - prx) * MathUtils.degRad;
-        const ry = (rotation + shearY - prx + 90) * MathUtils.degRad;
+        const rx = (r + shearX) * MathUtils.degRad;
+        const ry = (r + shearY + 90) * MathUtils.degRad;
         const la = Math.cos(rx) * scaleX;
         const lb = Math.cos(ry) * scaleY;
         const lc = Math.sin(rx) * scaleX;
         const ld = Math.sin(ry) * scaleY;
-        this.a = pa * la - pb * lc;
-        this.b = pa * lb - pb * ld;
-        this.c = pc * la + pd * lc;
-        this.d = pc * lb + pd * ld;
+        this.a = (pa * la - pb * lc) * sx;
+        this.b = (pa * lb - pb * ld) * sx;
+        this.c = (pc * la + pd * lc) * sy;
+        this.d = (pc * lb + pd * ld) * sy;
         break;
       }
       case 3 /* NoScale */:
       case 4 /* NoScaleOrReflection */: {
-        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 > 1e-5) s = 1 / s;
+        const sx = skeleton.scaleX, sy = skeleton.scaleY, sxi = 1 / sx, syi = 1 / sy;
+        const r = rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
+        let za = (pa * cos + pb * sin) * sxi;
+        let zc = (pc * cos + pd * sin) * syi;
+        const s = 1 / Math.sqrt(za * za + zc * zc);
         za *= s;
         zc *= s;
-        s = Math.sqrt(za * za + zc * zc);
-        if (this.inherit === 3 /* 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;
+        let zb = -zc, zd = za;
+        if (this.inherit === 3 /* NoScale */ && pa * pd - pb * pc < 0 !== (sx < 0 !== sy < 0)) {
+          zb = -zb;
+          zd = -zd;
+        }
         const rx = shearX * MathUtils.degRad;
         const ry = (90 + shearY) * MathUtils.degRad;
         const la = Math.cos(rx) * scaleX;
         const lb = Math.cos(ry) * scaleY;
         const lc = Math.sin(rx) * scaleX;
         const ld = Math.sin(ry) * scaleY;
-        this.a = za * la + zb * lc;
-        this.b = za * lb + zb * ld;
-        this.c = zc * la + zd * lc;
-        this.d = zc * lb + zd * ld;
+        this.a = (za * la + zb * lc) * sx;
+        this.b = (za * lb + zb * ld) * sx;
+        this.c = (zc * la + zd * lc) * sy;
+        this.d = (zc * lb + zd * ld) * sy;
         break;
       }
     }
-    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.
    *
@@ -5990,79 +5989,118 @@ var BonePose = class {
   updateLocalTransform(skeleton) {
     this.local = 0;
     this.world = skeleton._update;
+    const sx = skeleton.scaleX, sy = skeleton.scaleY;
     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);
+      const sxi = 1 / sx, syi = 1 / sy;
+      this.x = (this.worldX - skeleton.x) * sxi;
+      this.y = (this.worldY - skeleton.y) * syi;
+      this.set5(this.a * sxi, this.b * sxi, this.c * syi, this.d * syi, 0);
       return;
     }
     const parent = this.bone.parent.appliedPose;
     let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
-    let pid = 1 / (pa * pd - pb * pc);
-    let ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid;
+    const pad = pa * pd - pb * pc, pid = 1 / (pa * pd - pb * pc);
+    const ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid;
     const dx = this.worldX - parent.worldX, dy = this.worldY - parent.worldY;
     this.x = dx * ia - dy * ib;
     this.y = dy * id - dx * ic;
-    let ra, rb, rc, rd;
-    if (this.inherit === 1 /* OnlyTranslation */) {
-      ra = this.a;
-      rb = this.b;
-      rc = this.c;
-      rd = this.d;
+    switch (this.inherit) {
+      case 0 /* Normal */:
+        this.set5(ia * this.a - ib * this.c, ia * this.b - ib * this.d, id * this.c - ic * this.a, id * this.d - ic * this.b, 0);
+        break;
+      case 1 /* OnlyTranslation */: {
+        const sxi = 1 / sx, syi = 1 / sy;
+        this.set5(this.a * sxi, this.b * sxi, this.c * syi, this.d * syi, 0);
+        break;
+      }
+      case 2 /* NoRotationOrReflection */: {
+        const sxi = 1 / sx, syi = 1 / sy;
+        pa *= sxi;
+        pc *= syi;
+        const wa = this.a * sxi, wb = this.b * sxi, wc = this.c * syi, wd = this.d * syi;
+        const s = 1 / (pa * pa + pc * pc), det = 1 / Math.abs(pad * sxi * syi);
+        this.set5(
+          (pa * wa + pc * wc) * s,
+          (pa * wb + pc * wd) * s,
+          (pa * wc - pc * wa) * det,
+          (pa * wd - pc * wb) * det,
+          MathUtils.atan2Deg(pc, pa)
+        );
+        break;
+      }
+      case 3 /* NoScale */:
+      case 4 /* NoScaleOrReflection */: {
+        const sxi = 1 / sx, syi = 1 / sy;
+        const wa = this.a * sxi, wb = this.b * sxi, wc = this.c * syi, wd = this.d * syi;
+        let tx = pd * this.a - pb * this.c, ty = pa * this.c - pc * this.a;
+        if (pad < 0) {
+          tx = -tx;
+          ty = -ty;
+        }
+        let r = MathUtils.atan2Deg(ty, tx);
+        this.rotation = r;
+        r *= MathUtils.degRad;
+        const cos = Math.cos(r), sin = Math.sin(r);
+        let za = (pa * cos + pb * sin) * sxi;
+        let zc = (pc * cos + pd * sin) * syi;
+        const s = 1 / Math.sqrt(za * za + zc * zc);
+        za *= s;
+        zc *= s;
+        const si = this.inherit === 3 /* NoScale */ && pad < 0 !== (sx < 0 !== sy < 0) ? -1 : 1;
+        this.set4(za * wa + zc * wc, za * wb + zc * wd, (za * wc - zc * wa) * si, (za * wd - zc * wb) * si);
+      }
+    }
+  }
+  set4(ra, rb, rc, rd) {
+    const x = ra * ra + rc * rc, y = rb * rb + rd * rd;
+    if (x > MathUtils.epsilon2) {
+      this.shearX = MathUtils.atan2Deg(rc, ra);
+      this.scaleX = Math.sqrt(x);
     } else {
-      switch (this.inherit) {
-        case 2 /* 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 3 /* NoScale */:
-        case 4 /* 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 > 1e-5) s = 1 / s;
-          pa *= s;
-          pc *= s;
-          s = Math.sqrt(pa * pa + pc * pc);
-          if (this.inherit === 3 /* 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 = 0;
     }
+    this.scaleY = Math.sqrt(y);
+    if (y > MathUtils.epsilon2) {
+      this.shearY = MathUtils.atan2Deg(rd, rb);
+      if (ra * rd - rb * rc < 0) {
+        this.scaleY = -this.scaleY;
+        this.shearY += 90;
+      } else
+        this.shearY -= 90;
+      if (this.shearY > 180)
+        this.shearY -= 360;
+      else if (this.shearY <= -180)
+        this.shearY += 360;
+    } else
+      this.shearY = 0;
+  }
+  set5(ra, rb, rc, rd, ro) {
     this.shearX = 0;
-    this.scaleX = Math.sqrt(ra * ra + rc * rc);
-    if (this.scaleX > 1e-4) {
-      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);
+    const x = ra * ra + rc * rc, y = rb * rb + rd * rd;
+    if (x > MathUtils.epsilon2) {
+      const r = MathUtils.atan2Deg(rc, ra);
+      this.rotation = r + ro;
+      this.scaleX = Math.sqrt(x);
+      this.scaleY = Math.sqrt(y);
+      if (y > MathUtils.epsilon2) {
+        this.shearY = MathUtils.atan2Deg(rd, rb);
+        if (ra * rd - rb * rc < 0) {
+          this.scaleY = -this.scaleY;
+          this.shearY += 90 - r;
+        } else
+          this.shearY -= 90 + r;
+        if (this.shearY > 180)
+          this.shearY -= 360;
+        else if (this.shearY <= -180)
+          this.shearY += 360;
+      } else
+        this.shearY = 0;
     } else {
       this.scaleX = 0;
-      this.scaleY = Math.sqrt(rb * rb + rd * rd);
+      this.scaleY = Math.sqrt(y);
       this.shearY = 0;
-      this.rotation = 90 - MathUtils.atan2Deg(rd, rb);
+      this.rotation = y > MathUtils.epsilon2 ? MathUtils.atan2Deg(rd, rb) - 90 + ro : ro;
     }
   }
   /** If the world transform has been modified by constraints and the local transform no longer matches,
@@ -6307,6 +6345,12 @@ var ConstraintData = class extends PosedData {
     super(name, setup);
   }
 };
+var ScaleYMode = /* @__PURE__ */ ((ScaleYMode2) => {
+  ScaleYMode2[ScaleYMode2["None"] = 0] = "None";
+  ScaleYMode2[ScaleYMode2["Uniform"] = 1] = "Uniform";
+  ScaleYMode2[ScaleYMode2["Volume"] = 2] = "Volume";
+  return ScaleYMode2;
+})(ScaleYMode || {});
 
 // spine-core/src/Event.ts
 var Event = class {
@@ -6378,43 +6422,6 @@ var IkConstraintPose = class {
   }
 };
 
-// spine-core/src/IkConstraintData.ts
-var IkConstraintData = class extends ConstraintData {
-  /** The bones that are constrained by this IK constraint. */
-  bones = [];
-  _target = null;
-  /** The bone that is the IK target. */
-  set target(boneData) {
-    this._target = boneData;
-  }
-  get target() {
-    if (!this._target) throw new Error("target cannot be null.");
-    return this._target;
-  }
-  /** Determines how the {@link BonePose.scaleY} changes when {@link IkConstraintPose.compress} or
-    * {@link IkConstraintPose.stretch} set {@link BonePose.scaleX}. */
-  _scaleYMode = 0 /* None */;
-  set scaleYMode(scaleYMode) {
-    this._scaleYMode = scaleYMode;
-  }
-  get scaleYMode() {
-    if (this._scaleYMode == null) throw new Error("scaleYMode cannot be null.");
-    return this._scaleYMode;
-  }
-  constructor(name) {
-    super(name, new IkConstraintPose());
-  }
-  create(skeleton) {
-    return new IkConstraint(this, skeleton);
-  }
-};
-var ScaleYMode = /* @__PURE__ */ ((ScaleYMode2) => {
-  ScaleYMode2[ScaleYMode2["None"] = 0] = "None";
-  ScaleYMode2[ScaleYMode2["Uniform"] = 1] = "Uniform";
-  ScaleYMode2[ScaleYMode2["Volume"] = 2] = "Volume";
-  return ScaleYMode2;
-})(ScaleYMode || {});
-
 // spine-core/src/IkConstraint.ts
 var IkConstraint = class _IkConstraint extends Constraint {
   /** The 1 or 2 bones that will be modified by this IK constraint. */
@@ -6501,7 +6508,7 @@ var IkConstraint = class _IkConstraint extends Constraint {
         break;
       // biome-ignore lint/suspicious/noFallthroughSwitchClause: reference runtime
       case 2 /* NoRotationOrReflection */: {
-        const s = Math.abs(pa * pd - pb * pc) / Math.max(1e-4, pa * pa + pc * pc);
+        const s = Math.abs(pa * pd - pb * pc) / Math.max(MathUtils.epsilon, pa * pa + pc * pc);
         const sa = pa / skeleton.scaleX;
         const sc = pc / skeleton.scaleY;
         pb = -sc * s * skeleton.scaleX;
@@ -6512,7 +6519,7 @@ var IkConstraint = class _IkConstraint extends Constraint {
       default: {
         const x = targetX - p.worldX, y = targetY - p.worldY;
         const d = pa * pd - pb * pc;
-        if (Math.abs(d) <= 1e-4) {
+        if (Math.abs(d) <= MathUtils.epsilon) {
           tx = 0;
           ty = 0;
         } else {
@@ -6525,7 +6532,7 @@ var IkConstraint = class _IkConstraint extends Constraint {
     if (bone.scaleX < 0) rotationIK += 180;
     if (rotationIK > 180)
       rotationIK -= 360;
-    else if (rotationIK < -180)
+    else if (rotationIK <= -180)
       rotationIK += 360;
     bone.rotation += rotationIK * mix;
     if (compress || stretch) {
@@ -6536,7 +6543,7 @@ var IkConstraint = class _IkConstraint extends Constraint {
           ty = targetY - bone.worldY;
       }
       const b = bone.bone.data.length * bone.scaleX;
-      if (b > 1e-4) {
+      if (b > MathUtils.epsilon) {
         const dd = tx * tx + ty * ty;
         if (compress && dd < b * b || stretch && dd > b * b) {
           const s = (Math.sqrt(dd) / b - 1) * mix + 1;
@@ -6546,7 +6553,7 @@ var IkConstraint = class _IkConstraint extends Constraint {
               bone.scaleY *= s;
               break;
             case 2 /* Volume */:
-              bone.scaleY /= s;
+              bone.scaleY /= s < 0.7 ? 0.25 + 0.642857 * s : s;
           }
         }
       }
@@ -6578,7 +6585,7 @@ var IkConstraint = class _IkConstraint extends Constraint {
     } else
       os2 = 0;
     let cwx = 0, cwy = 0, a = parent.a, b = parent.b, c = parent.c, d = parent.d;
-    const u = Math.abs(psx - psy) <= 1e-4;
+    const u = Math.abs(psx - psy) <= MathUtils.epsilon;
     if (!u || stretch) {
       child.y = 0;
       cwx = a * child.x + parent.worldX;
@@ -6593,10 +6600,10 @@ var IkConstraint = class _IkConstraint extends Constraint {
     c = pp.c;
     d = pp.d;
     let id = a * d - b * c, x = cwx - pp.worldX, y = cwy - pp.worldY;
-    id = Math.abs(id) <= 1e-4 ? 0 : 1 / id;
+    id = Math.abs(id) <= MathUtils.epsilon ? 0 : 1 / id;
     const dx = (x * d - y * b) * id - px, dy = (y * a - x * c) * id - py;
     let l1 = Math.sqrt(dx * dx + dy * dy), l2 = child.bone.data.length * csx, a1, a2;
-    if (l1 < 1e-4) {
+    if (l1 < MathUtils.epsilon) {
       _IkConstraint.apply(skeleton, parent, targetX, targetY, false, stretch, 0 /* None */, mix);
       child.rotation = 0;
       return;
@@ -6634,7 +6641,7 @@ var IkConstraint = class _IkConstraint extends Constraint {
                 parent.scaleY *= a;
                 break;
               case 2 /* Volume */:
-                parent.scaleY /= a;
+                parent.scaleY /= a < 0.7 ? 0.25 + 0.642857 * a : a;
             }
           }
         } else
@@ -6696,18 +6703,49 @@ var IkConstraint = class _IkConstraint extends Constraint {
     a1 = (a1 - os) * MathUtils.radDeg + os1 - parent.rotation;
     if (a1 > 180)
       a1 -= 360;
-    else if (a1 < -180)
+    else if (a1 <= -180)
       a1 += 360;
     parent.rotation += a1 * mix;
     a2 = ((a2 + os) * MathUtils.radDeg - child.shearX) * s2 + os2 - child.rotation;
     if (a2 > 180)
       a2 -= 360;
-    else if (a2 < -180)
+    else if (a2 <= -180)
       a2 += 360;
     child.rotation += a2 * mix;
   }
 };
 
+// spine-core/src/IkConstraintData.ts
+var IkConstraintData = class extends ConstraintData {
+  /** The bones that are constrained by this IK constraint. */
+  bones = [];
+  _target = null;
+  /** The bone that is the IK target. */
+  set target(boneData) {
+    this._target = boneData;
+  }
+  get target() {
+    if (!this._target) throw new Error("target cannot be null.");
+    return this._target;
+  }
+  /** Determines how the {@link BonePose.scaleY} changes when {@link IkConstraintPose.compress} or
+    * {@link IkConstraintPose.stretch} set {@link BonePose.scaleX}. */
+  _scaleYMode = 0 /* None */;
+  set scaleYMode(scaleYMode) {
+    this._scaleYMode = scaleYMode;
+  }
+  get scaleYMode() {
+    if (this._scaleYMode == null) throw new Error("scaleYMode cannot be null.");
+    return this._scaleYMode;
+  }
+  constructor(name) {
+    super(name, new IkConstraintPose());
+  }
+  create(skeleton) {
+    return new IkConstraint(this, skeleton);
+  }
+};
+
 // spine-core/src/PathConstraintPose.ts
 var PathConstraintPose = class {
   /** The position along the path. */
@@ -6781,7 +6819,6 @@ var PathConstraint = class _PathConstraint extends Constraint {
   static NONE = -1;
   static BEFORE = -2;
   static AFTER = -3;
-  static epsilon = 1e-5;
   /** The path constraint's setup pose data. */
   data;
   /** The bones that will be modified by this path constraint. */
@@ -6837,7 +6874,7 @@ var PathConstraint = class _PathConstraint extends Constraint {
         for (let i = 0, n = spacesCount - 1; i < n; ) {
           const bone = bones[i];
           const setupLength = bone.bone.data.length;
-          if (setupLength < _PathConstraint.epsilon) {
+          if (setupLength < MathUtils.epsilon) {
             if (scale) lengths[i] = 0;
             spaces[++i] = spacing;
           } else {
@@ -6860,7 +6897,7 @@ var PathConstraint = class _PathConstraint extends Constraint {
         for (let i = 0, n = spacesCount - 1; i < n; ) {
           const bone = bones[i];
           const setupLength = bone.bone.data.length;
-          if (setupLength < _PathConstraint.epsilon) {
+          if (setupLength < MathUtils.epsilon) {
             if (scale) lengths[i] = 0;
             spaces[++i] = spacing;
           } else {
@@ -8001,9 +8038,20 @@ var PhysicsConstraint = class _PhysicsConstraint extends Constraint {
       }
     }
     if (scaleX) {
-      const s = 1 + (this.scaleOffset - this.scaleLag * z) * mix * this.data.scaleX;
+      let s = 1 + (this.scaleOffset - this.scaleLag * z) * mix * this.data.scaleX;
       bone.a *= s;
       bone.c *= s;
+      switch (this.data.scaleYMode) {
+        case 1 /* Uniform */:
+          bone.b *= s;
+          bone.d *= s;
+          break;
+        case 2 /* Volume */:
+          s = Math.abs(s);
+          s = s >= 0.7 ? 1 / s : 4 - 3.67347 * s;
+          bone.b *= s;
+          bone.d *= s;
+      }
     }
     if (physics !== 3 /* pose */) {
       this.tx = l * bone.a;
@@ -8062,6 +8110,16 @@ var PhysicsConstraintData = class extends ConstraintData {
   gravityGlobal = false;
   /** True when this constraint's mix is controlled by global slider timelines. */
   mixGlobal = false;
+  /** Determines how the {@link BonePose.scaleY} changes when {@link PhysicsConstraintData.scaleX} sets
+   * {@link BonePose.scaleX}. */
+  _scaleYMode = 0 /* None */;
+  get scaleYMode() {
+    return this._scaleYMode;
+  }
+  set scaleYMode(scaleYMode) {
+    if (scaleYMode == null) throw new Error("scaleYMode cannot be null.");
+    this._scaleYMode = scaleYMode;
+  }
   constructor(name) {
     super(name, new PhysicsConstraintPose());
   }
@@ -9114,7 +9172,17 @@ var SkeletonBinary = class {
           if ((flags & 2) !== 0) data.x = input.readFloat();
           if ((flags & 4) !== 0) data.y = input.readFloat();
           if ((flags & 8) !== 0) data.rotate = input.readFloat();
-          if ((flags & 16) !== 0) data.scaleX = input.readFloat();
+          if ((flags & 16) !== 0) {
+            let scaleX = input.readFloat();
+            if (scaleX < -2) {
+              data.scaleYMode = 2 /* Volume */;
+              scaleX = -2 - scaleX;
+            } else if (scaleX < 0) {
+              data.scaleYMode = 1 /* Uniform */;
+              scaleX = -1 - scaleX;
+            }
+            data.scaleX = scaleX;
+          }
           if ((flags & 32) !== 0) data.shearX = input.readFloat();
           data.limit = ((flags & 64) !== 0 ? input.readFloat() : 5e3) * scale;
           data.step = 1 / input.readUnsignedByte();
@@ -11537,6 +11605,8 @@ var SkeletonJson = class {
             data.y = getValue(constraintMap, "y", 0);
             data.rotate = getValue(constraintMap, "rotate", 0);
             data.scaleX = getValue(constraintMap, "scaleX", 0);
+            const scaleY = getValue(constraintMap, "scaleY", null);
+            if (scaleY != null) data.scaleYMode = Utils.enumValue(ScaleYMode, scaleY);
             data.shearX = getValue(constraintMap, "shearX", 0);
             data.limit = getValue(constraintMap, "limit", 5e3) * scale;
             data.step = 1 / getValue(constraintMap, "fps", 60);
@@ -14671,10 +14741,12 @@ var SkeletonRenderer = class _SkeletonRenderer {
   twoColorTint = false;
   renderable = new Renderable([], 0, 0);
   clipper = new SkeletonClipping();
-  temp = new Vector2();
-  temp2 = new Vector2();
-  temp3 = new Color();
-  temp4 = new Color();
+  /**
+   * Batches additive slots together with normal slots by rendering additive slots with premultiplied alpha RGB and zero alpha,
+   * while using normal PMA blending. This reduces draw calls for normal/additive/normal sequences with the same texture.
+   * Disable this if rendering to a transparent target and the accumulated destination alpha from additive blending must be preserved.
+   */
+  pmaAdditiveBatching = true;
   constructor(context, twoColorTint = true) {
     this.twoColorTint = twoColorTint;
     if (twoColorTint)
@@ -14753,7 +14825,9 @@ var SkeletonRenderer = class _SkeletonRenderer {
         finalColor.r = skeletonColor.r * slotColor.r * attachmentColor.r * alpha;
         finalColor.g = skeletonColor.g * slotColor.g * attachmentColor.g * alpha;
         finalColor.b = skeletonColor.b * slotColor.b * attachmentColor.b * alpha;
-        finalColor.a = alpha;
+        const slotBlendMode = slot.data.blendMode;
+        const additiveBlend = this.pmaAdditiveBatching && slotBlendMode === 1 /* Additive */;
+        finalColor.a = additiveBlend ? 0 : alpha;
         const darkColor = this.tempColor2;
         if (!pose.darkColor)
           darkColor.set(0, 0, 0, 1);
@@ -14763,9 +14837,9 @@ var SkeletonRenderer = class _SkeletonRenderer {
           darkColor.b = pose.darkColor.b * alpha;
           darkColor.a = 1;
         }
-        const slotBlendMode = slot.data.blendMode;
-        if (slotBlendMode !== blendMode) {
-          blendMode = slotBlendMode;
+        const batchBlendMode = additiveBlend ? 0 /* Normal */ : slotBlendMode;
+        if (batchBlendMode !== blendMode) {
+          blendMode = batchBlendMode;
           batcher.setBlendMode(blendMode);
         }
         if (clipper.isClipping() && clipper.clipTriangles(renderable.vertices, triangles, triangles.length, uvs, finalColor, darkColor, twoColorTint, vertexSize)) {
@@ -14780,7 +14854,7 @@ var SkeletonRenderer = class _SkeletonRenderer {
               verts[v] = finalColor.r;
               verts[v + 1] = finalColor.g;
               verts[v + 2] = finalColor.b;
-              verts[v + 3] = alpha;
+              verts[v + 3] = finalColor.a;
               verts[v + 4] = uvs[u];
               verts[v + 5] = uvs[u + 1];
             }
@@ -14789,7 +14863,7 @@ var SkeletonRenderer = class _SkeletonRenderer {
               verts[v] = finalColor.r;
               verts[v + 1] = finalColor.g;
               verts[v + 2] = finalColor.b;
-              verts[v + 3] = alpha;
+              verts[v + 3] = finalColor.a;
               verts[v + 4] = uvs[u];
               verts[v + 5] = uvs[u + 1];
               verts[v + 6] = darkColor.r;