@esotericsoftware/spine-phaser-v3 4.2.77

package/LICENSE

@@ -0,0 +1,26 @@
+Spine Runtimes License Agreement
+Last updated May 1, 2019. Replaces all prior versions.
+
+Copyright (c) 2013-2019, Esoteric Software LLC
+
+Integration of the Spine Runtimes into software or otherwise creating
+derivative works of the Spine Runtimes is permitted under the terms and
+conditions of Section 2 of the Spine Editor License Agreement:
+http://esotericsoftware.com/spine-editor-license
+
+Otherwise, it is permitted to integrate the Spine Runtimes into software
+or otherwise create derivative works of the Spine Runtimes (collectively,
+"Products"), provided that each user of the Products must obtain their own
+Spine Editor license and redistribution of the Products in any form must
+include this license and copyright notice.
+
+THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
+NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS
+INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,3 @@
+# spine-ts Phaser v3
+
+Please see the top-level [README.md](../README.md) for more information.

package/dist/SpineGameObject.d.ts

@@ -0,0 +1,137 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { SpinePlugin } from "./SpinePlugin.js";
+import { AnimationState, AnimationStateData, Bone, Skeleton } from "@esotericsoftware/spine-core";
+declare class BaseSpineGameObject extends Phaser.GameObjects.GameObject {
+    constructor(scene: Phaser.Scene, type: string);
+}
+/** A bounds provider calculates the bounding box for a skeleton, which is then assigned as the size of the SpineGameObject. */
+export interface SpineGameObjectBoundsProvider {
+    calculateBounds(gameObject: SpineGameObject): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** A bounds provider that calculates the bounding box from the setup pose. */
+export declare class SetupPoseBoundsProvider implements SpineGameObjectBoundsProvider {
+    private clipping;
+    /**
+     * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.
+     */
+    constructor(clipping?: boolean);
+    calculateBounds(gameObject: SpineGameObject): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** A bounds provider that calculates the bounding box by taking the maximumg bounding box for a combination of skins and specific animation. */
+export declare class SkinsAndAnimationBoundsProvider implements SpineGameObjectBoundsProvider {
+    private animation;
+    private skins;
+    private timeStep;
+    private clipping;
+    /**
+     * @param animation The animation to use for calculating the bounds. If null, the setup pose is used.
+     * @param skins The skins to use for calculating the bounds. If empty, the default skin is used.
+     * @param timeStep The time step to use for calculating the bounds. A smaller time step means more precision, but slower calculation.
+     * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.
+     */
+    constructor(animation: string | null, skins?: string[], timeStep?: number, clipping?: boolean);
+    calculateBounds(gameObject: SpineGameObject): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+declare const SpineGameObject_base: typeof BaseSpineGameObject & import("./mixins.js").Type<Phaser.GameObjects.Components.Alpha, any[]> & import("./mixins.js").Type<Phaser.GameObjects.Components.Visible, any[]> & import("./mixins.js").Type<Phaser.GameObjects.Components.Transform, any[]> & import("./mixins.js").Type<Phaser.GameObjects.Components.ScrollFactor, any[]> & import("./mixins.js").Type<Phaser.GameObjects.Components.Flip, any[]> & import("./mixins.js").Type<Phaser.GameObjects.Components.ComputedSize, any[]> & import("./mixins.js").Type<Phaser.GameObjects.Components.Origin, any[]> & import("./mixins.js").Type<Phaser.GameObjects.Components.Depth, any[]>;
+/**
+ * A SpineGameObject is a Phaser {@link GameObject} that can be added to a Phaser Scene and render a Spine skeleton.
+ *
+ * The Spine GameObject is a thin wrapper around a Spine {@link Skeleton}, {@link AnimationState} and {@link AnimationStateData}. It is responsible for:
+ * - updating the animation state
+ * - applying the animation state to the skeleton's bones, slots, attachments, and draw order.
+ * - updating the skeleton's bone world transforms
+ * - rendering the skeleton
+ *
+ * See the {@link SpinePlugin} class for more information on how to create a `SpineGameObject`.
+ *
+ * The skeleton, animation state, and animation state data can be accessed via the repsective fields. They can be manually updated via {@link updatePose}.
+ *
+ * To modify the bone hierarchy before the world transforms are computed, a callback can be set via the {@link beforeUpdateWorldTransforms} field.
+ *
+ * To modify the bone hierarchy after the world transforms are computed, a callback can be set via the {@link afterUpdateWorldTransforms} field.
+ *
+ * The class also features methods to convert between the skeleton coordinate system and the Phaser coordinate system.
+ *
+ * See {@link skeletonToPhaserWorldCoordinates}, {@link phaserWorldCoordinatesToSkeleton}, and {@link phaserWorldCoordinatesToBoneLocal.}
+ */
+export declare class SpineGameObject extends SpineGameObject_base {
+    private plugin;
+    boundsProvider: SpineGameObjectBoundsProvider;
+    blendMode: number;
+    skeleton: Skeleton;
+    animationStateData: AnimationStateData;
+    animationState: AnimationState;
+    beforeUpdateWorldTransforms: (object: SpineGameObject) => void;
+    afterUpdateWorldTransforms: (object: SpineGameObject) => void;
+    private premultipliedAlpha;
+    constructor(scene: Phaser.Scene, plugin: SpinePlugin, x: number, y: number, dataKey: string, atlasKey: string, boundsProvider?: SpineGameObjectBoundsProvider);
+    updateSize(): void;
+    /** Converts a point from the skeleton coordinate system to the Phaser world coordinate system. */
+    skeletonToPhaserWorldCoordinates(point: {
+        x: number;
+        y: number;
+    }): void;
+    /** Converts a point from the Phaser world coordinate system to the skeleton coordinate system. */
+    phaserWorldCoordinatesToSkeleton(point: {
+        x: number;
+        y: number;
+    }): void;
+    /** Converts a point from the Phaser world coordinate system to the bone's local coordinate system. */
+    phaserWorldCoordinatesToBone(point: {
+        x: number;
+        y: number;
+    }, bone: Bone): void;
+    /**
+     * Updates the {@link AnimationState}, applies it to the {@link Skeleton}, then updates the world transforms of all bones.
+     * @param delta The time delta in milliseconds
+     */
+    updatePose(delta: number): void;
+    preUpdate(time: number, delta: number): void;
+    preDestroy(): void;
+    willRender(camera: Phaser.Cameras.Scene2D.Camera): boolean;
+    renderWebGL(renderer: Phaser.Renderer.WebGL.WebGLRenderer, src: SpineGameObject, camera: Phaser.Cameras.Scene2D.Camera, parentMatrix: Phaser.GameObjects.Components.TransformMatrix): void;
+    renderCanvas(renderer: Phaser.Renderer.Canvas.CanvasRenderer, src: SpineGameObject, camera: Phaser.Cameras.Scene2D.Camera, parentMatrix: Phaser.GameObjects.Components.TransformMatrix): void;
+}
+export {};

package/dist/SpineGameObject.js

@@ -0,0 +1,300 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { SPINE_GAME_OBJECT_TYPE } from "./keys.js";
+import { ComputedSizeMixin, DepthMixin, FlipMixin, ScrollFactorMixin, TransformMixin, VisibleMixin, AlphaMixin, OriginMixin, } from "./mixins.js";
+import { AnimationState, AnimationStateData, MathUtils, Physics, Skeleton, SkeletonClipping, Skin, } from "@esotericsoftware/spine-core";
+class BaseSpineGameObject extends Phaser.GameObjects.GameObject {
+    constructor(scene, type) {
+        super(scene, type);
+    }
+}
+/** A bounds provider that calculates the bounding box from the setup pose. */
+export class SetupPoseBoundsProvider {
+    clipping;
+    /**
+     * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.
+     */
+    constructor(clipping = false) {
+        this.clipping = clipping;
+    }
+    calculateBounds(gameObject) {
+        if (!gameObject.skeleton)
+            return { x: 0, y: 0, width: 0, height: 0 };
+        // Make a copy of animation state and skeleton as this might be called while
+        // the skeleton in the GameObject has already been heavily modified. We can not
+        // reconstruct that state.
+        const skeleton = new Skeleton(gameObject.skeleton.data);
+        skeleton.setToSetupPose();
+        skeleton.updateWorldTransform(Physics.update);
+        const bounds = skeleton.getBoundsRect(this.clipping ? new SkeletonClipping() : undefined);
+        return bounds.width == Number.NEGATIVE_INFINITY
+            ? { x: 0, y: 0, width: 0, height: 0 }
+            : bounds;
+    }
+}
+/** A bounds provider that calculates the bounding box by taking the maximumg bounding box for a combination of skins and specific animation. */
+export class SkinsAndAnimationBoundsProvider {
+    animation;
+    skins;
+    timeStep;
+    clipping;
+    /**
+     * @param animation The animation to use for calculating the bounds. If null, the setup pose is used.
+     * @param skins The skins to use for calculating the bounds. If empty, the default skin is used.
+     * @param timeStep The time step to use for calculating the bounds. A smaller time step means more precision, but slower calculation.
+     * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.
+     */
+    constructor(animation, skins = [], timeStep = 0.05, clipping = false) {
+        this.animation = animation;
+        this.skins = skins;
+        this.timeStep = timeStep;
+        this.clipping = clipping;
+    }
+    calculateBounds(gameObject) {
+        if (!gameObject.skeleton || !gameObject.animationState)
+            return { x: 0, y: 0, width: 0, height: 0 };
+        // Make a copy of animation state and skeleton as this might be called while
+        // the skeleton in the GameObject has already been heavily modified. We can not
+        // reconstruct that state.
+        const animationState = new AnimationState(gameObject.animationState.data);
+        const skeleton = new Skeleton(gameObject.skeleton.data);
+        const clipper = this.clipping ? new SkeletonClipping() : undefined;
+        const data = skeleton.data;
+        if (this.skins.length > 0) {
+            let customSkin = new Skin("custom-skin");
+            for (const skinName of this.skins) {
+                const skin = data.findSkin(skinName);
+                if (skin == null)
+                    continue;
+                customSkin.addSkin(skin);
+            }
+            skeleton.setSkin(customSkin);
+        }
+        skeleton.setToSetupPose();
+        const animation = this.animation != null ? data.findAnimation(this.animation) : null;
+        if (animation == null) {
+            skeleton.updateWorldTransform(Physics.update);
+            const bounds = skeleton.getBoundsRect(clipper);
+            return bounds.width == Number.NEGATIVE_INFINITY
+                ? { x: 0, y: 0, width: 0, height: 0 }
+                : bounds;
+        }
+        else {
+            let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
+            animationState.clearTracks();
+            animationState.setAnimationWith(0, animation, false);
+            const steps = Math.max(animation.duration / this.timeStep, 1.0);
+            for (let i = 0; i < steps; i++) {
+                const delta = i > 0 ? this.timeStep : 0;
+                animationState.update(delta);
+                animationState.apply(skeleton);
+                skeleton.update(delta);
+                skeleton.updateWorldTransform(Physics.update);
+                const bounds = skeleton.getBoundsRect(clipper);
+                minX = Math.min(minX, bounds.x);
+                minY = Math.min(minY, bounds.y);
+                maxX = Math.max(maxX, bounds.x + bounds.width);
+                maxY = Math.max(maxY, bounds.y + bounds.height);
+            }
+            const bounds = {
+                x: minX,
+                y: minY,
+                width: maxX - minX,
+                height: maxY - minY,
+            };
+            return bounds.width == Number.NEGATIVE_INFINITY
+                ? { x: 0, y: 0, width: 0, height: 0 }
+                : bounds;
+        }
+    }
+}
+/**
+ * A SpineGameObject is a Phaser {@link GameObject} that can be added to a Phaser Scene and render a Spine skeleton.
+ *
+ * The Spine GameObject is a thin wrapper around a Spine {@link Skeleton}, {@link AnimationState} and {@link AnimationStateData}. It is responsible for:
+ * - updating the animation state
+ * - applying the animation state to the skeleton's bones, slots, attachments, and draw order.
+ * - updating the skeleton's bone world transforms
+ * - rendering the skeleton
+ *
+ * See the {@link SpinePlugin} class for more information on how to create a `SpineGameObject`.
+ *
+ * The skeleton, animation state, and animation state data can be accessed via the repsective fields. They can be manually updated via {@link updatePose}.
+ *
+ * To modify the bone hierarchy before the world transforms are computed, a callback can be set via the {@link beforeUpdateWorldTransforms} field.
+ *
+ * To modify the bone hierarchy after the world transforms are computed, a callback can be set via the {@link afterUpdateWorldTransforms} field.
+ *
+ * The class also features methods to convert between the skeleton coordinate system and the Phaser coordinate system.
+ *
+ * See {@link skeletonToPhaserWorldCoordinates}, {@link phaserWorldCoordinatesToSkeleton}, and {@link phaserWorldCoordinatesToBoneLocal.}
+ */
+export class SpineGameObject extends DepthMixin(OriginMixin(ComputedSizeMixin(FlipMixin(ScrollFactorMixin(TransformMixin(VisibleMixin(AlphaMixin(BaseSpineGameObject)))))))) {
+    plugin;
+    boundsProvider;
+    blendMode = -1;
+    skeleton;
+    animationStateData;
+    animationState;
+    beforeUpdateWorldTransforms = () => { };
+    afterUpdateWorldTransforms = () => { };
+    premultipliedAlpha = false;
+    constructor(scene, plugin, x, y, dataKey, atlasKey, boundsProvider = new SetupPoseBoundsProvider()) {
+        super(scene, window.SPINE_GAME_OBJECT_TYPE ? window.SPINE_GAME_OBJECT_TYPE : SPINE_GAME_OBJECT_TYPE);
+        this.plugin = plugin;
+        this.boundsProvider = boundsProvider;
+        this.setPosition(x, y);
+        this.premultipliedAlpha = this.plugin.isAtlasPremultiplied(atlasKey);
+        this.skeleton = this.plugin.createSkeleton(dataKey, atlasKey);
+        this.animationStateData = new AnimationStateData(this.skeleton.data);
+        this.animationState = new AnimationState(this.animationStateData);
+        this.skeleton.updateWorldTransform(Physics.update);
+        this.updateSize();
+    }
+    updateSize() {
+        if (!this.skeleton)
+            return;
+        let bounds = this.boundsProvider.calculateBounds(this);
+        // For some reason the TS compiler and the ComputedSize mixin don't work well together and we have
+        // to cast to any.
+        let self = this;
+        self.width = bounds.width;
+        self.height = bounds.height;
+        this.displayOriginX = -bounds.x;
+        this.displayOriginY = -bounds.y;
+    }
+    /** Converts a point from the skeleton coordinate system to the Phaser world coordinate system. */
+    skeletonToPhaserWorldCoordinates(point) {
+        let transform = this.getWorldTransformMatrix();
+        let a = transform.a, b = transform.b, c = transform.c, d = transform.d, tx = transform.tx, ty = transform.ty;
+        let x = point.x;
+        let y = point.y;
+        point.x = x * a + y * c + tx;
+        point.y = x * b + y * d + ty;
+    }
+    /** Converts a point from the Phaser world coordinate system to the skeleton coordinate system. */
+    phaserWorldCoordinatesToSkeleton(point) {
+        let transform = this.getWorldTransformMatrix();
+        transform = transform.invert();
+        let a = transform.a, b = transform.b, c = transform.c, d = transform.d, tx = transform.tx, ty = transform.ty;
+        let x = point.x;
+        let y = point.y;
+        point.x = x * a + y * c + tx;
+        point.y = x * b + y * d + ty;
+    }
+    /** Converts a point from the Phaser world coordinate system to the bone's local coordinate system. */
+    phaserWorldCoordinatesToBone(point, bone) {
+        this.phaserWorldCoordinatesToSkeleton(point);
+        if (bone.parent) {
+            bone.parent.worldToLocal(point);
+        }
+        else {
+            bone.worldToLocal(point);
+        }
+    }
+    /**
+     * Updates the {@link AnimationState}, applies it to the {@link Skeleton}, then updates the world transforms of all bones.
+     * @param delta The time delta in milliseconds
+     */
+    updatePose(delta) {
+        this.animationState.update(delta / 1000);
+        this.animationState.apply(this.skeleton);
+        this.beforeUpdateWorldTransforms(this);
+        this.skeleton.update(delta / 1000);
+        this.skeleton.updateWorldTransform(Physics.update);
+        this.afterUpdateWorldTransforms(this);
+    }
+    preUpdate(time, delta) {
+        if (!this.skeleton || !this.animationState)
+            return;
+        this.updatePose(delta);
+    }
+    preDestroy() {
+        // FIXME tear down any event emitters
+    }
+    willRender(camera) {
+        var GameObjectRenderMask = 0xf;
+        var result = !this.skeleton || !(GameObjectRenderMask !== this.renderFlags || (this.cameraFilter !== 0 && this.cameraFilter & camera.id));
+        if (!this.visible)
+            result = false;
+        if (!result && this.parentContainer && this.plugin.webGLRenderer) {
+            var sceneRenderer = this.plugin.webGLRenderer;
+            if (this.plugin.gl && this.plugin.phaserRenderer instanceof Phaser.Renderer.WebGL.WebGLRenderer && sceneRenderer.batcher.isDrawing) {
+                sceneRenderer.end();
+                this.plugin.phaserRenderer.pipelines.rebind();
+            }
+        }
+        return result;
+    }
+    renderWebGL(renderer, src, camera, parentMatrix) {
+        if (!this.skeleton || !this.animationState || !this.plugin.webGLRenderer)
+            return;
+        let sceneRenderer = this.plugin.webGLRenderer;
+        if (renderer.newType) {
+            renderer.pipelines.clear();
+            sceneRenderer.begin();
+        }
+        camera.addToRenderList(src);
+        let transform = Phaser.GameObjects.GetCalcMatrix(src, camera, parentMatrix).calc;
+        let a = transform.a, b = transform.b, c = transform.c, d = transform.d, tx = transform.tx, ty = transform.ty;
+        sceneRenderer.drawSkeleton(this.skeleton, this.premultipliedAlpha, -1, -1, (vertices, numVertices, stride) => {
+            for (let i = 0; i < numVertices; i += stride) {
+                let vx = vertices[i];
+                let vy = vertices[i + 1];
+                vertices[i] = vx * a + vy * c + tx;
+                vertices[i + 1] = vx * b + vy * d + ty;
+            }
+        });
+        if (!renderer.nextTypeMatch) {
+            sceneRenderer.end();
+            renderer.pipelines.rebind();
+        }
+    }
+    renderCanvas(renderer, src, camera, parentMatrix) {
+        if (!this.skeleton || !this.animationState || !this.plugin.canvasRenderer)
+            return;
+        let context = renderer.currentContext;
+        let skeletonRenderer = this.plugin.canvasRenderer;
+        skeletonRenderer.ctx = context;
+        camera.addToRenderList(src);
+        let transform = Phaser.GameObjects.GetCalcMatrix(src, camera, parentMatrix).calc;
+        let skeleton = this.skeleton;
+        skeleton.x = transform.tx;
+        skeleton.y = transform.ty;
+        skeleton.scaleX = transform.scaleX;
+        skeleton.scaleY = transform.scaleY;
+        let root = skeleton.getRootBone();
+        root.rotation = -MathUtils.radiansToDegrees * transform.rotationNormalized;
+        this.skeleton.updateWorldTransform(Physics.update);
+        context.save();
+        skeletonRenderer.draw(skeleton);
+        context.restore();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SpineGameObject.js","sourceRoot":"","sources":["../src/SpineGameObject.ts"],"names":[],"mappings":"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","sourcesContent":["/******************************************************************************\n * Spine Runtimes License Agreement\n * Last updated July 28, 2023. Replaces all prior versions.\n *\n * Copyright (c) 2013-2023, Esoteric Software LLC\n *\n * Integration of the Spine Runtimes into software or otherwise creating\n * derivative works of the Spine Runtimes is permitted under the terms and\n * conditions of Section 2 of the Spine Editor License Agreement:\n * http://esotericsoftware.com/spine-editor-license\n *\n * Otherwise, it is permitted to integrate the Spine Runtimes into software or\n * otherwise create derivative works of the Spine Runtimes (collectively,\n * \"Products\"), provided that each user of the Products must obtain their own\n * Spine Editor license and redistribution of the Products in any form must\n * include this license and copyright notice.\n *\n * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC \"AS IS\" AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY\n * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,\n * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND\n * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE\n * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *****************************************************************************/\n\nimport { SPINE_GAME_OBJECT_TYPE } from \"./keys.js\";\nimport { SpinePlugin } from \"./SpinePlugin.js\";\nimport {\n\tComputedSizeMixin,\n\tDepthMixin,\n\tFlipMixin,\n\tScrollFactorMixin,\n\tTransformMixin,\n\tVisibleMixin,\n\tAlphaMixin,\n\tOriginMixin,\n} from \"./mixins.js\";\nimport {\n\tAnimationState,\n\tAnimationStateData,\n\tBone,\n\tMathUtils,\n\tPhysics,\n\tSkeleton,\n\tSkeletonClipping,\n\tSkin,\n\tVector2,\n} from \"@esotericsoftware/spine-core\";\n\nclass BaseSpineGameObject extends Phaser.GameObjects.GameObject {\n\tconstructor (scene: Phaser.Scene, type: string) {\n\t\tsuper(scene, type);\n\t}\n}\n\n/** A bounds provider calculates the bounding box for a skeleton, which is then assigned as the size of the SpineGameObject. */\nexport interface SpineGameObjectBoundsProvider {\n\t// Returns the bounding box for the skeleton, in skeleton space.\n\tcalculateBounds (gameObject: SpineGameObject): {\n\t\tx: number;\n\t\ty: number;\n\t\twidth: number;\n\t\theight: number;\n\t};\n}\n\n/** A bounds provider that calculates the bounding box from the setup pose. */\nexport class SetupPoseBoundsProvider implements SpineGameObjectBoundsProvider {\n\t/**\n\t * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.\n\t */\n\tconstructor (\n\t\tprivate clipping = false,\n\t) { }\n\n\tcalculateBounds (gameObject: SpineGameObject) {\n\t\tif (!gameObject.skeleton) return { x: 0, y: 0, width: 0, height: 0 };\n\t\t// Make a copy of animation state and skeleton as this might be called while\n\t\t// the skeleton in the GameObject has already been heavily modified. We can not\n\t\t// reconstruct that state.\n\t\tconst skeleton = new Skeleton(gameObject.skeleton.data);\n\t\tskeleton.setToSetupPose();\n\t\tskeleton.updateWorldTransform(Physics.update);\n\t\tconst bounds = skeleton.getBoundsRect(this.clipping ? new SkeletonClipping() : undefined);\n\t\treturn bounds.width == Number.NEGATIVE_INFINITY\n\t\t\t? { x: 0, y: 0, width: 0, height: 0 }\n\t\t\t: bounds;\n\t}\n}\n\n/** A bounds provider that calculates the bounding box by taking the maximumg bounding box for a combination of skins and specific animation. */\nexport class SkinsAndAnimationBoundsProvider\n\timplements SpineGameObjectBoundsProvider {\n\t/**\n\t * @param animation The animation to use for calculating the bounds. If null, the setup pose is used.\n\t * @param skins The skins to use for calculating the bounds. If empty, the default skin is used.\n\t * @param timeStep The time step to use for calculating the bounds. A smaller time step means more precision, but slower calculation.\n\t * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.\n\t */\n\tconstructor (\n\t\tprivate animation: string | null,\n\t\tprivate skins: string[] = [],\n\t\tprivate timeStep: number = 0.05,\n\t\tprivate clipping = false,\n\t) { }\n\n\tcalculateBounds (gameObject: SpineGameObject): {\n\t\tx: number;\n\t\ty: number;\n\t\twidth: number;\n\t\theight: number;\n\t} {\n\t\tif (!gameObject.skeleton || !gameObject.animationState)\n\t\t\treturn { x: 0, y: 0, width: 0, height: 0 };\n\t\t// Make a copy of animation state and skeleton as this might be called while\n\t\t// the skeleton in the GameObject has already been heavily modified. We can not\n\t\t// reconstruct that state.\n\t\tconst animationState = new AnimationState(gameObject.animationState.data);\n\t\tconst skeleton = new Skeleton(gameObject.skeleton.data);\n\t\tconst clipper = this.clipping ? new SkeletonClipping() : undefined;\n\t\tconst data = skeleton.data;\n\t\tif (this.skins.length > 0) {\n\t\t\tlet customSkin = new Skin(\"custom-skin\");\n\t\t\tfor (const skinName of this.skins) {\n\t\t\t\tconst skin = data.findSkin(skinName);\n\t\t\t\tif (skin == null) continue;\n\t\t\t\tcustomSkin.addSkin(skin);\n\t\t\t}\n\t\t\tskeleton.setSkin(customSkin);\n\t\t}\n\t\tskeleton.setToSetupPose();\n\n\t\tconst animation =\n\t\t\tthis.animation != null ? data.findAnimation(this.animation!) : null;\n\t\tif (animation == null) {\n\t\t\tskeleton.updateWorldTransform(Physics.update);\n\t\t\tconst bounds = skeleton.getBoundsRect(clipper);\n\t\t\treturn bounds.width == Number.NEGATIVE_INFINITY\n\t\t\t\t? { x: 0, y: 0, width: 0, height: 0 }\n\t\t\t\t: bounds;\n\t\t} else {\n\t\t\tlet minX = Number.POSITIVE_INFINITY,\n\t\t\t\tminY = Number.POSITIVE_INFINITY,\n\t\t\t\tmaxX = Number.NEGATIVE_INFINITY,\n\t\t\t\tmaxY = Number.NEGATIVE_INFINITY;\n\t\t\tanimationState.clearTracks();\n\t\t\tanimationState.setAnimationWith(0, animation, false);\n\t\t\tconst steps = Math.max(animation.duration / this.timeStep, 1.0);\n\t\t\tfor (let i = 0; i < steps; i++) {\n\t\t\t\tconst delta = i > 0 ? this.timeStep : 0;\n\t\t\t\tanimationState.update(delta);\n\t\t\t\tanimationState.apply(skeleton);\n\t\t\t\tskeleton.update(delta);\n\t\t\t\tskeleton.updateWorldTransform(Physics.update);\n\n\t\t\t\tconst bounds = skeleton.getBoundsRect(clipper);\n\t\t\t\tminX = Math.min(minX, bounds.x);\n\t\t\t\tminY = Math.min(minY, bounds.y);\n\t\t\t\tmaxX = Math.max(maxX, bounds.x + bounds.width);\n\t\t\t\tmaxY = Math.max(maxY, bounds.y + bounds.height);\n\t\t\t}\n\t\t\tconst bounds = {\n\t\t\t\tx: minX,\n\t\t\t\ty: minY,\n\t\t\t\twidth: maxX - minX,\n\t\t\t\theight: maxY - minY,\n\t\t\t};\n\t\t\treturn bounds.width == Number.NEGATIVE_INFINITY\n\t\t\t\t? { x: 0, y: 0, width: 0, height: 0 }\n\t\t\t\t: bounds;\n\t\t}\n\t}\n}\n\n/**\n * A SpineGameObject is a Phaser {@link GameObject} that can be added to a Phaser Scene and render a Spine skeleton.\n *\n * The Spine GameObject is a thin wrapper around a Spine {@link Skeleton}, {@link AnimationState} and {@link AnimationStateData}. It is responsible for:\n * - updating the animation state\n * - applying the animation state to the skeleton's bones, slots, attachments, and draw order.\n * - updating the skeleton's bone world transforms\n * - rendering the skeleton\n *\n * See the {@link SpinePlugin} class for more information on how to create a `SpineGameObject`.\n *\n * The skeleton, animation state, and animation state data can be accessed via the repsective fields. They can be manually updated via {@link updatePose}.\n *\n * To modify the bone hierarchy before the world transforms are computed, a callback can be set via the {@link beforeUpdateWorldTransforms} field.\n *\n * To modify the bone hierarchy after the world transforms are computed, a callback can be set via the {@link afterUpdateWorldTransforms} field.\n *\n * The class also features methods to convert between the skeleton coordinate system and the Phaser coordinate system.\n *\n * See {@link skeletonToPhaserWorldCoordinates}, {@link phaserWorldCoordinatesToSkeleton}, and {@link phaserWorldCoordinatesToBoneLocal.}\n */\nexport class SpineGameObject extends DepthMixin(\n\tOriginMixin(\n\t\tComputedSizeMixin(\n\t\t\tFlipMixin(\n\t\t\t\tScrollFactorMixin(\n\t\t\t\t\tTransformMixin(VisibleMixin(AlphaMixin(BaseSpineGameObject)))\n\t\t\t\t)\n\t\t\t)\n\t\t)\n\t)\n) {\n\tblendMode = -1;\n\tskeleton: Skeleton;\n\tanimationStateData: AnimationStateData;\n\tanimationState: AnimationState;\n\tbeforeUpdateWorldTransforms: (object: SpineGameObject) => void = () => { };\n\tafterUpdateWorldTransforms: (object: SpineGameObject) => void = () => { };\n\tprivate premultipliedAlpha = false;\n\n\tconstructor (\n\t\tscene: Phaser.Scene,\n\t\tprivate plugin: SpinePlugin,\n\t\tx: number,\n\t\ty: number,\n\t\tdataKey: string,\n\t\tatlasKey: string,\n\t\tpublic boundsProvider: SpineGameObjectBoundsProvider = new SetupPoseBoundsProvider()\n\t) {\n\t\tsuper(scene, (window as any).SPINE_GAME_OBJECT_TYPE ? (window as any).SPINE_GAME_OBJECT_TYPE : SPINE_GAME_OBJECT_TYPE);\n\t\tthis.setPosition(x, y);\n\n\t\tthis.premultipliedAlpha = this.plugin.isAtlasPremultiplied(atlasKey);\n\t\tthis.skeleton = this.plugin.createSkeleton(dataKey, atlasKey);\n\t\tthis.animationStateData = new AnimationStateData(this.skeleton.data);\n\t\tthis.animationState = new AnimationState(this.animationStateData);\n\t\tthis.skeleton.updateWorldTransform(Physics.update);\n\t\tthis.updateSize();\n\t}\n\n\tupdateSize () {\n\t\tif (!this.skeleton) return;\n\t\tlet bounds = this.boundsProvider.calculateBounds(this);\n\t\t// For some reason the TS compiler and the ComputedSize mixin don't work well together and we have\n\t\t// to cast to any.\n\t\tlet self = this as any;\n\t\tself.width = bounds.width;\n\t\tself.height = bounds.height;\n\t\tthis.displayOriginX = -bounds.x;\n\t\tthis.displayOriginY = -bounds.y;\n\t}\n\n\t/** Converts a point from the skeleton coordinate system to the Phaser world coordinate system. */\n\tskeletonToPhaserWorldCoordinates (point: { x: number; y: number }) {\n\t\tlet transform = this.getWorldTransformMatrix();\n\t\tlet a = transform.a,\n\t\t\tb = transform.b,\n\t\t\tc = transform.c,\n\t\t\td = transform.d,\n\t\t\ttx = transform.tx,\n\t\t\tty = transform.ty;\n\t\tlet x = point.x;\n\t\tlet y = point.y;\n\t\tpoint.x = x * a + y * c + tx;\n\t\tpoint.y = x * b + y * d + ty;\n\t}\n\n\t/** Converts a point from the Phaser world coordinate system to the skeleton coordinate system. */\n\tphaserWorldCoordinatesToSkeleton (point: { x: number; y: number }) {\n\t\tlet transform = this.getWorldTransformMatrix();\n\t\ttransform = transform.invert();\n\t\tlet a = transform.a,\n\t\t\tb = transform.b,\n\t\t\tc = transform.c,\n\t\t\td = transform.d,\n\t\t\ttx = transform.tx,\n\t\t\tty = transform.ty;\n\t\tlet x = point.x;\n\t\tlet y = point.y;\n\t\tpoint.x = x * a + y * c + tx;\n\t\tpoint.y = x * b + y * d + ty;\n\t}\n\n\t/** Converts a point from the Phaser world coordinate system to the bone's local coordinate system. */\n\tphaserWorldCoordinatesToBone (point: { x: number; y: number }, bone: Bone) {\n\t\tthis.phaserWorldCoordinatesToSkeleton(point);\n\t\tif (bone.parent) {\n\t\t\tbone.parent.worldToLocal(point as Vector2);\n\t\t} else {\n\t\t\tbone.worldToLocal(point as Vector2);\n\t\t}\n\t}\n\n\t/**\n\t * Updates the {@link AnimationState}, applies it to the {@link Skeleton}, then updates the world transforms of all bones.\n\t * @param delta The time delta in milliseconds\n\t */\n\tupdatePose (delta: number) {\n\t\tthis.animationState.update(delta / 1000);\n\t\tthis.animationState.apply(this.skeleton);\n\t\tthis.beforeUpdateWorldTransforms(this);\n\t\tthis.skeleton.update(delta / 1000);\n\t\tthis.skeleton.updateWorldTransform(Physics.update);\n\t\tthis.afterUpdateWorldTransforms(this);\n\t}\n\n\tpreUpdate (time: number, delta: number) {\n\t\tif (!this.skeleton || !this.animationState) return;\n\t\tthis.updatePose(delta);\n\t}\n\n\tpreDestroy () {\n\t\t// FIXME tear down any event emitters\n\t}\n\n\twillRender (camera: Phaser.Cameras.Scene2D.Camera) {\n\t\tvar GameObjectRenderMask = 0xf;\n\t\tvar result = !this.skeleton || !(GameObjectRenderMask !== this.renderFlags || (this.cameraFilter !== 0 && this.cameraFilter & camera.id));\n\t\tif (!this.visible) result = false;\n\n\t\tif (!result && this.parentContainer && this.plugin.webGLRenderer) {\n\t\t\tvar sceneRenderer = this.plugin.webGLRenderer;\n\n\t\t\tif (this.plugin.gl && this.plugin.phaserRenderer instanceof Phaser.Renderer.WebGL.WebGLRenderer && sceneRenderer.batcher.isDrawing) {\n\t\t\t\tsceneRenderer.end();\n\t\t\t\tthis.plugin.phaserRenderer.pipelines.rebind();\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t}\n\n\trenderWebGL (\n\t\trenderer: Phaser.Renderer.WebGL.WebGLRenderer,\n\t\tsrc: SpineGameObject,\n\t\tcamera: Phaser.Cameras.Scene2D.Camera,\n\t\tparentMatrix: Phaser.GameObjects.Components.TransformMatrix\n\t) {\n\t\tif (!this.skeleton || !this.animationState || !this.plugin.webGLRenderer)\n\t\t\treturn;\n\n\t\tlet sceneRenderer = this.plugin.webGLRenderer;\n\t\tif (renderer.newType) {\n\t\t\trenderer.pipelines.clear();\n\t\t\tsceneRenderer.begin();\n\t\t}\n\n\t\tcamera.addToRenderList(src);\n\t\tlet transform = Phaser.GameObjects.GetCalcMatrix(\n\t\t\tsrc,\n\t\t\tcamera,\n\t\t\tparentMatrix\n\t\t).calc;\n\t\tlet a = transform.a,\n\t\t\tb = transform.b,\n\t\t\tc = transform.c,\n\t\t\td = transform.d,\n\t\t\ttx = transform.tx,\n\t\t\tty = transform.ty;\n\t\tsceneRenderer.drawSkeleton(\n\t\t\tthis.skeleton,\n\t\t\tthis.premultipliedAlpha,\n\t\t\t-1,\n\t\t\t-1,\n\t\t\t(vertices, numVertices, stride) => {\n\t\t\t\tfor (let i = 0; i < numVertices; i += stride) {\n\t\t\t\t\tlet vx = vertices[i];\n\t\t\t\t\tlet vy = vertices[i + 1];\n\t\t\t\t\tvertices[i] = vx * a + vy * c + tx;\n\t\t\t\t\tvertices[i + 1] = vx * b + vy * d + ty;\n\t\t\t\t}\n\t\t\t}\n\t\t);\n\n\t\tif (!renderer.nextTypeMatch) {\n\t\t\tsceneRenderer.end();\n\t\t\trenderer.pipelines.rebind();\n\t\t}\n\t}\n\n\trenderCanvas (\n\t\trenderer: Phaser.Renderer.Canvas.CanvasRenderer,\n\t\tsrc: SpineGameObject,\n\t\tcamera: Phaser.Cameras.Scene2D.Camera,\n\t\tparentMatrix: Phaser.GameObjects.Components.TransformMatrix\n\t) {\n\t\tif (!this.skeleton || !this.animationState || !this.plugin.canvasRenderer)\n\t\t\treturn;\n\n\t\tlet context = renderer.currentContext;\n\t\tlet skeletonRenderer = this.plugin.canvasRenderer;\n\t\t(skeletonRenderer as any).ctx = context;\n\n\t\tcamera.addToRenderList(src);\n\t\tlet transform = Phaser.GameObjects.GetCalcMatrix(\n\t\t\tsrc,\n\t\t\tcamera,\n\t\t\tparentMatrix\n\t\t).calc;\n\t\tlet skeleton = this.skeleton;\n\t\tskeleton.x = transform.tx;\n\t\tskeleton.y = transform.ty;\n\t\tskeleton.scaleX = transform.scaleX;\n\t\tskeleton.scaleY = transform.scaleY;\n\t\tlet root = skeleton.getRootBone()!;\n\t\troot.rotation = -MathUtils.radiansToDegrees * transform.rotationNormalized;\n\t\tthis.skeleton.updateWorldTransform(Physics.update);\n\n\t\tcontext.save();\n\t\tskeletonRenderer.draw(skeleton);\n\t\tcontext.restore();\n\t}\n}\n"]}

package/dist/SpinePlugin.d.ts

@@ -0,0 +1,95 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import * as Phaser from "phaser";
+import { SceneRenderer, Skeleton, SkeletonData, TextureAtlas } from "@esotericsoftware/spine-webgl";
+import { SpineGameObjectBoundsProvider } from "./SpineGameObject.js";
+import { SkeletonRenderer } from "@esotericsoftware/spine-canvas";
+/**
+ * Configuration object used when creating {@link SpineGameObject} instances via a scene's
+ * {@link GameObjectCreator} (`Scene.make`).
+ */
+export interface SpineGameObjectConfig extends Phaser.Types.GameObjects.GameObjectConfig {
+    /** The x-position of the object, optional, default: 0 */
+    x?: number;
+    /** The y-position of the object, optional, default: 0 */
+    y?: number;
+    /** The skeleton data key */
+    dataKey: string;
+    /** The atlas key */
+    atlasKey: string;
+    /** The bounds provider, optional, default: `SetupPoseBoundsProvider` */
+    boundsProvider?: SpineGameObjectBoundsProvider;
+}
+/**
+ * {@link ScenePlugin} implementation adding Spine Runtime capabilities to a scene.
+ *
+ * The scene's {@link LoaderPlugin} (`Scene.load`) gets these additional functions:
+ * * `spineBinary(key: string, url: string, xhrSettings?: XHRSettingsObject)`: loads a skeleton binary `.skel` file from the `url`.
+ * * `spineJson(key: string, url: string, xhrSettings?: XHRSettingsObject)`: loads a skeleton binary `.skel` file from the `url`.
+ * * `spineAtlas(key: string, url: string, premultipliedAlpha: boolean = true, xhrSettings?: XHRSettingsObject)`: loads a texture atlas `.atlas` file from the `url` as well as its correponding texture atlas page images.
+ *
+ * The scene's {@link GameObjectFactory} (`Scene.add`) gets these additional functions:
+ * * `spine(x: number, y: number, dataKey: string, atlasKey: string, boundsProvider: SpineGameObjectBoundsProvider = SetupPoseBoundsProvider())`:
+ *    creates a new {@link SpineGameObject} from the data and atlas at position `(x, y)`, using the {@link BoundsProvider} to calculate its bounding box. The object is automatically added to the scene.
+ *
+ * The scene's {@link GameObjectCreator} (`Scene.make`) gets these additional functions:
+ * * `spine(config: SpineGameObjectConfig)`: creates a new {@link SpineGameObject} from the given configuration object.
+ *
+ * The plugin has additional public methods to work with Spine Runtime core API objects:
+ * * `getAtlas(atlasKey: string)`: returns the {@link TextureAtlas} instance for the given atlas key.
+ * * `getSkeletonData(skeletonDataKey: string)`: returns the {@link SkeletonData} instance for the given skeleton data key.
+ * * `createSkeleton(skeletonDataKey: string, atlasKey: string, premultipliedAlpha: boolean = true)`: creates a new {@link Skeleton} instance from the given skeleton data and atlas key.
+ * * `isPremultipliedAlpha(atlasKey: string)`: returns `true` if the atlas with the given key has premultiplied alpha.
+ */
+export declare class SpinePlugin extends Phaser.Plugins.ScenePlugin {
+    game: Phaser.Game;
+    private isWebGL;
+    gl: WebGLRenderingContext | null;
+    static gameWebGLRenderer: SceneRenderer | null;
+    get webGLRenderer(): SceneRenderer | null;
+    canvasRenderer: SkeletonRenderer | null;
+    phaserRenderer: Phaser.Renderer.Canvas.CanvasRenderer | Phaser.Renderer.WebGL.WebGLRenderer;
+    private skeletonDataCache;
+    private atlasCache;
+    constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager, pluginKey: string);
+    static rendererId: number;
+    boot(): void;
+    onResize(): void;
+    shutdown(): void;
+    destroy(): void;
+    gameDestroy(): void;
+    /** Returns the TextureAtlas instance for the given key */
+    getAtlas(atlasKey: string): TextureAtlas;
+    /** Returns whether the TextureAtlas uses premultiplied alpha */
+    isAtlasPremultiplied(atlasKey: string): any;
+    /** Returns the SkeletonData instance for the given data and atlas key */
+    getSkeletonData(dataKey: string, atlasKey: string): SkeletonData;
+    /** Creates a new Skeleton instance from the data and atlas. */
+    createSkeleton(dataKey: string, atlasKey: string): Skeleton;
+}