@esotericsoftware/spine-canvaskit 4.2.87 → 4.2.88

package/dist/iife/spine-canvaskit.js

@@ -4552,21 +4552,21 @@ var spine = (() => {
       return this._image;
     }
   };
-  var TextureFilter = /* @__PURE__ */ ((TextureFilter3) => {
-    TextureFilter3[TextureFilter3["Nearest"] = 9728] = "Nearest";
-    TextureFilter3[TextureFilter3["Linear"] = 9729] = "Linear";
-    TextureFilter3[TextureFilter3["MipMap"] = 9987] = "MipMap";
-    TextureFilter3[TextureFilter3["MipMapNearestNearest"] = 9984] = "MipMapNearestNearest";
-    TextureFilter3[TextureFilter3["MipMapLinearNearest"] = 9985] = "MipMapLinearNearest";
-    TextureFilter3[TextureFilter3["MipMapNearestLinear"] = 9986] = "MipMapNearestLinear";
-    TextureFilter3[TextureFilter3["MipMapLinearLinear"] = 9987] = "MipMapLinearLinear";
-    return TextureFilter3;
+  var TextureFilter = /* @__PURE__ */ ((TextureFilter2) => {
+    TextureFilter2[TextureFilter2["Nearest"] = 9728] = "Nearest";
+    TextureFilter2[TextureFilter2["Linear"] = 9729] = "Linear";
+    TextureFilter2[TextureFilter2["MipMap"] = 9987] = "MipMap";
+    TextureFilter2[TextureFilter2["MipMapNearestNearest"] = 9984] = "MipMapNearestNearest";
+    TextureFilter2[TextureFilter2["MipMapLinearNearest"] = 9985] = "MipMapLinearNearest";
+    TextureFilter2[TextureFilter2["MipMapNearestLinear"] = 9986] = "MipMapNearestLinear";
+    TextureFilter2[TextureFilter2["MipMapLinearLinear"] = 9987] = "MipMapLinearLinear";
+    return TextureFilter2;
   })(TextureFilter || {});
-  var TextureWrap = /* @__PURE__ */ ((TextureWrap3) => {
-    TextureWrap3[TextureWrap3["MirroredRepeat"] = 33648] = "MirroredRepeat";
-    TextureWrap3[TextureWrap3["ClampToEdge"] = 33071] = "ClampToEdge";
-    TextureWrap3[TextureWrap3["Repeat"] = 10497] = "Repeat";
-    return TextureWrap3;
+  var TextureWrap = /* @__PURE__ */ ((TextureWrap2) => {
+    TextureWrap2[TextureWrap2["MirroredRepeat"] = 33648] = "MirroredRepeat";
+    TextureWrap2[TextureWrap2["ClampToEdge"] = 33071] = "ClampToEdge";
+    TextureWrap2[TextureWrap2["Repeat"] = 10497] = "Repeat";
+    return TextureWrap2;
   })(TextureWrap || {});
   var TextureRegion = class {
     texture;
@@ -11455,9 +11455,9 @@ var spine = (() => {
     getImage() {
       return this._image;
     }
-    setFilters(minFilter, magFilter) {
+    setFilters() {
     }
-    setWraps(uWrap, vWrap) {
+    setWraps() {
     }
     dispose() {
       const data = this._image;
@@ -11516,12 +11516,11 @@ var spine = (() => {
     const attachmentLoader = new AtlasAttachmentLoader(atlas);
     const loader = skeletonFile.endsWith(".json") ? new SkeletonJson(attachmentLoader) : new SkeletonBinary(attachmentLoader);
     loader.scale = scale;
-    let data = await readFile(skeletonFile);
-    if (skeletonFile.endsWith(".json")) {
-      data = bufferToUtf8String(data);
+    const data = await readFile(skeletonFile);
+    if (loader instanceof SkeletonJson) {
+      return loader.readSkeletonData(bufferToUtf8String(data));
     }
-    const skeletonData = loader.readSkeletonData(data);
-    return skeletonData;
+    return loader.readSkeletonData(data);
   }
   var SkeletonDrawable = class {
     skeleton;
@@ -11558,12 +11557,10 @@ var spine = (() => {
       this.ck = ck;
     }
     clipper = new SkeletonClipping();
-    tempColor = new Color();
-    tempColor2 = new Color();
     static QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
     scratchPositions = Utils.newFloatArray(100);
-    scratchColors = Utils.newFloatArray(100);
     scratchUVs = Utils.newFloatArray(100);
+    scratchColors = new Uint32Array(100 / 4);
     /**
      * Renders a skeleton or skeleton drawable in its current pose to the canvas.
      * @param canvas the canvas to render to.
@@ -11571,100 +11568,79 @@ var spine = (() => {
      */
     render(canvas, skeleton) {
       if (skeleton instanceof SkeletonDrawable) skeleton = skeleton.skeleton;
-      let clipper = this.clipper;
-      let drawOrder = skeleton.drawOrder;
-      let skeletonColor = skeleton.color;
+      const clipper = this.clipper;
+      const drawOrder = skeleton.drawOrder;
+      const skeletonColor = skeleton.color;
       for (let i = 0, n = drawOrder.length; i < n; i++) {
-        let slot = drawOrder[i];
+        const slot = drawOrder[i];
         if (!slot.bone.active) {
           clipper.clipEndWithSlot(slot);
           continue;
         }
-        let attachment = slot.getAttachment();
+        const attachment = slot.getAttachment();
         let positions = this.scratchPositions;
-        let colors = this.scratchColors;
-        let uvs;
-        let texture;
         let triangles;
-        let attachmentColor;
-        let numVertices = 0;
+        let numVertices = 4;
         if (attachment instanceof RegionAttachment) {
-          let region = attachment;
-          if (positions.length < 8) this.scratchPositions = positions = Utils.newFloatArray(8);
-          numVertices = 4;
-          region.computeWorldVertices(slot, positions, 0, 2);
+          attachment.computeWorldVertices(slot, positions, 0, 2);
           triangles = _SkeletonRenderer.QUAD_TRIANGLES;
-          uvs = region.uvs;
-          texture = region.region?.texture;
-          attachmentColor = region.color;
         } else if (attachment instanceof MeshAttachment) {
-          let mesh = attachment;
-          if (positions.length < mesh.worldVerticesLength)
-            this.scratchPositions = positions = Utils.newFloatArray(mesh.worldVerticesLength);
-          numVertices = mesh.worldVerticesLength >> 1;
-          mesh.computeWorldVertices(
+          if (positions.length < attachment.worldVerticesLength) {
+            this.scratchPositions = Utils.newFloatArray(attachment.worldVerticesLength);
+            positions = this.scratchPositions;
+          }
+          numVertices = attachment.worldVerticesLength >> 1;
+          attachment.computeWorldVertices(
             slot,
             0,
-            mesh.worldVerticesLength,
+            attachment.worldVerticesLength,
             positions,
             0,
             2
           );
-          triangles = mesh.triangles;
-          texture = mesh.region?.texture;
-          uvs = mesh.uvs;
-          attachmentColor = mesh.color;
+          triangles = attachment.triangles;
         } else if (attachment instanceof ClippingAttachment) {
-          let clip = attachment;
-          clipper.clipStart(slot, clip);
+          clipper.clipStart(slot, attachment);
           continue;
         } else {
           clipper.clipEndWithSlot(slot);
           continue;
         }
+        const texture = attachment.region?.texture;
         if (texture) {
+          let uvs = attachment.uvs;
+          let scaledUvs;
+          let colors = this.scratchColors;
           if (clipper.isClipping()) {
-            clipper.clipTrianglesUnpacked(
-              positions,
-              triangles,
-              triangles.length,
-              uvs
-            );
-            if (clipper.clippedVertices.length > 0) {
-              if (positions.length < clipper.clippedVertices.length)
-                this.scratchPositions = positions = Utils.newFloatArray(clipper.clippedVertices.length);
-              numVertices = clipper.clippedVertices.length / 2;
-              for (let i2 = 0; i2 < clipper.clippedVertices.length; i2++)
-                positions[i2] = clipper.clippedVertices[i2];
-              uvs = clipper.clippedUVs;
-              triangles = clipper.clippedTriangles;
-            } else {
+            clipper.clipTrianglesUnpacked(positions, triangles, triangles.length, uvs);
+            if (clipper.clippedVertices.length <= 0) {
               clipper.clipEndWithSlot(slot);
               continue;
             }
+            positions = clipper.clippedVertices;
+            uvs = scaledUvs = clipper.clippedUVs;
+            triangles = clipper.clippedTriangles;
+            numVertices = clipper.clippedVertices.length / 2;
+            colors = new Uint32Array(numVertices);
+          } else {
+            scaledUvs = this.scratchUVs;
+            if (this.scratchUVs.length < uvs.length)
+              scaledUvs = this.scratchUVs = Utils.newFloatArray(uvs.length);
+            if (colors.length < numVertices)
+              colors = this.scratchColors = new Uint32Array(numVertices);
           }
-          let slotColor = slot.color;
-          let finalColor = this.tempColor;
-          finalColor.r = skeletonColor.r * slotColor.r * attachmentColor.r;
-          finalColor.g = skeletonColor.g * slotColor.g * attachmentColor.g;
-          finalColor.b = skeletonColor.b * slotColor.b * attachmentColor.b;
-          finalColor.a = skeletonColor.a * slotColor.a * attachmentColor.a;
-          if (colors.length / 4 < numVertices)
-            this.scratchColors = colors = Utils.newFloatArray(numVertices * 4);
-          for (let i2 = 0, n2 = numVertices * 4; i2 < n2; i2 += 4) {
-            colors[i2] = finalColor.r;
-            colors[i2 + 1] = finalColor.g;
-            colors[i2 + 2] = finalColor.b;
-            colors[i2 + 3] = finalColor.a;
-          }
-          const scaledUvs = this.scratchUVs.length < uvs.length ? this.scratchUVs = Utils.newFloatArray(uvs.length) : this.scratchUVs;
-          const width = texture.getImage().image.width();
-          const height = texture.getImage().image.height();
+          const ckImage = texture.getImage();
+          const image = ckImage.image;
+          const width = image.width();
+          const height = image.height();
           for (let i2 = 0; i2 < uvs.length; i2 += 2) {
             scaledUvs[i2] = uvs[i2] * width;
             scaledUvs[i2 + 1] = uvs[i2 + 1] * height;
           }
-          const blendMode = slot.data.blendMode;
+          const attachmentColor = attachment.color;
+          const slotColor = slot.color;
+          const finalColor = (MathUtils.clamp(skeletonColor.a * slotColor.a * attachmentColor.a * 255, 0, 255) << 24 | MathUtils.clamp(skeletonColor.r * slotColor.r * attachmentColor.r * 255, 0, 255) << 16 | MathUtils.clamp(skeletonColor.g * slotColor.g * attachmentColor.g * 255, 0, 255) << 8 | MathUtils.clamp(skeletonColor.b * slotColor.b * attachmentColor.b * 255, 0, 255) << 0) >>> 0;
+          for (let i2 = 0, n2 = numVertices; i2 < n2; i2++) colors[i2] = finalColor;
           const vertices = this.ck.MakeVertices(
             this.ck.VertexMode.Triangles,
             positions,
@@ -11673,11 +11649,8 @@ var spine = (() => {
             triangles,
             false
           );
-          canvas.drawVertices(
-            vertices,
-            this.ck.BlendMode.Modulate,
-            texture.getImage().paintPerBlendMode.get(blendMode)
-          );
+          const ckPaint = ckImage.paintPerBlendMode.get(slot.data.blendMode);
+          if (ckPaint) canvas.drawVertices(vertices, this.ck.BlendMode.Modulate, ckPaint);
           vertices.delete();
         }
         clipper.clipEndWithSlot(slot);