@esotericsoftware/spine-phaser-v3 4.2.90 → 4.2.92

package/dist/esm/spine-phaser-v3.mjs

@@ -7,16 +7,6 @@ if (typeof window !== "undefined" && window.Phaser) {
   };
 }
 
-// spine-phaser-v3/src/SpinePlugin.ts
-import * as Phaser2 from "Phaser";
-
-// 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();
@@ -11299,6 +11289,250 @@ function getValue(map, property, defaultValue) {
   }
 })();
 
+// 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;
@@ -13137,7 +13371,7 @@ var Renderable = class {
     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();
@@ -13355,7 +13589,7 @@ var SceneRenderer = class {
     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() {
@@ -13955,6 +14189,16 @@ var SpineCanvas = class {
   }
 };
 
+// spine-phaser-v3/src/SpinePlugin.ts
+import * as Phaser2 from "Phaser";
+
+// 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;
@@ -14239,251 +14483,8 @@ var SpineGameObject = class extends DepthMixin(
   }
 };
 
-// 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;
@@ -14557,29 +14558,25 @@ var SpinePlugin = class _SpinePlugin extends Phaser2.Plugins.ScenePlugin {
   }
   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;
@@ -14587,14 +14584,18 @@ var SpinePlugin = class _SpinePlugin extends Phaser2.Plugins.ScenePlugin {
       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);
@@ -14907,7 +14908,7 @@ export {
   SkeletonData,
   SkeletonDebugRenderer,
   SkeletonJson,
-  SkeletonRenderer,
+  SkeletonRenderer2 as SkeletonRenderer,
   Skin,
   SkinEntry,
   SkinsAndAnimationBoundsProvider,