mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-02-04 14:24:53 +08:00
300 lines
48 KiB
JavaScript
300 lines
48 KiB
JavaScript
/******************************************************************************
|
|
* 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"]}
|