@esotericsoftware/spine-canvas 4.3.8 → 4.3.10

package/dist/iife/spine-canvas.js

@@ -6475,21 +6475,22 @@ ${error}` : ""}`);
     modifyLocal(skeleton) {
       if (this.local === skeleton._update) this.updateLocalTransform(skeleton);
       this.world = 0;
-      this.resetWorld(skeleton._update);
+      this.resetWorld(skeleton, skeleton._update);
     }
-    modifyWorld(update) {
+    modifyWorld(skeleton) {
+      const update = skeleton._update;
       this.local = update;
       this.world = update;
-      this.resetWorld(update);
+      this.resetWorld(skeleton, update);
     }
-    resetWorld(update) {
+    resetWorld(skeleton, update) {
       const children = this.bone.children;
       for (let i = 0, n = children.length; i < n; i++) {
         const child = children[i].appliedPose;
         if (child.world === update) {
+          if (child.local === update) child.updateLocalTransform(skeleton);
           child.world = 0;
-          child.local = 0;
-          child.resetWorld(update);
+          child.resetWorld(skeleton, update);
         }
       }
     }
@@ -7282,8 +7283,9 @@ ${error}` : ""}`);
         const bone = this.slot.bone.appliedPose;
         offsetRotation *= bone.a * bone.d - bone.b * bone.c > 0 ? MathUtils.degRad : -MathUtils.degRad;
       }
-      for (let i = 0, ip = 3, u = skeleton._update; i < boneCount; i++, ip += 3) {
+      for (let i = 0, ip = 3; i < boneCount; i++, ip += 3) {
         const bone = bones[i];
+        bone.modifyWorld(skeleton);
         bone.worldX += (boneX - bone.worldX) * mixX;
         bone.worldY += (boneY - bone.worldY) * mixY;
         const x = positions[ip], y = positions[ip + 1], dx = x - boneX, dy = y - boneY;
@@ -7327,7 +7329,6 @@ ${error}` : ""}`);
           bone.c = sin * a + cos * c;
           bone.d = sin * b + cos * d;
         }
-        bone.modifyWorld(u);
       }
     }
     computeWorldPositions(skeleton, path, spacesCount, tangents) {
@@ -8240,9 +8241,9 @@ ${error}` : ""}`);
       const x = this.data.x > 0, y = this.data.y > 0, rotateOrShearX = this.data.rotate > 0 || this.data.shearX > 0, scaleX = this.data.scaleX > 0;
       const bone = this.bone;
       let l = bone.bone.data.length, t = this.data.step, z = 0;
+      if (physics === 0 /* none */) return;
+      bone.modifyWorld(skeleton);
       switch (physics) {
-        case 0 /* none */:
-          return;
         // biome-ignore lint/suspicious/noFallthroughSwitchClause: fall through expected
         case 1 /* reset */:
           this.reset(skeleton);
@@ -8420,7 +8421,6 @@ ${error}` : ""}`);
         this.tx = l * bone.a;
         this.ty = l * bone.c;
       }
-      bone.modifyWorld(skeleton._update);
     }
     sort(skeleton) {
       const bone = this.bone.bone;
@@ -8987,14 +8987,14 @@ ${error}` : ""}`);
       const source = this.source.appliedPose;
       if (localSource) source.validateLocalTransform(skeleton);
       const fromItems = data.properties;
-      const fn = data.properties.length, update = skeleton._update;
+      const fn = data.properties.length;
       const bones = this.bones;
       for (let i = 0, n = this.bones.length; i < n; i++) {
         const bone = bones[i];
         if (localTarget)
           bone.modifyLocal(skeleton);
         else
-          bone.modifyWorld(update);
+          bone.modifyWorld(skeleton);
         for (let f = 0; f < fn; f++) {
           const from = fromItems[f];
           const value = from.value(skeleton, source, localSource, offsets) - from.offset;
@@ -11222,7 +11222,7 @@ ${error}` : ""}`);
         t = triangles[i + 2];
         const x3 = vertices[t * stride], y3 = vertices[t * stride + 1];
         const u3 = uvs[t << 1], v3 = uvs[(t << 1) + 1];
-        const d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1, d = 1 / (d0 * d2 + d1 * (y1 - y3));
+        let d0 = 0, d1 = 0, d2 = 0, d4 = 0, d = 0;
         for (let p = 0; p < polygonsCount; p++) {
           let s = clippedVertices.length;
           if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p])) {
@@ -11230,6 +11230,13 @@ ${error}` : ""}`);
             const clipOutputLength = clipOutput.length;
             if (clipOutputLength === 0) continue;
             let clipOutputCount = clipOutputLength >> 1;
+            if (d === 0) {
+              d0 = y2 - y3;
+              d1 = x3 - x2;
+              d2 = x1 - x3;
+              d4 = y3 - y1;
+              d = 1 / (d0 * d2 - d1 * d4);
+            }
             const cv = Utils.setArraySize(clippedVertices, s + clipOutputCount * stride);
             for (let ii = 0; ii < clipOutputLength; ii += 2, s += stride) {
               const x = clipOutputItems[ii], y = clipOutputItems[ii + 1];
@@ -11429,7 +11436,7 @@ ${error}` : ""}`);
         const x3 = vertices[vertexStart + v], y3 = vertices[vertexStart + v + 1];
         uv = t << 1;
         const u3 = uvs[uv], v3 = uvs[uv + 1];
-        const d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1, d = 1 / (d0 * d2 + d1 * (y1 - y3));
+        let d0 = 0, d1 = 0, d2 = 0, d4 = 0, d = 0;
         for (let p = 0; p < polygonsCount; p++) {
           let s = this.clippedVerticesLength;
           if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p])) {
@@ -11437,6 +11444,13 @@ ${error}` : ""}`);
             const clipOutputLength = clipOutput.length;
             if (clipOutputLength === 0) continue;
             let clipOutputCount = clipOutputLength >> 1;
+            if (d === 0) {
+              d0 = y2 - y3;
+              d1 = x3 - x2;
+              d2 = x1 - x3;
+              d4 = y3 - y1;
+              d = 1 / (d0 * d2 - d1 * d4);
+            }
             const newLength = s + clipOutputCount * stride;
             if (clippedVertices.length < newLength) {
               this._clippedVerticesTyped = new Float32Array(newLength * 2);
@@ -11553,16 +11567,15 @@ ${error}` : ""}`);
         const edgeX = v[i], edgeY = v[i + 1], ex = edgeX - v[i + 2], ey = edgeY - v[i + 3];
         const outputStart = output.length;
         const iv2 = input;
-        for (let ii = 0, nn = input.length - 2; ii < nn; ) {
-          x1 = iv2[ii];
-          y1 = iv2[ii + 1];
-          ii += 2;
+        x1 = iv2[0];
+        y1 = iv2[1];
+        let s1 = ey * (edgeX - x1) - ex * (edgeY - y1);
+        for (let ii = 2, nn = input.length - 2; ii <= nn; ii += 2) {
           x2 = iv2[ii];
           y2 = iv2[ii + 1];
-          const s2 = ey * (edgeX - x2) > ex * (edgeY - y2);
-          const s1 = ey * (edgeX - x1) - ex * (edgeY - y1);
+          const s2 = ey * (edgeX - x2) - ex * (edgeY - y2);
           if (s1 > 0) {
-            if (s2)
+            if (s2 > 0)
               output.push(x2, y2);
             else {
               const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex);
@@ -11572,7 +11585,7 @@ ${error}` : ""}`);
               } else
                 output.push(x2, y2);
             }
-          } else if (s2) {
+          } else if (s2 > 0) {
             const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex);
             if (t >= 0 && t <= 1) {
               output.push(x1 + ix * t, y1 + iy * t, x2, y2);
@@ -11581,6 +11594,9 @@ ${error}` : ""}`);
               output.push(x2, y2);
           } else
             clipped = true;
+          x1 = x2;
+          y1 = y2;
+          s1 = s2;
         }
         if (outputStart === output.length) {
           originalOutput.length = 0;
@@ -11628,16 +11644,15 @@ ${error}` : ""}`);
         const outputStart = output.length, fragmentStart = this.inverseVertices.length;
         this.inverseVertices.push(0);
         iv = input;
-        for (let ii = 0, nn = input.length - 2; ii < nn; ) {
-          x1 = iv[ii];
-          y1 = iv[ii + 1];
-          ii += 2;
+        x1 = iv[0];
+        y1 = iv[1];
+        let s1 = ey * (edgeX - x1) - ex * (edgeY - y1);
+        for (let ii = 2, nn = input.length - 2; ii <= nn; ii += 2) {
           x2 = iv[ii];
           y2 = iv[ii + 1];
-          const s2 = ey * (edgeX - x2) > ex * (edgeY - y2);
-          const s1 = ey * (edgeX - x1) - ex * (edgeY - y1);
+          const s2 = ey * (edgeX - x2) - ex * (edgeY - y2);
           if (s1 > 0) {
-            if (s2)
+            if (s2 > 0)
               output.push(x2, y2);
             else {
               const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex);
@@ -11648,16 +11663,19 @@ ${error}` : ""}`);
               } else
                 output.push(x2, y2);
             }
-          } else if (s2) {
-            const dx = x2 - x1, dy = y2 - y1, t = s1 / (dx * ey - dy * ex);
+          } else if (s2 > 0) {
+            const ix = x2 - x1, iy = y2 - y1, t = s1 / (ix * ey - iy * ex);
             if (t >= 0 && t <= 1) {
-              const cx = x1 + dx * t, cy = y1 + dy * t;
+              const cx = x1 + ix * t, cy = y1 + iy * t;
               this.inverseVertices.push(cx, cy);
               output.push(cx, cy, x2, y2);
             } else
               output.push(x2, y2);
           } else
             this.inverseVertices.push(x2, y2);
+          x1 = x2;
+          y1 = y2;
+          s1 = s2;
         }
         const fragmentSize = this.inverseVertices.length - fragmentStart - 1;
         if (fragmentSize >= 6)
@@ -13024,17 +13042,21 @@ ${error}` : ""}`);
       this.renderCommands.length = 0;
       const clipper = this.clipping;
       const drawOrder = skeleton.drawOrder.appliedPose;
-      for (let i = 0; i < skeleton.slots.length; i++) {
+      for (let i = 0, n = drawOrder.length; i < n; i++) {
         const slot = drawOrder[i];
-        const attachment = slot.appliedPose.attachment;
-        if (!attachment) {
+        if (!slot.bone.active) {
           clipper.clipEnd(slot);
           continue;
         }
         const pose = slot.appliedPose;
+        const attachment = pose.attachment;
+        if (!attachment) {
+          clipper.clipEnd(slot);
+          continue;
+        }
         const slotColor = pose.color;
         const alpha = slotColor.a;
-        if ((alpha === 0 || !slot.bone.active) && !(attachment instanceof ClippingAttachment)) {
+        if (alpha === 0 && !(attachment instanceof ClippingAttachment)) {
           clipper.clipEnd(slot);
           continue;
         }
@@ -13078,9 +13100,15 @@ ${error}` : ""}`);
           indicesCount = indices.length;
           texture = sequence.regions[sequenceIndex]?.texture;
         } else if (attachment instanceof ClippingAttachment) {
+          clipper.clipEnd(slot);
           clipper.clipStart(skeleton, slot, attachment);
           continue;
         } else {
+          clipper.clipEnd(slot);
+          continue;
+        }
+        if (!texture) {
+          clipper.clipEnd(slot);
           continue;
         }
         const skelColor = skeleton.color;