@esotericsoftware/spine-phaser-v3 4.2.90 → 4.2.92

package/dist/iife/spine-phaser-v3.js

@@ -177,7 +177,7 @@ var spine = (() => {
     SkeletonData: () => SkeletonData,
     SkeletonDebugRenderer: () => SkeletonDebugRenderer,
     SkeletonJson: () => SkeletonJson,
-    SkeletonRenderer: () => SkeletonRenderer,
+    SkeletonRenderer: () => SkeletonRenderer2,
     Skin: () => Skin,
     SkinEntry: () => SkinEntry,
     SkinsAndAnimationBoundsProvider: () => SkinsAndAnimationBoundsProvider,
@@ -230,16 +230,6 @@ var spine = (() => {
     };
   }
 
-  // spine-phaser-v3/src/SpinePlugin.ts
-  var Phaser2 = __toESM(__require("Phaser"), 1);
-
-  // spine-phaser-v3/src/keys.ts
-  var SPINE_SKELETON_FILE_CACHE_KEY = "esotericsoftware.spine.skeletonFile.cache";
-  var SPINE_ATLAS_CACHE_KEY = "esotericsoftware.spine.atlas.cache";
-  var SPINE_SKELETON_DATA_FILE_TYPE = "spineSkeletonData";
-  var SPINE_ATLAS_FILE_TYPE = "spineAtlasData";
-  var SPINE_GAME_OBJECT_TYPE = "spine";
-
   // spine-core/src/Utils.ts
   var IntSet = class {
     array = new Array();
@@ -11522,6 +11512,250 @@ var spine = (() => {
     }
   })();
 
+  // spine-canvas/src/CanvasTexture.ts
+  var CanvasTexture = class extends Texture {
+    constructor(image) {
+      super(image);
+    }
+    setFilters(minFilter, magFilter) {
+    }
+    setWraps(uWrap, vWrap) {
+    }
+    dispose() {
+    }
+  };
+
+  // spine-canvas/src/SkeletonRenderer.ts
+  var worldVertices = Utils.newFloatArray(8);
+  var SkeletonRenderer = class _SkeletonRenderer {
+    static QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
+    static VERTEX_SIZE = 2 + 2 + 4;
+    ctx;
+    triangleRendering = false;
+    debugRendering = false;
+    vertices = Utils.newFloatArray(8 * 1024);
+    tempColor = new Color();
+    constructor(context) {
+      this.ctx = context;
+    }
+    draw(skeleton) {
+      if (this.triangleRendering) this.drawTriangles(skeleton);
+      else this.drawImages(skeleton);
+    }
+    drawImages(skeleton) {
+      let ctx = this.ctx;
+      let color = this.tempColor;
+      let skeletonColor = skeleton.color;
+      let drawOrder = skeleton.drawOrder;
+      if (this.debugRendering) ctx.strokeStyle = "green";
+      for (let i = 0, n = drawOrder.length; i < n; i++) {
+        let slot = drawOrder[i];
+        let bone = slot.bone;
+        if (!bone.active) continue;
+        let attachment = slot.getAttachment();
+        if (!(attachment instanceof RegionAttachment)) continue;
+        attachment.computeWorldVertices(slot, worldVertices, 0, 2);
+        let region = attachment.region;
+        let image = region.texture.getImage();
+        let slotColor = slot.color;
+        let regionColor = attachment.color;
+        color.set(
+          skeletonColor.r * slotColor.r * regionColor.r,
+          skeletonColor.g * slotColor.g * regionColor.g,
+          skeletonColor.b * slotColor.b * regionColor.b,
+          skeletonColor.a * slotColor.a * regionColor.a
+        );
+        ctx.save();
+        ctx.transform(bone.a, bone.c, bone.b, bone.d, bone.worldX, bone.worldY);
+        ctx.translate(attachment.offset[0], attachment.offset[1]);
+        ctx.rotate(attachment.rotation * Math.PI / 180);
+        let atlasScale = attachment.width / region.originalWidth;
+        ctx.scale(atlasScale * attachment.scaleX, atlasScale * attachment.scaleY);
+        let w = region.width, h = region.height;
+        ctx.translate(w / 2, h / 2);
+        if (attachment.region.degrees == 90) {
+          let t = w;
+          w = h;
+          h = t;
+          ctx.rotate(-Math.PI / 2);
+        }
+        ctx.scale(1, -1);
+        ctx.translate(-w / 2, -h / 2);
+        ctx.globalAlpha = color.a;
+        ctx.drawImage(image, image.width * region.u, image.height * region.v, w, h, 0, 0, w, h);
+        if (this.debugRendering) ctx.strokeRect(0, 0, w, h);
+        ctx.restore();
+      }
+    }
+    drawTriangles(skeleton) {
+      let ctx = this.ctx;
+      let color = this.tempColor;
+      let skeletonColor = skeleton.color;
+      let drawOrder = skeleton.drawOrder;
+      let blendMode = null;
+      let vertices = this.vertices;
+      let triangles = null;
+      for (let i = 0, n = drawOrder.length; i < n; i++) {
+        let slot = drawOrder[i];
+        let attachment = slot.getAttachment();
+        let texture;
+        let region;
+        if (attachment instanceof RegionAttachment) {
+          let regionAttachment = attachment;
+          vertices = this.computeRegionVertices(slot, regionAttachment, false);
+          triangles = _SkeletonRenderer.QUAD_TRIANGLES;
+          texture = regionAttachment.region.texture.getImage();
+        } else if (attachment instanceof MeshAttachment) {
+          let mesh = attachment;
+          vertices = this.computeMeshVertices(slot, mesh, false);
+          triangles = mesh.triangles;
+          texture = mesh.region.texture.getImage();
+        } else
+          continue;
+        if (texture) {
+          if (slot.data.blendMode != blendMode) blendMode = slot.data.blendMode;
+          let slotColor = slot.color;
+          let attachmentColor = attachment.color;
+          color.set(
+            skeletonColor.r * slotColor.r * attachmentColor.r,
+            skeletonColor.g * slotColor.g * attachmentColor.g,
+            skeletonColor.b * slotColor.b * attachmentColor.b,
+            skeletonColor.a * slotColor.a * attachmentColor.a
+          );
+          ctx.globalAlpha = color.a;
+          for (var j = 0; j < triangles.length; j += 3) {
+            let t1 = triangles[j] * 8, t2 = triangles[j + 1] * 8, t3 = triangles[j + 2] * 8;
+            let x0 = vertices[t1], y0 = vertices[t1 + 1], u0 = vertices[t1 + 6], v0 = vertices[t1 + 7];
+            let x1 = vertices[t2], y1 = vertices[t2 + 1], u1 = vertices[t2 + 6], v1 = vertices[t2 + 7];
+            let x2 = vertices[t3], y2 = vertices[t3 + 1], u2 = vertices[t3 + 6], v2 = vertices[t3 + 7];
+            this.drawTriangle(texture, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
+            if (this.debugRendering) {
+              ctx.strokeStyle = "green";
+              ctx.beginPath();
+              ctx.moveTo(x0, y0);
+              ctx.lineTo(x1, y1);
+              ctx.lineTo(x2, y2);
+              ctx.lineTo(x0, y0);
+              ctx.stroke();
+            }
+          }
+        }
+      }
+      this.ctx.globalAlpha = 1;
+    }
+    // Adapted from http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
+    // Apache 2 licensed
+    drawTriangle(img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2) {
+      let ctx = this.ctx;
+      const width = img.width - 1;
+      const height = img.height - 1;
+      u0 *= width;
+      v0 *= height;
+      u1 *= width;
+      v1 *= height;
+      u2 *= width;
+      v2 *= height;
+      ctx.beginPath();
+      ctx.moveTo(x0, y0);
+      ctx.lineTo(x1, y1);
+      ctx.lineTo(x2, y2);
+      ctx.closePath();
+      x1 -= x0;
+      y1 -= y0;
+      x2 -= x0;
+      y2 -= y0;
+      u1 -= u0;
+      v1 -= v0;
+      u2 -= u0;
+      v2 -= v0;
+      let det = u1 * v2 - u2 * v1;
+      if (det == 0) return;
+      det = 1 / det;
+      const a = (v2 * x1 - v1 * x2) * det;
+      const b = (v2 * y1 - v1 * y2) * det;
+      const c = (u1 * x2 - u2 * x1) * det;
+      const d = (u1 * y2 - u2 * y1) * det;
+      const e = x0 - a * u0 - c * v0;
+      const f = y0 - b * u0 - d * v0;
+      ctx.save();
+      ctx.transform(a, b, c, d, e, f);
+      ctx.clip();
+      ctx.drawImage(img, 0, 0);
+      ctx.restore();
+    }
+    computeRegionVertices(slot, region, pma) {
+      let skeletonColor = slot.bone.skeleton.color;
+      let slotColor = slot.color;
+      let regionColor = region.color;
+      let alpha = skeletonColor.a * slotColor.a * regionColor.a;
+      let multiplier = pma ? alpha : 1;
+      let color = this.tempColor;
+      color.set(
+        skeletonColor.r * slotColor.r * regionColor.r * multiplier,
+        skeletonColor.g * slotColor.g * regionColor.g * multiplier,
+        skeletonColor.b * slotColor.b * regionColor.b * multiplier,
+        alpha
+      );
+      region.computeWorldVertices(slot, this.vertices, 0, _SkeletonRenderer.VERTEX_SIZE);
+      let vertices = this.vertices;
+      let uvs = region.uvs;
+      vertices[RegionAttachment.C1R] = color.r;
+      vertices[RegionAttachment.C1G] = color.g;
+      vertices[RegionAttachment.C1B] = color.b;
+      vertices[RegionAttachment.C1A] = color.a;
+      vertices[RegionAttachment.U1] = uvs[0];
+      vertices[RegionAttachment.V1] = uvs[1];
+      vertices[RegionAttachment.C2R] = color.r;
+      vertices[RegionAttachment.C2G] = color.g;
+      vertices[RegionAttachment.C2B] = color.b;
+      vertices[RegionAttachment.C2A] = color.a;
+      vertices[RegionAttachment.U2] = uvs[2];
+      vertices[RegionAttachment.V2] = uvs[3];
+      vertices[RegionAttachment.C3R] = color.r;
+      vertices[RegionAttachment.C3G] = color.g;
+      vertices[RegionAttachment.C3B] = color.b;
+      vertices[RegionAttachment.C3A] = color.a;
+      vertices[RegionAttachment.U3] = uvs[4];
+      vertices[RegionAttachment.V3] = uvs[5];
+      vertices[RegionAttachment.C4R] = color.r;
+      vertices[RegionAttachment.C4G] = color.g;
+      vertices[RegionAttachment.C4B] = color.b;
+      vertices[RegionAttachment.C4A] = color.a;
+      vertices[RegionAttachment.U4] = uvs[6];
+      vertices[RegionAttachment.V4] = uvs[7];
+      return vertices;
+    }
+    computeMeshVertices(slot, mesh, pma) {
+      let skeletonColor = slot.bone.skeleton.color;
+      let slotColor = slot.color;
+      let regionColor = mesh.color;
+      let alpha = skeletonColor.a * slotColor.a * regionColor.a;
+      let multiplier = pma ? alpha : 1;
+      let color = this.tempColor;
+      color.set(
+        skeletonColor.r * slotColor.r * regionColor.r * multiplier,
+        skeletonColor.g * slotColor.g * regionColor.g * multiplier,
+        skeletonColor.b * slotColor.b * regionColor.b * multiplier,
+        alpha
+      );
+      let vertexCount = mesh.worldVerticesLength / 2;
+      let vertices = this.vertices;
+      if (vertices.length < mesh.worldVerticesLength) this.vertices = vertices = Utils.newFloatArray(mesh.worldVerticesLength);
+      mesh.computeWorldVertices(slot, 0, mesh.worldVerticesLength, vertices, 0, _SkeletonRenderer.VERTEX_SIZE);
+      let uvs = mesh.uvs;
+      for (let i = 0, u = 0, v = 2; i < vertexCount; i++) {
+        vertices[v++] = color.r;
+        vertices[v++] = color.g;
+        vertices[v++] = color.b;
+        vertices[v++] = color.a;
+        vertices[v++] = uvs[u++];
+        vertices[v++] = uvs[u++];
+        v += 2;
+      }
+      return vertices;
+    }
+  };
+
   // spine-webgl/src/WebGL.ts
   var ManagedWebGLRenderingContext = class {
     canvas;
@@ -13360,7 +13594,7 @@ void main () {
       this.numFloats = numFloats;
     }
   };
-  var SkeletonRenderer = class _SkeletonRenderer {
+  var SkeletonRenderer2 = class _SkeletonRenderer {
     static QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
     premultipliedAlpha = false;
     tempColor = new Color();
@@ -13578,7 +13812,7 @@ void main () {
       this.batcher = new PolygonBatcher(this.context, twoColorTint);
       this.shapesShader = Shader.newColored(this.context);
       this.shapes = new ShapeRenderer(this.context);
-      this.skeletonRenderer = new SkeletonRenderer(this.context, twoColorTint);
+      this.skeletonRenderer = new SkeletonRenderer2(this.context, twoColorTint);
       this.skeletonDebugRenderer = new SkeletonDebugRenderer(this.context);
     }
     dispose() {
@@ -14178,6 +14412,16 @@ void main () {
     }
   };
 
+  // spine-phaser-v3/src/SpinePlugin.ts
+  var Phaser2 = __toESM(__require("Phaser"), 1);
+
+  // spine-phaser-v3/src/keys.ts
+  var SPINE_SKELETON_FILE_CACHE_KEY = "esotericsoftware.spine.skeletonFile.cache";
+  var SPINE_ATLAS_CACHE_KEY = "esotericsoftware.spine.atlas.cache";
+  var SPINE_SKELETON_DATA_FILE_TYPE = "spineSkeletonData";
+  var SPINE_ATLAS_FILE_TYPE = "spineAtlasData";
+  var SPINE_GAME_OBJECT_TYPE = "spine";
+
   // spine-phaser-v3/src/mixins.ts
   var components = Phaser.GameObjects.Components;
   var ComputedSize = components.ComputedSize;
@@ -14462,251 +14706,8 @@ void main () {
     }
   };
 
-  // spine-canvas/src/CanvasTexture.ts
-  var CanvasTexture = class extends Texture {
-    constructor(image) {
-      super(image);
-    }
-    setFilters(minFilter, magFilter) {
-    }
-    setWraps(uWrap, vWrap) {
-    }
-    dispose() {
-    }
-  };
-
-  // spine-canvas/src/SkeletonRenderer.ts
-  var worldVertices = Utils.newFloatArray(8);
-  var SkeletonRenderer2 = class _SkeletonRenderer {
-    static QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
-    static VERTEX_SIZE = 2 + 2 + 4;
-    ctx;
-    triangleRendering = false;
-    debugRendering = false;
-    vertices = Utils.newFloatArray(8 * 1024);
-    tempColor = new Color();
-    constructor(context) {
-      this.ctx = context;
-    }
-    draw(skeleton) {
-      if (this.triangleRendering) this.drawTriangles(skeleton);
-      else this.drawImages(skeleton);
-    }
-    drawImages(skeleton) {
-      let ctx = this.ctx;
-      let color = this.tempColor;
-      let skeletonColor = skeleton.color;
-      let drawOrder = skeleton.drawOrder;
-      if (this.debugRendering) ctx.strokeStyle = "green";
-      for (let i = 0, n = drawOrder.length; i < n; i++) {
-        let slot = drawOrder[i];
-        let bone = slot.bone;
-        if (!bone.active) continue;
-        let attachment = slot.getAttachment();
-        if (!(attachment instanceof RegionAttachment)) continue;
-        attachment.computeWorldVertices(slot, worldVertices, 0, 2);
-        let region = attachment.region;
-        let image = region.texture.getImage();
-        let slotColor = slot.color;
-        let regionColor = attachment.color;
-        color.set(
-          skeletonColor.r * slotColor.r * regionColor.r,
-          skeletonColor.g * slotColor.g * regionColor.g,
-          skeletonColor.b * slotColor.b * regionColor.b,
-          skeletonColor.a * slotColor.a * regionColor.a
-        );
-        ctx.save();
-        ctx.transform(bone.a, bone.c, bone.b, bone.d, bone.worldX, bone.worldY);
-        ctx.translate(attachment.offset[0], attachment.offset[1]);
-        ctx.rotate(attachment.rotation * Math.PI / 180);
-        let atlasScale = attachment.width / region.originalWidth;
-        ctx.scale(atlasScale * attachment.scaleX, atlasScale * attachment.scaleY);
-        let w = region.width, h = region.height;
-        ctx.translate(w / 2, h / 2);
-        if (attachment.region.degrees == 90) {
-          let t = w;
-          w = h;
-          h = t;
-          ctx.rotate(-Math.PI / 2);
-        }
-        ctx.scale(1, -1);
-        ctx.translate(-w / 2, -h / 2);
-        ctx.globalAlpha = color.a;
-        ctx.drawImage(image, image.width * region.u, image.height * region.v, w, h, 0, 0, w, h);
-        if (this.debugRendering) ctx.strokeRect(0, 0, w, h);
-        ctx.restore();
-      }
-    }
-    drawTriangles(skeleton) {
-      let ctx = this.ctx;
-      let color = this.tempColor;
-      let skeletonColor = skeleton.color;
-      let drawOrder = skeleton.drawOrder;
-      let blendMode = null;
-      let vertices = this.vertices;
-      let triangles = null;
-      for (let i = 0, n = drawOrder.length; i < n; i++) {
-        let slot = drawOrder[i];
-        let attachment = slot.getAttachment();
-        let texture;
-        let region;
-        if (attachment instanceof RegionAttachment) {
-          let regionAttachment = attachment;
-          vertices = this.computeRegionVertices(slot, regionAttachment, false);
-          triangles = _SkeletonRenderer.QUAD_TRIANGLES;
-          texture = regionAttachment.region.texture.getImage();
-        } else if (attachment instanceof MeshAttachment) {
-          let mesh = attachment;
-          vertices = this.computeMeshVertices(slot, mesh, false);
-          triangles = mesh.triangles;
-          texture = mesh.region.texture.getImage();
-        } else
-          continue;
-        if (texture) {
-          if (slot.data.blendMode != blendMode) blendMode = slot.data.blendMode;
-          let slotColor = slot.color;
-          let attachmentColor = attachment.color;
-          color.set(
-            skeletonColor.r * slotColor.r * attachmentColor.r,
-            skeletonColor.g * slotColor.g * attachmentColor.g,
-            skeletonColor.b * slotColor.b * attachmentColor.b,
-            skeletonColor.a * slotColor.a * attachmentColor.a
-          );
-          ctx.globalAlpha = color.a;
-          for (var j = 0; j < triangles.length; j += 3) {
-            let t1 = triangles[j] * 8, t2 = triangles[j + 1] * 8, t3 = triangles[j + 2] * 8;
-            let x0 = vertices[t1], y0 = vertices[t1 + 1], u0 = vertices[t1 + 6], v0 = vertices[t1 + 7];
-            let x1 = vertices[t2], y1 = vertices[t2 + 1], u1 = vertices[t2 + 6], v1 = vertices[t2 + 7];
-            let x2 = vertices[t3], y2 = vertices[t3 + 1], u2 = vertices[t3 + 6], v2 = vertices[t3 + 7];
-            this.drawTriangle(texture, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
-            if (this.debugRendering) {
-              ctx.strokeStyle = "green";
-              ctx.beginPath();
-              ctx.moveTo(x0, y0);
-              ctx.lineTo(x1, y1);
-              ctx.lineTo(x2, y2);
-              ctx.lineTo(x0, y0);
-              ctx.stroke();
-            }
-          }
-        }
-      }
-      this.ctx.globalAlpha = 1;
-    }
-    // Adapted from http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
-    // Apache 2 licensed
-    drawTriangle(img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2) {
-      let ctx = this.ctx;
-      const width = img.width - 1;
-      const height = img.height - 1;
-      u0 *= width;
-      v0 *= height;
-      u1 *= width;
-      v1 *= height;
-      u2 *= width;
-      v2 *= height;
-      ctx.beginPath();
-      ctx.moveTo(x0, y0);
-      ctx.lineTo(x1, y1);
-      ctx.lineTo(x2, y2);
-      ctx.closePath();
-      x1 -= x0;
-      y1 -= y0;
-      x2 -= x0;
-      y2 -= y0;
-      u1 -= u0;
-      v1 -= v0;
-      u2 -= u0;
-      v2 -= v0;
-      let det = u1 * v2 - u2 * v1;
-      if (det == 0) return;
-      det = 1 / det;
-      const a = (v2 * x1 - v1 * x2) * det;
-      const b = (v2 * y1 - v1 * y2) * det;
-      const c = (u1 * x2 - u2 * x1) * det;
-      const d = (u1 * y2 - u2 * y1) * det;
-      const e = x0 - a * u0 - c * v0;
-      const f = y0 - b * u0 - d * v0;
-      ctx.save();
-      ctx.transform(a, b, c, d, e, f);
-      ctx.clip();
-      ctx.drawImage(img, 0, 0);
-      ctx.restore();
-    }
-    computeRegionVertices(slot, region, pma) {
-      let skeletonColor = slot.bone.skeleton.color;
-      let slotColor = slot.color;
-      let regionColor = region.color;
-      let alpha = skeletonColor.a * slotColor.a * regionColor.a;
-      let multiplier = pma ? alpha : 1;
-      let color = this.tempColor;
-      color.set(
-        skeletonColor.r * slotColor.r * regionColor.r * multiplier,
-        skeletonColor.g * slotColor.g * regionColor.g * multiplier,
-        skeletonColor.b * slotColor.b * regionColor.b * multiplier,
-        alpha
-      );
-      region.computeWorldVertices(slot, this.vertices, 0, _SkeletonRenderer.VERTEX_SIZE);
-      let vertices = this.vertices;
-      let uvs = region.uvs;
-      vertices[RegionAttachment.C1R] = color.r;
-      vertices[RegionAttachment.C1G] = color.g;
-      vertices[RegionAttachment.C1B] = color.b;
-      vertices[RegionAttachment.C1A] = color.a;
-      vertices[RegionAttachment.U1] = uvs[0];
-      vertices[RegionAttachment.V1] = uvs[1];
-      vertices[RegionAttachment.C2R] = color.r;
-      vertices[RegionAttachment.C2G] = color.g;
-      vertices[RegionAttachment.C2B] = color.b;
-      vertices[RegionAttachment.C2A] = color.a;
-      vertices[RegionAttachment.U2] = uvs[2];
-      vertices[RegionAttachment.V2] = uvs[3];
-      vertices[RegionAttachment.C3R] = color.r;
-      vertices[RegionAttachment.C3G] = color.g;
-      vertices[RegionAttachment.C3B] = color.b;
-      vertices[RegionAttachment.C3A] = color.a;
-      vertices[RegionAttachment.U3] = uvs[4];
-      vertices[RegionAttachment.V3] = uvs[5];
-      vertices[RegionAttachment.C4R] = color.r;
-      vertices[RegionAttachment.C4G] = color.g;
-      vertices[RegionAttachment.C4B] = color.b;
-      vertices[RegionAttachment.C4A] = color.a;
-      vertices[RegionAttachment.U4] = uvs[6];
-      vertices[RegionAttachment.V4] = uvs[7];
-      return vertices;
-    }
-    computeMeshVertices(slot, mesh, pma) {
-      let skeletonColor = slot.bone.skeleton.color;
-      let slotColor = slot.color;
-      let regionColor = mesh.color;
-      let alpha = skeletonColor.a * slotColor.a * regionColor.a;
-      let multiplier = pma ? alpha : 1;
-      let color = this.tempColor;
-      color.set(
-        skeletonColor.r * slotColor.r * regionColor.r * multiplier,
-        skeletonColor.g * slotColor.g * regionColor.g * multiplier,
-        skeletonColor.b * slotColor.b * regionColor.b * multiplier,
-        alpha
-      );
-      let vertexCount = mesh.worldVerticesLength / 2;
-      let vertices = this.vertices;
-      if (vertices.length < mesh.worldVerticesLength) this.vertices = vertices = Utils.newFloatArray(mesh.worldVerticesLength);
-      mesh.computeWorldVertices(slot, 0, mesh.worldVerticesLength, vertices, 0, _SkeletonRenderer.VERTEX_SIZE);
-      let uvs = mesh.uvs;
-      for (let i = 0, u = 0, v = 2; i < vertexCount; i++) {
-        vertices[v++] = color.r;
-        vertices[v++] = color.g;
-        vertices[v++] = color.b;
-        vertices[v++] = color.a;
-        vertices[v++] = uvs[u++];
-        vertices[v++] = uvs[u++];
-        v += 2;
-      }
-      return vertices;
-    }
-  };
-
   // spine-phaser-v3/src/SpinePlugin.ts
+  Skeleton.yDown = true;
   var SpinePlugin = class _SpinePlugin extends Phaser2.Plugins.ScenePlugin {
     game;
     isWebGL;
@@ -14780,29 +14781,25 @@ void main () {
     }
     static rendererId = 0;
     boot() {
-      Skeleton.yDown = true;
-      if (this.isWebGL) {
-        if (!_SpinePlugin.gameWebGLRenderer) {
-          _SpinePlugin.gameWebGLRenderer = new SceneRenderer(this.game.renderer.canvas, this.gl, true);
-        }
-        this.onResize();
-        this.game.scale.on(Phaser2.Scale.Events.RESIZE, this.onResize, this);
-      } else {
-        if (!this.canvasRenderer) {
-          this.canvasRenderer = new SkeletonRenderer2(this.scene.sys.context);
-        }
+      if (this.isWebGL && this.gl) {
+        _SpinePlugin.gameWebGLRenderer ||= new SceneRenderer(this.game.renderer.canvas, this.gl, true);
+      } else if (this.scene) {
+        this.canvasRenderer ||= new SkeletonRenderer(this.scene.sys.context);
+      }
+      this.onResize();
+      if (this.systems) {
+        this.systems.events.once("destroy", this.destroy, this);
+        this.systems.events.on("start", this.onStart, this);
+        this.systems.events.on("shutdown", this.shutdown, this);
       }
-      var eventEmitter = this.systems.events;
-      eventEmitter.once("shutdown", this.shutdown, this);
-      eventEmitter.once("destroy", this.destroy, this);
       this.game.events.once("destroy", this.gameDestroy, this);
     }
     onResize() {
-      var phaserRenderer = this.game.renderer;
-      var sceneRenderer = this.webGLRenderer;
+      const phaserRenderer = this.game.renderer;
+      const sceneRenderer = this.webGLRenderer;
       if (phaserRenderer && sceneRenderer) {
-        var viewportWidth = phaserRenderer.width;
-        var viewportHeight = phaserRenderer.height;
+        const viewportWidth = phaserRenderer.width;
+        const viewportHeight = phaserRenderer.height;
         sceneRenderer.camera.position.x = viewportWidth / 2;
         sceneRenderer.camera.position.y = viewportHeight / 2;
         sceneRenderer.camera.up.y = -1;
@@ -14810,14 +14807,18 @@ void main () {
         sceneRenderer.camera.setViewport(viewportWidth, viewportHeight);
       }
     }
+    onStart() {
+      this.game.scale.on(Phaser2.Scale.Events.RESIZE, this.onResize, this);
+    }
     shutdown() {
-      this.systems.events.off("shutdown", this.shutdown, this);
       if (this.isWebGL) {
         this.game.scale.off(Phaser2.Scale.Events.RESIZE, this.onResize, this);
       }
     }
     destroy() {
       this.shutdown();
+      this.systems?.events.off("start", this.onStart, this);
+      this.systems?.events.off("shutdown", this.shutdown, this);
     }
     gameDestroy() {
       this.pluginManager.removeGameObject(window.SPINE_GAME_OBJECT_TYPE ? window.SPINE_GAME_OBJECT_TYPE : SPINE_GAME_OBJECT_TYPE, true, true);