@melonjs/spine-plugin 2.2.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 3.0.0 - _2026-06-14_
+
+### **BREAKING CHANGES**
+
+- **Spine 4.3 editor required** — bundled Spine runtimes bumped from `^4.2.114` to `^4.3.7`. The 4.2 and 4.3 skeleton data formats are incompatible both ways: existing `.json`/`.skel` exports must be re-exported from a Spine 4.3 editor, and 4.3 exports will not load on plugin 2.x
+- the plugin now sets `Skeleton.yDown = true` (the official 4.3 Y-down switch, same approach as Spine's own pixi/phaser/canvaskit integrations). Code that reached into `spineObject.skeleton` and compensated for the old manual Y-flip (root bone `scaleY = -1`, inverted physics gravity) must drop those workarounds — the runtime now handles Y-down natively
+- Spine 4.3 moved bone/slot state into poses: code accessing `bone.x/.scaleX/.worldX` etc. through `spineObject.skeleton` must use `bone.pose.*` (unconstrained, for writing) or `bone.appliedPose.*` (constrained, for reading world transforms); `slot.color`/`slot.getAttachment()` are now `slot.appliedPose.color`/`slot.appliedPose.attachment`
+- other 4.3 core renames that surface through `spineObject.skeleton`: `setToSetupPose()` → `setupPose()`, `physicsConstraints` → `physics`, `MixBlend`/`MixDirection` removed (use `TrackEntry.additive`), `MeshAttachment.getParentMesh()` → `getSourceMesh()`. The plugin's own `Spine.setToSetupPose()` wrapper keeps its name
+
+### Added
+
+- Spine 4.3 feature support inherited with the runtime bump: slider constraints, sequence timelines, non-linear animation mixing (`TrackEntry.mixInterpolation`), convex/inverse clipping, physics force direction vectors (`skeleton.windX/Y`, `gravityX/Y`)
+- **WebGL context-loss recovery** — the plugin now survives a `webglcontextlost`/`webglcontextrestored` cycle (melonJS ≥ 19.7 recovery machinery): `SpineBatcher` builds its GPU resources in `init()` so the renderer's restore path can re-create them, and all spine GL resources (atlas textures, debug pipeline) are funneled through a single shared canvas-backed `ManagedWebGLRenderingContext` so spine's own restorables actually fire (a managed context built from a raw GL context has no element to listen on and silently never restores)
+
+### Changed
+
+- minimum melonJS version is now **19.7.1** (was 18.3.0) — required for the WebGL context-loss restore + blend-cache invalidation fix the plugin's recovery path relies on
+- skeleton positioning now goes through `skeleton.x/y` instead of writing to the root bone pose — root-bone-relative user code (e.g. custom bone offsets) is unaffected
+- `flipX()`/`flipY()` JSDoc corrected: flipping is around the root bone, not the visual center (behavior unchanged, was always root-relative)
+- mesh auto-detection for the canvas renderer now uses the public `Skin.getAttachments()` API instead of walking spine's internal `skin.attachments` array
+
+### Performance
+
+- Canvas `SkeletonRenderer` mesh vertex buffer slimmed from 8 floats per vertex down to 2 (positions only) — first removed the 4 dead per-vertex color floats (canvas tinting is applied per slot via `setTint()`/`setGlobalAlpha()`), then dropped the UV interleave entirely (UVs now read straight from `sequence.getUVs(index)` in `drawMesh`). Halves the buffer twice over, eliminates a per-vertex copy pass, and removes the dedicated `computeMeshVertices` method. Verified pixel-identical across all 15 example skeletons (cold-start harness drift falls in the same noise floor with the change applied or not)
+
+### Fixed
+
+- Canvas `SkeletonRenderer` no longer corrupts mesh vertex data while a `ClippingAttachment` is active — the stride-2 "clipped vertex size" was inherited from spine-webgl's `clipTriangles` repacking, which the canvas path never performs: positions were written at stride 2 then read at the full vertex stride, scrambling any mesh drawn inside an active clip (latent since the 4.2 plugin; canvas meshes are clipped per-triangle, so no example skeleton ever exposed it)
+- Canvas `SkeletonRenderer` now uses `color.alpha` (the melonJS `Color` accessor) instead of `color.a`, which was always `undefined`. Canvas's `globalAlpha = undefined` is silently ignored, so slot-alpha animation never faded attachments — the canvas renderer behaved as if every slot were fully opaque. Visible on `powerup` (the trailing stars stayed at full opacity instead of fading) and any other skeleton with slot-alpha keyframes
+- Canvas `SkeletonRenderer` correctly handles atlas regions packed at 90° rotation (`region.degrees === 90`) — the `translate(-w/2, -h/2)` after the dimension swap was using the *pre-swap* half-dimensions, so any attachment whose texture region was rotated in the atlas drew with its quad offset by `±(w−h)/2`. Visible as the tank turret floating detached from the chassis and the raptor rider's visor tilted off his head on canvas (WebGL was unaffected). Now matches the official `spine-canvas` SkeletonRenderer math by re-deriving the halves from post-swap `w`/`h`
+
+### Removed
+
+- all manual Y-down plumbing made obsolete by `Skeleton.yDown`: the root-bone `scaleY` inversion in `setToSetupPose()`, the per-constraint physics gravity flip in `setSkeleton()`, and the `+90°` Canvas rotation offset in `rotate()`
+
+## 2.2.1 - 2026-05-11
+
+### Changed
+- Bump bundled Spine runtimes (`@esotericsoftware/spine-canvas`, `@esotericsoftware/spine-core`, `@esotericsoftware/spine-webgl`) range from `^4.2.109` to `^4.2.114`. Picks up the empty-atlas hang fix in `AssetManagerBase` (4.2.113) — `loadTextureAtlas` no longer waits forever on an atlas with zero pages. No plugin API change.
+
 ## 2.2.0 - 2026-04-15
 
 ### Added

package/README.md

@@ -1,20 +1,20 @@
 # melonJS Spine Plugin
 
-A [Spine](http://en.esotericsoftware.com/spine-in-depth) 4.2 runtime integration for the [melonJS](http://www.melonjs.org) game engine, using the official [@esotericsoftware/spine-webgl](https://www.npmjs.com/package/@esotericsoftware/spine-webgl) and [@esotericsoftware/spine-canvas](https://www.npmjs.com/package/@esotericsoftware/spine-canvas) runtimes.
+A [Spine](http://en.esotericsoftware.com/spine-in-depth) 4.x runtime integration for the [melonJS](http://www.melonjs.org) game engine, using the official [@esotericsoftware/spine-webgl](https://www.npmjs.com/package/@esotericsoftware/spine-webgl) and [@esotericsoftware/spine-canvas](https://www.npmjs.com/package/@esotericsoftware/spine-canvas) runtimes.
 
 ![melonjs-spine-gif](https://github.com/melonjs/spine-plugin/assets/4033090/dc259c8e-def6-419e-83a9-cda374715686)
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/melonjs/melonJS/blob/master/packages/spine-plugin/LICENSE)
 [![NPM Package](https://img.shields.io/npm/v/@melonjs/spine-plugin)](https://www.npmjs.com/package/@melonjs/spine-plugin)
-[![Spine Runtime](https://img.shields.io/badge/spine--runtime-4.2-orange)](http://esotericsoftware.com/spine-runtimes)
+[![Spine Runtime](https://img.shields.io/badge/spine--runtime-4.3-orange)](http://esotericsoftware.com/spine-runtimes)
 
-[Live Example](https://melonjs.github.io/melonJS/examples/#/spine) — 17 official Spine characters including spineboy, raptor, owl, dragon, and more
+[Live Example](https://melonjs.github.io/melonJS/examples/#/spine) — 15 official Spine characters including spineboy, raptor, owl, dragon, and more
 
 ## Features
 -------------------------------------------------------------------------------
 - **WebGL rendering** via custom `SpineBatcher` extending melonJS `Batcher` with two-color tinting and indexed drawing
 - **Canvas rendering** with full mesh, clipping, tinting, and blend mode support
-- **Spine 4.2 physics** support with automatic gravity correction for Y-down coordinate system
+- **Spine physics** support — native Y-down handling via the official `Skeleton.yDown` runtime switch, including physics force direction vectors (`windX/Y`, `gravityX/Y`)
 - **Two-color tinting** (dark/light color) using Spine's official shader
 - **Blend modes** (Normal, Additive, Multiply, Screen) with premultiplied alpha support
 - **Clipping attachments** via melonJS masking (canvas) and Spine's SkeletonClipping (WebGL)
@@ -30,7 +30,7 @@ A [Spine](http://en.esotericsoftware.com/spine-in-depth) 4.2 runtime integration
 ## Installation
 -------------------------------------------------------------------------------
 This plugin is already bundled with the required Spine [4.x runtime](package.json#dependencies), so there is no need to install it separately.
->Note: this plugin requires melonJS version 18.3.0 or higher.
+>Note: this plugin requires melonJS version 19.7.1 or higher.
 
 To install the plugin using npm:
 
@@ -125,12 +125,15 @@ me.loader.preload(DataManifest, function() {
 
 | @melonjs/spine-plugin | melonJS | spine-runtime |
 |---|---|---|
+| v3.0.0 | v19.7.1 (or higher) | v4.3.x |
 | v2.2.0 | v18.3.0 (or higher) | v4.2.x |
 | v2.1.0 | v18.3.0 (or higher) | v4.2.x |
 | v2.0.1 | v18.2.1 (or higher) | v4.2.x |
 | v2.0.0 | v18.2.0 | v4.2.x |
 | v1.5.x | v15.12.x — v18.0.x | v4.1, v4.2-beta |
 
+> **Note:** skeleton data is editor-version locked — plugin 3.x requires assets exported from a Spine **4.3** editor; 4.2 exports will not load (and vice-versa on plugin 2.x).
+
 ## Questions, need help ?
 -------------------------------------------------------------------------------
 If you need technical support, you can contact us through the following channels:

package/build/AssetManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../src/AssetManager.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IACC;;;OAGG;IACH,sBAHW,cAAc,GAAC,aAAa,eAC5B,MAAM,EA0ChB;IAvCA;;;OAGG;IACH,sEAG4C;IAkC7C;;;OAGG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,iBARW,MAAM,QACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,iBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,eAJW,MAAM,+CAMhB;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,GAAC,CAIb;IAED;;OAEG;IACH,gBAEC;CACD;4BA3I2B,+BAA+B;6BAD9B,gCAAgC"}
+{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../src/AssetManager.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IACC;;;OAGG;IACH,sBAHW,cAAc,GAAC,aAAa,eAC5B,MAAM,EA+ChB;IA5CA;;;OAGG;IACH,sEAQ4C;IAkC7C;;;OAGG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,iBARW,MAAM,QACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,iBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,eAJW,MAAM,+CAMhB;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,GAAC,CAIb;IAED;;OAEG;IACH,gBAEC;CACD;4BAjJ2B,+BAA+B;6BAD9B,gCAAgC"}

package/build/SkeletonRenderer.d.ts

@@ -28,7 +28,6 @@ export default class SkeletonRenderer {
      */
     premultipliedAlpha: boolean;
     tintColor: MColor;
-    tempColor: MColor;
     clipper: SkeletonClipping;
     clippingVertices: any[];
     clippingMask: Polygon;
@@ -44,38 +43,31 @@ export default class SkeletonRenderer {
      * @param {HTMLImageElement} image
      * @param {Bone} bone
      * @param {RegionAttachment} attachment
+     * @param {SlotPose} slotPose - the slot's applied pose (resolves sequence offsets)
      * @param {TextureRegion} region
      * @param {Polygon|null} mask - clipping mask if active
      * @param {boolean} debug - whether to draw debug outline
      * @ignore
      */
-    drawRegion(renderer: CanvasRenderer, image: HTMLImageElement, bone: Bone, attachment: RegionAttachment, region: TextureRegion, mask: Polygon | null, debug: boolean): void;
+    drawRegion(renderer: CanvasRenderer, image: HTMLImageElement, bone: Bone, attachment: RegionAttachment, slotPose: SlotPose, region: TextureRegion, mask: Polygon | null, debug: boolean): void;
     /**
      * Draw a mesh attachment as a series of textured triangles.
      * @param {CanvasRenderer} renderer
      * @param {HTMLImageElement} image
-     * @param {Float32Array} vertices - world vertices
+     * @param {Float32Array} vertices - world positions, stride 2 (x, y per vertex)
+     * @param {NumberArrayLike} uvs - atlas UVs from `sequence.getUVs(index)`, stride 2
      * @param {number[]} triangles - triangle indices
      * @ignore
      */
-    drawMesh(renderer: CanvasRenderer, image: HTMLImageElement, vertices: Float32Array, triangles: number[]): void;
+    drawMesh(renderer: CanvasRenderer, image: HTMLImageElement, vertices: Float32Array, uvs: NumberArrayLike, triangles: number[]): void;
     /**
      * Draw a single textured triangle using affine transform.
      * @ignore
      */
     drawTriangle(renderer: any, img: any, x0: any, y0: any, u0: any, v0: any, x1: any, y1: any, u1: any, v1: any, x2: any, y2: any, u2: any, v2: any): void;
-    /**
-     * Compute world vertices for a mesh attachment with color and UV data.
-     * @param {Slot} slot
-     * @param {MeshAttachment} mesh
-     * @param {number} vertexSize - floats per vertex
-     * @ignore
-     */
-    computeMeshVertices(slot: Slot, mesh: MeshAttachment, vertexSize: number): void;
 }
 import { Color as MColor } from "melonjs";
 import { SkeletonClipping } from "@esotericsoftware/spine-core";
 import { Polygon } from "melonjs";
 import { RegionAttachment } from "@esotericsoftware/spine-core";
-import { MeshAttachment } from "@esotericsoftware/spine-core";
 //# sourceMappingURL=SkeletonRenderer.d.ts.map

package/build/SkeletonRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SkeletonRenderer.d.ts","sourceRoot":"","sources":["../src/SkeletonRenderer.js"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH;IACC;;;;;;;OAOG;IACH,mBAHU,OAAO,CAGS;IAE1B;;;;OAIG;IACH,gBAHU,OAAO,CAGM;IAEvB;;;;OAIG;IACH,oBAHU,OAAO,CAGU;IAG3B,kBAAyB;IACzB,kBAAyB;IAGzB,0BAAiC;IACjC,wBAAsB;IACtB,sBAIG;IAEH;;;;OAIG;IACH,eAHW,cAAc,YACd,QAAQ,QAoGlB;IAED;;;;;;;;;;OAUG;IACH,qBATW,cAAc,SACd,gBAAgB,QAChB,IAAI,cACJ,gBAAgB,UAChB,aAAa,QACb,OAAO,GAAC,IAAI,SACZ,OAAO,QAqDjB;IAED;;;;;;;OAOG;IACH,mBANW,cAAc,SACd,gBAAgB,YAChB,YAAY,aACZ,MAAM,EAAE,QA8BlB;IAED;;;OAGG;IACH,wJA2CC;IAED;;;;;;OAMG;IACH,0BALW,IAAI,QACJ,cAAc,cACd,MAAM,QAwChB;CACD;gCA5WuD,SAAS;iCAD1D,8BAA8B;wBACmB,SAAS;iCAD1D,8BAA8B;+BAA9B,8BAA8B"}
+{"version":3,"file":"SkeletonRenderer.d.ts","sourceRoot":"","sources":["../src/SkeletonRenderer.js"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH;IACC;;;;;;;OAOG;IACH,mBAHU,OAAO,CAGS;IAE1B;;;;OAIG;IACH,gBAHU,OAAO,CAGM;IAEvB;;;;OAIG;IACH,oBAHU,OAAO,CAGU;IAG3B,kBAAyB;IAGzB,0BAAiC;IACjC,wBAAsB;IACtB,sBAIG;IAEH;;;;OAIG;IACH,eAHW,cAAc,YACd,QAAQ,QA2HlB;IAED;;;;;;;;;;;OAWG;IACH,qBAVW,cAAc,SACd,gBAAgB,QAChB,IAAI,cACJ,gBAAgB,YAChB,QAAQ,UACR,aAAa,QACb,OAAO,GAAC,IAAI,SACZ,OAAO,QAiEjB;IAED;;;;;;;;OAQG;IACH,mBAPW,cAAc,SACd,gBAAgB,YAChB,YAAY,OACZ,eAAe,aACf,MAAM,EAAE,QA8BlB;IAED;;;OAGG;IACH,wJA2CC;CACD;gCAnWuD,SAAS;iCAD1D,8BAA8B;wBACmB,SAAS;iCAD1D,8BAA8B"}

package/build/Spine.d.ts

@@ -79,7 +79,6 @@ export default class Spine extends Renderable {
     currentTrack: TrackEntry;
     /** @ignore */
     isWebGL: boolean;
-    canvas: any;
     spineBatcher: any;
     shapesShader: spineWebGL.Shader | undefined;
     shapes: spineWebGL.ShapeRenderer | undefined;
@@ -115,13 +114,13 @@ export default class Spine extends Renderable {
     setSkeleton(atlasFile: string, jsonFile: string): void;
     premultipliedAlpha: any;
     /**
-     * Flip the Spine skeleton on the horizontal axis (around its center).
+     * Flip the Spine skeleton on the horizontal axis (around its root bone).
      * @param {boolean} [flip=true] - `true` to flip this Spine object.
      * @returns {Spine} Reference to this object for method chaining
      */
     flipX(flip?: boolean): Spine;
     /**
-     * Flip the Spine skeleton on the vertical axis (around its center).
+     * Flip the Spine skeleton on the vertical axis (around its root bone).
      * @param {boolean} [flip=true] - `true` to flip this Spine object.
      * @returns {Spine} Reference to this object for method chaining
      */
@@ -153,6 +152,12 @@ export default class Spine extends Renderable {
      * Called automatically when the renderable is removed from the world.
      */
     dispose(): void;
+    /**
+     * Called when the renderable is destroyed (removed from the world).
+     * Cleans up GPU resources automatically.
+     * @ignore
+     */
+    onDestroyEvent(): void;
     /**
      * Sets the current animation for a track by animation index, discarding any queued animations.
      * @param {number} trackIndex - the track index

package/build/Spine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Spine.d.ts","sourceRoot":"","sources":["../src/Spine.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IAkCC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,eApCW,MAAM,KACN,MAAM,YAEd;QAA0B,SAAS;QACT,QAAQ;QACR,OAAO;KACjC,EA2FF;IAnID,gDAAQ;IACR,cAAS;IACT,0BAAO;IACP,oBAAe;IACf,iEAAiB;IACjB,UAAK;IACL,gCAAW;IACX,8BAAS;IACT;;;MAGE;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,cAhBU,UAAU,CAgBP;IAmDZ,cAAc;IACd,iBAAyC;IAIxC,YAA0C;IAK1C,kBAAkD;IASlD,4CAA+D;IAC/D,6CAAyD;IACzD,oEAEC;IAmBF,gBAAsC;IAGrC,6BAAiC;IACjC,8BAAmC;IAcrC,0BANU,OAAO,EAQhB;IAXD;;;;OAIG;IACH,sBAFU,OAAO,CAIhB;IAMD;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAfW,MAAM,YACN,MAAM,QAmEhB;IA3CA,wBAEE;IA2CH;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;;OAKG;IACH,cAJW,MAAM,MACN,QAAQ,GAAC,kBAAkB,GACzB,KAAK,CAWjB;IAED;;;;;OAKG;IACH,SAJW,MAAM,MACN,MAAM,GACJ,KAAK,CAWjB;IAmFD;;;;;;OAMG;IACH,eAFW,cAAc,GAAC,aAAa,QA4CtC;IAED;;;OAGG;IACH,gBAMC;IAWD;;;;;;OAMG;IACH,gCALW,MAAM,SACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;;OASG;IACH,yBARW,MAAM,QACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAWnB;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,SACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAatB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,QACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAItB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,qCAJW,MAAM,mBACN,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBAdW,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,8BANW,MAAM,gBACH,MAAM,EAAA,QAkBnB;IAED;;;;;OAKG;IACH,8BAJW,MAAM,gBACN,MAAM,GACJ,UAAU,CAItB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,+BAhBG;QAA4B,KAAK;QACL,SAAS;QACT,GAAG;QACH,OAAO;QACP,QAAQ;QACR,KAAK;KACjC,QAYF;IAED;;;OAGG;IACH,kCAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,qBAFa,MAAM,EAAE,CAMpB;IAED;;;OAGG;IACH,gBAFa,MAAM,EAAE,CAMpB;IAED;;OAEG;IACH,uBAYC;CACD;2BAnrBwC,SAAS;4BADtB,+BAA+B;6BAF9B,gCAAgC;uBAGpB,SAAS;6BACrB,uBAAuB"}
+{"version":3,"file":"Spine.d.ts","sourceRoot":"","sources":["../src/Spine.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH;IAkCC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,eApCW,MAAM,KACN,MAAM,YAEd;QAA0B,SAAS;QACT,QAAQ;QACR,OAAO;KACjC,EA6FF;IArID,gDAAQ;IACR,cAAS;IACT,0BAAO;IACP,oBAAe;IACf,iEAAiB;IACjB,UAAK;IACL,gCAAW;IACX,8BAAS;IACT;;;MAGE;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,cAhBU,UAAU,CAgBP;IAmDZ,cAAc;IACd,iBAAyC;IAWxC,kBAAkD;IASlD,4CAA6D;IAC7D,6CAAuD;IACvD,oEAEC;IAmBF,gBAAsC;IAGrC,6BAAiC;IACjC,8BAAmC;IAcrC,0BANU,OAAO,EAQhB;IAXD;;;;OAIG;IACH,sBAFU,OAAO,CAIhB;IAMD;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAfW,MAAM,YACN,MAAM,QAsDhB;IA9BA,wBAEE;IA8BH;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;;OAKG;IACH,cAJW,MAAM,MACN,QAAQ,GAAC,kBAAkB,GACzB,KAAK,CAMjB;IAED;;;;;OAKG;IACH,SAJW,MAAM,MACN,MAAM,GACJ,KAAK,CAWjB;IAmFD;;;;;;OAMG;IACH,eAFW,cAAc,GAAC,aAAa,QA4CtC;IAED;;;OAGG;IACH,gBAMC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,gCALW,MAAM,SACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;;OASG;IACH,yBARW,MAAM,QACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAWnB;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,SACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAatB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,QACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAItB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,qCAJW,MAAM,mBACN,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBAdW,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,8BANW,MAAM,gBACH,MAAM,EAAA,QAkBnB;IAED;;;;;OAKG;IACH,8BAJW,MAAM,gBACN,MAAM,GACJ,UAAU,CAItB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,+BAhBG;QAA4B,KAAK;QACL,SAAS;QACT,GAAG;QACH,OAAO;QACP,QAAQ;QACR,KAAK;KACjC,QAYF;IAED;;;OAGG;IACH,kCAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,qBAFa,MAAM,EAAE,CAMpB;IAED;;;OAGG;IACH,gBAFa,MAAM,EAAE,CAMpB;IAED;;OAEG;IACH,uBAUC;CACD;2BAxqBwC,SAAS;4BADtB,+BAA+B;6BAP9B,gCAAgC;uBAQpB,SAAS;6BAErB,uBAAuB"}

package/build/SpineBatcher.d.ts

@@ -5,16 +5,21 @@
  */
 export default class SpineBatcher extends Batcher {
     /**
+     * Initialize (or re-initialize) the batcher.
+     * Settings are built here rather than in the constructor so the
+     * renderer's context-restore recovery can re-create all GPU
+     * resources with a bare `batcher.init(renderer)` call, matching
+     * the engine's built-in batchers.
      * @param {WebGLRenderer} renderer - the current WebGL renderer session
-     * @param {WebGLRenderingContext|WebGL2RenderingContext} canvas - the GL context for Spine shader creation
+     * @ignore
      */
-    constructor(renderer: WebGLRenderer, canvas: WebGLRenderingContext | WebGL2RenderingContext);
+    init(renderer: WebGLRenderer): void;
     /**
      * the current texture bound to the batcher
      * @type {object|null}
      * @ignore
      */
-    lastTexture: object | null;
+    lastTexture: object | null | undefined;
     /**
      * Set the blend mode for subsequent draw calls.
      * Maps Spine BlendMode enum to melonJS blend mode strings.

package/build/SpineBatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpineBatcher.d.ts","sourceRoot":"","sources":["../src/SpineBatcher.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH;IACC;;;OAGG;IACH,sBAHW,aAAa,UACb,qBAAqB,GAAC,sBAAsB,EAuDtD;IANA;;;;OAIG;IACH,aAHU,MAAM,GAAC,IAAI,CAGE;IAGxB;;;;;OAKG;IACH,wBAHW,MAAM,sBACN,OAAO,QAOjB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,YACN,SAAS,CAAC,MAAM,CAAC,WACjB,MAAM,EAAE,QAwBlB;CAaD;wBArIuB,SAAS"}
+{"version":3,"file":"SpineBatcher.d.ts","sourceRoot":"","sources":["../src/SpineBatcher.js"],"names":[],"mappings":"AAeA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,eAHW,aAAa,QA0DvB;IANA;;;;OAIG;IACH,uCAAuB;IAGxB;;;;;OAKG;IACH,wBAHW,MAAM,sBACN,OAAO,QAOjB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,YACN,SAAS,CAAC,MAAM,CAAC,WACjB,MAAM,EAAE,QAwBlB;CAaD;wBA7IuB,SAAS"}

package/build/SpinePlugin.d.ts

@@ -4,7 +4,13 @@
  * @augments plugin.BasePlugin
  */
 export class SpinePlugin extends plugin.BasePlugin {
-    constructor();
+    /**
+     * @param {Application} [app] - the application instance this plugin
+     * belongs to (defaults to the active game instance). Pass it through
+     * `plugin.register(SpinePlugin, "SpinePlugin", app)` when running
+     * multiple applications.
+     */
+    constructor(app?: Application);
     assetManager: AssetManager;
 }
 import { plugin } from "melonjs";

package/build/SpinePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpinePlugin.d.ts","sourceRoot":"","sources":["../src/SpinePlugin.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IACC,cAkBC;IALA,2BAAuD;CAMxD;uBApCgD,SAAS;yBAQjC,gBAAgB"}
+{"version":3,"file":"SpinePlugin.d.ts","sourceRoot":"","sources":["../src/SpinePlugin.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IACC;;;;;OAKG;IACH,kBALW,WAAW,EAuBrB;IALA,2BAAuD;CAMxD;uBA1CgD,SAAS;yBAQjC,gBAAgB"}

package/build/glContext.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return the shared spine ManagedWebGLRenderingContext for the given canvas,
+ * creating it on first use.
+ *
+ * One shared instance per canvas matters for WebGL context-loss recovery:
+ * Spine's GLTexture/Shader/Mesh register themselves as restorables on their
+ * managed context, but a managed context only listens for
+ * `webglcontextrestored` when constructed from a canvas (a raw
+ * WebGLRenderingContext gives it no element to listen on). Funneling every
+ * spine GL resource through this single canvas-backed instance guarantees
+ * they are all restored after a context loss.
+ * @param {HTMLCanvasElement} canvas - the canvas the melonJS WebGL renderer draws to
+ * @returns {ManagedWebGLRenderingContext} the shared managed context
+ * @ignore
+ */
+export function getManagedContext(canvas: HTMLCanvasElement): ManagedWebGLRenderingContext;
+import { ManagedWebGLRenderingContext } from "@esotericsoftware/spine-webgl";
+//# sourceMappingURL=glContext.d.ts.map

package/build/glContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glContext.d.ts","sourceRoot":"","sources":["../src/glContext.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,0CAJW,iBAAiB,GACf,4BAA4B,CAUxC;6CA1B4C,+BAA+B"}