@esotericsoftware/spine-webgl 4.3.9 → 4.3.11

package/dist/iife/spine-webgl.js

@@ -172,6 +172,7 @@ var spine = (() => {
     SkeletonData: () => SkeletonData,
     SkeletonDebugRenderer: () => SkeletonDebugRenderer,
     SkeletonJson: () => SkeletonJson,
+    SkeletonPhysicsMovement: () => SkeletonPhysicsMovement,
     SkeletonRenderer: () => SkeletonRenderer,
     SkeletonRendererCore: () => SkeletonRendererCore,
     Skin: () => Skin,
@@ -11262,7 +11263,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])) {
@@ -11270,6 +11271,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];
@@ -11469,7 +11477,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])) {
@@ -11477,6 +11485,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);
@@ -11593,16 +11608,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);
@@ -11612,7 +11626,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);
@@ -11621,6 +11635,9 @@ ${error}` : ""}`);
               output.push(x2, y2);
           } else
             clipped = true;
+          x1 = x2;
+          y1 = y2;
+          s1 = s2;
         }
         if (outputStart === output.length) {
           originalOutput.length = 0;
@@ -11668,16 +11685,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);
@@ -11688,16 +11704,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)
@@ -13052,6 +13071,151 @@ ${error}` : ""}`);
     return map[property] !== void 0 ? map[property] : defaultValue;
   }
 
+  // spine-core/src/SkeletonPhysicsMovement.ts
+  var SkeletonPhysicsMovement = class {
+    /**
+     * Creates a movement tracker for a skeleton displayed by a host runtime object.
+     * @param skeleton The skeleton whose physics constraints receive inherited movement.
+     * @param adapter Runtime-specific hooks used to read and convert the host object's transform.
+     * @param options Initial movement inheritance values.
+     */
+    constructor(skeleton, adapter, options = {}) {
+      this.skeleton = skeleton;
+      this.adapter = adapter;
+      this.positionInheritanceFactorX = options.positionInheritanceX ?? 0;
+      this.positionInheritanceFactorY = options.positionInheritanceY ?? 0;
+      this.rotationInheritanceFactor = options.rotationInheritance ?? 0;
+    }
+    positionInheritanceFactorX = 0;
+    positionInheritanceFactorY = 0;
+    rotationInheritanceFactor = 0;
+    hasLastTransform = false;
+    lastX = 0;
+    lastY = 0;
+    lastZ = 0;
+    lastRotation = 0;
+    currentTransform = { x: 0, y: 0, z: 0, rotation: 0 };
+    currentPosition = { x: 0, y: 0, z: 0 };
+    lastPosition = { x: 0, y: 0, z: 0 };
+    /** Horizontal position inheritance factor. `0` disables horizontal position inheritance. */
+    get positionInheritanceX() {
+      return this.positionInheritanceFactorX;
+    }
+    /** Vertical position inheritance factor. `0` disables vertical position inheritance. */
+    get positionInheritanceY() {
+      return this.positionInheritanceFactorY;
+    }
+    /**
+     * Sets how much host object translation is inherited by skeleton physics constraints.
+     * Use `(1, 1)` for normal inheritance, or `(0, 0)` to disable position inheritance.
+     * @param x The horizontal position inheritance factor.
+     * @param y The vertical position inheritance factor.
+     */
+    setPositionInheritance(x, y) {
+      const wasDisabled = this.positionInheritanceFactorX === 0 && this.positionInheritanceFactorY === 0;
+      const isEnabled = x !== 0 || y !== 0;
+      this.positionInheritanceFactorX = x;
+      this.positionInheritanceFactorY = y;
+      if (wasDisabled && isEnabled) this.resetPosition();
+    }
+    /** Rotation inheritance factor. `0` disables rotation inheritance. */
+    get rotationInheritance() {
+      return this.rotationInheritanceFactor;
+    }
+    /**
+     * Sets how much host object rotation is inherited by skeleton physics constraints.
+     * @param value The rotation inheritance factor.
+     */
+    set rotationInheritance(value) {
+      const wasDisabled = this.rotationInheritanceFactor === 0;
+      this.rotationInheritanceFactor = value;
+      if (wasDisabled && value !== 0) this.resetRotation();
+    }
+    /** Resets the previous position used to calculate inherited translation. */
+    resetPosition() {
+      const transform = this.currentTransform;
+      const readRotation = !this.hasLastTransform && this.rotationInheritanceFactor !== 0;
+      this.adapter.readTransform(transform, readRotation);
+      this.lastX = transform.x;
+      this.lastY = transform.y;
+      this.lastZ = transform.z;
+      if (readRotation) this.lastRotation = transform.rotation;
+      this.hasLastTransform = true;
+    }
+    /** Resets the previous rotation used to calculate inherited rotation. */
+    resetRotation() {
+      const transform = this.currentTransform;
+      this.adapter.readTransform(transform, true);
+      this.lastRotation = transform.rotation;
+      if (!this.hasLastTransform) {
+        this.lastX = transform.x;
+        this.lastY = transform.y;
+        this.lastZ = transform.z;
+      }
+      this.hasLastTransform = true;
+    }
+    /** Resets both previous position and previous rotation. */
+    resetTransform() {
+      const transform = this.currentTransform;
+      this.adapter.readTransform(transform, true);
+      this.setLastTransform(transform.x, transform.y, transform.z, transform.rotation);
+    }
+    /**
+     * Applies host object transform movement since the previous call to the skeleton's physics constraints.
+     *
+     * The first call records the current transform as the baseline and does not apply movement.
+     */
+    applyTransformMovement() {
+      const inheritPosition = this.positionInheritanceFactorX !== 0 || this.positionInheritanceFactorY !== 0;
+      const inheritRotation = this.rotationInheritanceFactor !== 0;
+      if (!inheritPosition && !inheritRotation) return;
+      const transform = this.currentTransform;
+      this.adapter.readTransform(transform, inheritRotation);
+      const { x, y, z } = transform;
+      const currentRotation = inheritRotation ? transform.rotation : this.lastRotation;
+      const positionChanged = x !== this.lastX || y !== this.lastY || z !== this.lastZ;
+      if (this.hasLastTransform) {
+        if (!positionChanged && currentRotation === this.lastRotation) return;
+        if (inheritPosition && positionChanged) this.applyPositionMovement(x, y, z);
+        if (inheritRotation && currentRotation !== this.lastRotation) this.applyRotationMovement(currentRotation);
+      }
+      this.setLastTransform(x, y, z, currentRotation);
+    }
+    applyPositionMovement(currentX, currentY, currentZ) {
+      const currentPosition = this.currentPosition;
+      currentPosition.x = currentX;
+      currentPosition.y = currentY;
+      currentPosition.z = currentZ;
+      this.adapter.worldToSkeleton(currentPosition);
+      const lastPosition = this.lastPosition;
+      lastPosition.x = this.lastX;
+      lastPosition.y = this.lastY;
+      lastPosition.z = this.lastZ;
+      this.adapter.worldToSkeleton(lastPosition);
+      this.skeleton.physicsTranslate(
+        (currentPosition.x - lastPosition.x) * this.positionInheritanceFactorX,
+        (currentPosition.y - lastPosition.y) * this.positionInheritanceFactorY
+      );
+    }
+    applyRotationMovement(currentRotation) {
+      const rotationFactor = this.rotationInheritanceFactor;
+      if (rotationFactor === 0) return;
+      this.skeleton.physicsRotate(0, 0, this.getRotationDelta(currentRotation, this.lastRotation) * rotationFactor);
+    }
+    setLastTransform(x, y, z, rotation) {
+      this.lastX = x;
+      this.lastY = y;
+      this.lastZ = z;
+      this.lastRotation = rotation;
+      this.hasLastTransform = true;
+    }
+    getRotationDelta(current, previous) {
+      let delta = current - previous;
+      delta = (delta + 180) % 360 - 180;
+      return delta < -180 ? delta + 360 : delta;
+    }
+  };
+
   // spine-core/src/SkeletonRendererCore.ts
   var SkeletonRendererCore = class {
     commandPool = new CommandPool();
@@ -13064,17 +13228,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;
         }
@@ -13118,9 +13286,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;