483 lines
71 KiB
JavaScript
483 lines
71 KiB
JavaScript
/******************************************************************************
|
|
* Spine Runtimes License Agreement
|
|
* Last updated April 5, 2025. Replaces all prior versions.
|
|
*
|
|
* Copyright (c) 2013-2025, 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 { ClippingAttachment } from "./attachments/ClippingAttachment.js";
|
|
import { MeshAttachment } from "./attachments/MeshAttachment.js";
|
|
import { RegionAttachment } from "./attachments/RegionAttachment.js";
|
|
import { Bone } from "./Bone.js";
|
|
import { DrawOrder } from "./DrawOrder.js";
|
|
import { PhysicsConstraint } from "./PhysicsConstraint.js";
|
|
import { Slot } from "./Slot.js";
|
|
import { Color, Utils, Vector2 } from "./Utils.js";
|
|
/** Stores bones and slots to be posed by animations and application code. Multiple skeleton instances can share the same
|
|
* {@link SkeletonData}, including animations, attachments, and skins.
|
|
*
|
|
* After posing, call {@link updateWorldTransform} to apply constraints and compute world transforms for rendering.
|
|
*
|
|
* See [Instance objects](http://esotericsoftware.com/spine-runtime-architecture#Instance-objects) in the Spine Runtimes Guide. */
|
|
export class Skeleton {
|
|
static quadTriangles = [0, 1, 2, 2, 3, 0];
|
|
static yDown = false;
|
|
static get yDir() {
|
|
return Skeleton.yDown ? -1 : 1;
|
|
}
|
|
/** The skeleton's setup pose data. */
|
|
data;
|
|
/** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
|
|
bones;
|
|
/** The skeleton's slots. To add a slot, also add it to {@link DrawOrder.pose}. */
|
|
slots;
|
|
/** The skeleton's draw order. Use {@link DrawOrder.appliedPose} for rendering and {@link DrawOrder.pose} for changing the draw
|
|
* order. */
|
|
drawOrder;
|
|
/** The skeleton's constraints. */
|
|
// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
|
|
constraints;
|
|
/** The skeleton's physics constraints. */
|
|
physics;
|
|
/** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link updateCache}. */
|
|
// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
|
|
_updateCache = [];
|
|
// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
|
|
resetCache = [];
|
|
/** The skeleton's current skin. May be null. */
|
|
skin = null;
|
|
/** The color to tint all the skeleton's attachments. */
|
|
color;
|
|
/** Scales the entire skeleton on the X axis.
|
|
*
|
|
* Bones that do not inherit scale are still affected by this property. */
|
|
scaleX = 1;
|
|
_scaleY = 1;
|
|
/** Scales the entire skeleton on the Y axis.
|
|
*
|
|
* Bones that do not inherit scale are still affected by this property. */
|
|
get scaleY() {
|
|
return this._scaleY * Skeleton.yDir;
|
|
}
|
|
set scaleY(scaleY) {
|
|
this._scaleY = scaleY;
|
|
}
|
|
/** Sets the skeleton X position, which is added to the root bone worldX position.
|
|
*
|
|
* Bones that do not inherit translation are still affected by this property. */
|
|
x = 0;
|
|
/** Sets the skeleton Y position, which is added to the root bone worldY position.
|
|
*
|
|
* Bones that do not inherit translation are still affected by this property. */
|
|
y = 0;
|
|
/** Returns the skeleton's time, is used for time-based manipulations, such as {@link PhysicsConstraint}.
|
|
*
|
|
* See {@link _update}. */
|
|
time = 0;
|
|
/** The x component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */
|
|
windX = 1;
|
|
/** The y component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */
|
|
windY = 0;
|
|
/** The x component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */
|
|
gravityX = 0;
|
|
/** The y component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */
|
|
gravityY = 1;
|
|
_update = 0;
|
|
constructor(data) {
|
|
if (!data)
|
|
throw new Error("data cannot be null.");
|
|
this.data = data;
|
|
this.bones = [];
|
|
for (let i = 0; i < data.bones.length; i++) {
|
|
const boneData = data.bones[i];
|
|
let bone;
|
|
if (!boneData.parent)
|
|
bone = new Bone(boneData, null);
|
|
else {
|
|
const parent = this.bones[boneData.parent.index];
|
|
bone = new Bone(boneData, parent);
|
|
parent.children.push(bone);
|
|
}
|
|
this.bones.push(bone);
|
|
}
|
|
this.slots = [];
|
|
for (const slotData of this.data.slots)
|
|
this.slots.push(new Slot(slotData, this));
|
|
this.drawOrder = new DrawOrder(this.slots);
|
|
this.physics = [];
|
|
// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
|
|
this.constraints = [];
|
|
for (const constraintData of this.data.constraints) {
|
|
const constraint = constraintData.create(this);
|
|
if (constraint instanceof PhysicsConstraint)
|
|
this.physics.push(constraint);
|
|
this.constraints.push(constraint);
|
|
}
|
|
this.color = new Color(1, 1, 1, 1);
|
|
this.updateCache();
|
|
}
|
|
/** Caches information about bones and constraints. Must be called if the {@link skin} is modified or if bones, constraints,
|
|
* or weighted path attachments are added or removed. */
|
|
updateCache() {
|
|
this._updateCache.length = 0;
|
|
this.resetCache.length = 0;
|
|
this.drawOrder.unconstrained();
|
|
const slots = this.slots;
|
|
for (let i = 0, n = slots.length; i < n; i++)
|
|
slots[i].unconstrained();
|
|
const bones = this.bones;
|
|
const boneCount = bones.length;
|
|
for (let i = 0, n = boneCount; i < n; i++) {
|
|
const bone = bones[i];
|
|
bone.sorted = bone.data.skinRequired;
|
|
bone.active = !bone.sorted;
|
|
bone.unconstrained();
|
|
}
|
|
if (this.skin) {
|
|
const skinBones = this.skin.bones;
|
|
for (let i = 0, n = this.skin.bones.length; i < n; i++) {
|
|
let bone = this.bones[skinBones[i].index];
|
|
do {
|
|
bone.sorted = false;
|
|
bone.active = true;
|
|
bone = bone.parent;
|
|
} while (bone);
|
|
}
|
|
}
|
|
const constraints = this.constraints;
|
|
let n = this.constraints.length;
|
|
for (let i = 0; i < n; i++)
|
|
constraints[i].unconstrained();
|
|
for (let i = 0; i < n; i++) {
|
|
const constraint = constraints[i];
|
|
constraint.active = constraint.isSourceActive()
|
|
// biome-ignore lint/complexity/useOptionalChain: changing to this might return undefined
|
|
&& (!constraint.data.skinRequired || (this.skin != null && this.skin.constraints.includes(constraint.data)));
|
|
if (constraint.active)
|
|
constraint.sort(this);
|
|
}
|
|
for (let i = 0; i < boneCount; i++)
|
|
this.sortBone(bones[i]);
|
|
n = this._updateCache.length;
|
|
for (let i = 0; i < n; i++) {
|
|
const updateable = this._updateCache[i];
|
|
if (updateable instanceof Bone)
|
|
this._updateCache[i] = updateable.appliedPose;
|
|
}
|
|
}
|
|
// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
|
|
constrained(object) {
|
|
if (object.pose === object.appliedPose) {
|
|
object.constrained();
|
|
this.resetCache.push(object);
|
|
}
|
|
}
|
|
sortBone(bone) {
|
|
if (bone.sorted || !bone.active)
|
|
return;
|
|
const parent = bone.parent;
|
|
if (parent)
|
|
this.sortBone(parent);
|
|
bone.sorted = true;
|
|
this._updateCache.push(bone);
|
|
}
|
|
sortReset(bones) {
|
|
for (let i = 0, n = bones.length; i < n; i++) {
|
|
const bone = bones[i];
|
|
if (bone.active) {
|
|
if (bone.sorted)
|
|
this.sortReset(bone.children);
|
|
bone.sorted = false;
|
|
}
|
|
}
|
|
}
|
|
/** Updates the world transform for each bone and applies all constraints.
|
|
*
|
|
* See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
|
|
* Runtimes Guide. */
|
|
updateWorldTransform(physics) {
|
|
this._update++;
|
|
if (this.drawOrder.appliedPose === this.drawOrder.constrainedPose)
|
|
this.drawOrder.resetConstrained();
|
|
const resetCache = this.resetCache;
|
|
for (let i = 0, n = this.resetCache.length; i < n; i++)
|
|
resetCache[i].resetConstrained();
|
|
const updateCache = this._updateCache;
|
|
for (let i = 0, n = this._updateCache.length; i < n; i++)
|
|
updateCache[i].update(this, physics);
|
|
}
|
|
/** Sets the bones, constraints, and slots to their setup pose values. */
|
|
setupPose() {
|
|
this.setupPoseBones();
|
|
this.setupPoseSlots();
|
|
}
|
|
/** Sets the bones and constraints to their setup pose values. */
|
|
setupPoseBones() {
|
|
const bones = this.bones;
|
|
for (let i = 0, n = bones.length; i < n; i++)
|
|
bones[i].setupPose();
|
|
const constraints = this.constraints;
|
|
for (let i = 0, n = constraints.length; i < n; i++)
|
|
constraints[i].setupPose();
|
|
}
|
|
/** Sets the slots and draw order to their setup pose values. */
|
|
setupPoseSlots() {
|
|
this.drawOrder.setupPose();
|
|
const slots = this.slots;
|
|
for (let i = 0, n = slots.length; i < n; i++)
|
|
slots[i].setupPose();
|
|
}
|
|
/** Returns the root bone, or null if the skeleton has no bones. */
|
|
getRootBone() {
|
|
if (this.bones.length === 0)
|
|
return null;
|
|
return this.bones[0];
|
|
}
|
|
/** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it
|
|
* repeatedly. */
|
|
findBone(boneName) {
|
|
if (!boneName)
|
|
throw new Error("boneName cannot be null.");
|
|
const bones = this.bones;
|
|
for (let i = 0, n = bones.length; i < n; i++)
|
|
if (bones[i].data.name === boneName)
|
|
return bones[i];
|
|
return null;
|
|
}
|
|
/** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
|
|
* repeatedly. */
|
|
findSlot(slotName) {
|
|
if (!slotName)
|
|
throw new Error("slotName cannot be null.");
|
|
const slots = this.slots;
|
|
for (let i = 0, n = slots.length; i < n; i++)
|
|
if (slots[i].data.name === slotName)
|
|
return slots[i];
|
|
return null;
|
|
}
|
|
setSkin(newSkin) {
|
|
if (typeof newSkin === "string")
|
|
this.setSkinByName(newSkin);
|
|
else
|
|
this.setSkinBySkin(newSkin);
|
|
}
|
|
;
|
|
setSkinByName(skinName) {
|
|
const skin = this.data.findSkin(skinName);
|
|
if (!skin)
|
|
throw new Error(`Skin not found: ${skinName}`);
|
|
this.setSkin(skin);
|
|
}
|
|
setSkinBySkin(newSkin) {
|
|
if (newSkin === this.skin)
|
|
return;
|
|
if (newSkin) {
|
|
if (this.skin)
|
|
newSkin.attachAll(this, this.skin);
|
|
else {
|
|
const slots = this.slots;
|
|
for (let i = 0, n = slots.length; i < n; i++) {
|
|
const slot = slots[i];
|
|
const name = slot.data.attachmentName;
|
|
if (name) {
|
|
const attachment = newSkin.getAttachment(i, name);
|
|
if (attachment)
|
|
slot.pose.setAttachment(attachment);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.skin = newSkin;
|
|
this.updateCache();
|
|
}
|
|
getAttachment(slotNameOrIndex, placeholder) {
|
|
if (typeof slotNameOrIndex === 'string')
|
|
return this.getAttachmentByName(slotNameOrIndex, placeholder);
|
|
return this.getAttachmentByIndex(slotNameOrIndex, placeholder);
|
|
}
|
|
/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot name and attachment
|
|
* name.
|
|
*
|
|
* See {@link getAttachment}.
|
|
* @returns May be null. */
|
|
getAttachmentByName(slotName, placeholder) {
|
|
const slot = this.data.findSlot(slotName);
|
|
if (!slot)
|
|
throw new Error(`Can't find slot with name ${slotName}`);
|
|
return this.getAttachment(slot.index, placeholder);
|
|
}
|
|
/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot index and
|
|
* attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.
|
|
*
|
|
* See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.
|
|
* @returns May be null. */
|
|
getAttachmentByIndex(slotIndex, placeholder) {
|
|
if (!placeholder)
|
|
throw new Error("placeholder cannot be null.");
|
|
if (this.skin) {
|
|
const attachment = this.skin.getAttachment(slotIndex, placeholder);
|
|
if (attachment)
|
|
return attachment;
|
|
}
|
|
if (this.data.defaultSkin)
|
|
return this.data.defaultSkin.getAttachment(slotIndex, placeholder);
|
|
return null;
|
|
}
|
|
/** A convenience method to set an attachment by finding the slot with {@link findSlot}, finding the attachment with
|
|
* {@link getAttachment}, then setting the slot's {@link Slot.attachment}.
|
|
* @param placeholder May be null to clear the slot's attachment. */
|
|
setAttachment(slotName, placeholder) {
|
|
if (!slotName)
|
|
throw new Error("slotName cannot be null.");
|
|
const slot = this.findSlot(slotName);
|
|
if (!slot)
|
|
throw new Error(`Slot not found: ${slotName}`);
|
|
let attachment = null;
|
|
if (placeholder) {
|
|
attachment = this.getAttachment(slot.data.index, placeholder);
|
|
if (!attachment)
|
|
throw new Error(`Attachment not found: ${placeholder}, for slot: ${slotName}`);
|
|
}
|
|
slot.pose.setAttachment(attachment);
|
|
}
|
|
/** Finds a constraint of the specified type by comparing each constraints's name. It is more efficient to cache the results of
|
|
* this method than to call it multiple times. */
|
|
// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
|
|
findConstraint(constraintName, type) {
|
|
if (constraintName == null)
|
|
throw new Error("constraintName cannot be null.");
|
|
if (type == null)
|
|
throw new Error("type cannot be null.");
|
|
const constraints = this.constraints;
|
|
for (let i = 0, n = constraints.length; i < n; i++) {
|
|
const constraint = constraints[i];
|
|
if (constraint instanceof type && constraint.data.name === constraintName)
|
|
return constraint;
|
|
}
|
|
return null;
|
|
}
|
|
/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose.
|
|
* @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
|
|
* @param size An output value, the width and height of the AABB.
|
|
* @param temp Working memory to temporarily store attachments' computed world vertices. */
|
|
getBoundsRect(clipper) {
|
|
const offset = new Vector2();
|
|
const size = new Vector2();
|
|
this.getBounds(offset, size, undefined, clipper);
|
|
return { x: offset.x, y: offset.y, width: size.x, height: size.y };
|
|
}
|
|
/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose. Optionally applies
|
|
* clipping.
|
|
* @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
|
|
* @param size An output value, the width and height of the AABB.
|
|
* @param temp Working memory to temporarily store attachments' computed world vertices.
|
|
* @param clipper {@link SkeletonClipping} to use. If `null`, no clipping is applied. */
|
|
getBounds(offset, size, temp = new Array(2), clipper = null) {
|
|
if (!offset)
|
|
throw new Error("offset cannot be null.");
|
|
if (!size)
|
|
throw new Error("size cannot be null.");
|
|
const drawOrder = this.drawOrder.appliedPose;
|
|
const slots = drawOrder;
|
|
let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
|
|
for (let i = 0, n = drawOrder.length; i < n; i++) {
|
|
const slot = slots[i];
|
|
if (!slot.bone.active)
|
|
continue;
|
|
let verticesLength = 0;
|
|
let vertices = null;
|
|
let triangles = null;
|
|
const attachment = slot.appliedPose.attachment;
|
|
if (attachment) {
|
|
if (attachment instanceof RegionAttachment) {
|
|
verticesLength = 8;
|
|
vertices = Utils.setArraySize(temp, verticesLength, 0);
|
|
attachment.computeWorldVertices(slot, attachment.getOffsets(slot.appliedPose), vertices, 0, 2);
|
|
triangles = Skeleton.quadTriangles;
|
|
}
|
|
else if (attachment instanceof MeshAttachment) {
|
|
verticesLength = attachment.worldVerticesLength;
|
|
vertices = Utils.setArraySize(temp, verticesLength, 0);
|
|
attachment.computeWorldVertices(this, slot, 0, verticesLength, vertices, 0, 2);
|
|
triangles = attachment.triangles;
|
|
}
|
|
else if (attachment instanceof ClippingAttachment && clipper) {
|
|
clipper.clipEnd(slot);
|
|
clipper.clipStart(this, slot, attachment);
|
|
continue;
|
|
}
|
|
if (vertices && triangles) {
|
|
if (clipper?.isClipping() && clipper.clipTriangles(vertices, triangles, triangles.length)) {
|
|
vertices = clipper.clippedVertices;
|
|
verticesLength = clipper.clippedVertices.length;
|
|
}
|
|
for (let ii = 0, nn = vertices.length; ii < nn; ii += 2) {
|
|
const x = vertices[ii], y = vertices[ii + 1];
|
|
minX = Math.min(minX, x);
|
|
minY = Math.min(minY, y);
|
|
maxX = Math.max(maxX, x);
|
|
maxY = Math.max(maxY, y);
|
|
}
|
|
}
|
|
}
|
|
if (clipper)
|
|
clipper.clipEnd(slot);
|
|
}
|
|
if (clipper)
|
|
clipper.clipEnd();
|
|
offset.set(minX, minY);
|
|
size.set(maxX - minX, maxY - minY);
|
|
}
|
|
/** Scales the entire skeleton on the X and Y axes.
|
|
*
|
|
* Bones that do not inherit scale are still affected by this property. */
|
|
setScale(scaleX, scaleY) {
|
|
this.scaleX = scaleX;
|
|
this.scaleY = scaleY;
|
|
}
|
|
/** Sets the skeleton X and Y position, which is added to the root bone worldX and worldY position.
|
|
*
|
|
* Bones that do not inherit translation are still affected by this property. */
|
|
setPosition(x, y) {
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
/** Increments the skeleton's {@link time}. */
|
|
update(delta) {
|
|
this.time += delta;
|
|
}
|
|
/** Calls {@link PhysicsConstraint.translate} for each physics constraint. */
|
|
physicsTranslate(x, y) {
|
|
const constraints = this.physics;
|
|
for (let i = 0, n = constraints.length; i < n; i++)
|
|
constraints[i].translate(x, y);
|
|
}
|
|
/** Calls {@link PhysicsConstraint.rotate} for each physics constraint. */
|
|
physicsRotate(x, y, degrees) {
|
|
const constraints = this.physics;
|
|
for (let i = 0, n = constraints.length; i < n; i++)
|
|
constraints[i].rotate(x, y, degrees);
|
|
}
|
|
}
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Skeleton.js","sourceRoot":"","sources":["../src/Skeleton.ts"],"names":[],"mappings":"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","sourcesContent":["/******************************************************************************\n * Spine Runtimes License Agreement\n * Last updated April 5, 2025. Replaces all prior versions.\n *\n * Copyright (c) 2013-2025, 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\n * or 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\n * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *****************************************************************************/\n\nimport type { AnimationState } from \"./AnimationState.js\";\nimport type { Attachment } from \"./attachments/Attachment.js\";\nimport { ClippingAttachment } from \"./attachments/ClippingAttachment.js\";\nimport { MeshAttachment } from \"./attachments/MeshAttachment.js\";\nimport { RegionAttachment } from \"./attachments/RegionAttachment.js\";\nimport { Bone } from \"./Bone.js\";\nimport type { Constraint } from \"./Constraint.js\";\nimport { DrawOrder } from \"./DrawOrder.js\";\nimport type { Physics } from \"./Physics.js\";\nimport { PhysicsConstraint } from \"./PhysicsConstraint.js\";\nimport type { PhysicsConstraintPose } from \"./PhysicsConstraintPose.js\";\nimport type { Posed } from \"./Posed.js\";\nimport type { SkeletonClipping } from \"./SkeletonClipping.js\";\nimport type { SkeletonData } from \"./SkeletonData.js\";\nimport type { Skin } from \"./Skin.js\";\nimport { Slot } from \"./Slot.js\";\nimport { Color, type NumberArrayLike, Utils, Vector2 } from \"./Utils.js\";\n\n/** Stores bones and slots to be posed by animations and application code. Multiple skeleton instances can share the same\n * {@link SkeletonData}, including animations, attachments, and skins.\n *\n * After posing, call {@link updateWorldTransform} to apply constraints and compute world transforms for rendering.\n *\n * See [Instance objects](http://esotericsoftware.com/spine-runtime-architecture#Instance-objects) in the Spine Runtimes Guide. */\nexport class Skeleton {\n\tprivate static quadTriangles = [0, 1, 2, 2, 3, 0];\n\tstatic yDown = false;\n\tstatic get yDir (): number {\n\t\treturn Skeleton.yDown ? -1 : 1;\n\t}\n\n\t/** The skeleton's setup pose data. */\n\treadonly data: SkeletonData;\n\n\t/** The skeleton's bones, sorted parent first. The root bone is always the first bone. */\n\treadonly bones: Array<Bone>;\n\n\t/** The skeleton's slots. To add a slot, also add it to {@link DrawOrder.pose}. */\n\treadonly slots: Array<Slot>;\n\n\t/** The skeleton's draw order. Use {@link DrawOrder.appliedPose} for rendering and {@link DrawOrder.pose} for changing the draw\n\t * order. */\n\treadonly drawOrder: DrawOrder;\n\n\t/** The skeleton's constraints. */\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\treadonly constraints: Array<Constraint<any, any, any>>;\n\n\t/** The skeleton's physics constraints. */\n\treadonly physics: Array<PhysicsConstraint>;\n\n\t/** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link updateCache}. */\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\treadonly _updateCache = [] as any[];\n\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\treadonly resetCache: Array<Posed<any, any>> = [];\n\n\t/** The skeleton's current skin. May be null. */\n\tskin: Skin | null = null;\n\n\t/** The color to tint all the skeleton's attachments. */\n\treadonly color: Color;\n\n\t/** Scales the entire skeleton on the X axis.\n\t *\n\t * Bones that do not inherit scale are still affected by this property. */\n\tscaleX = 1;\n\n\tprivate _scaleY = 1;\n\n\t/** Scales the entire skeleton on the Y axis.\n\t *\n\t * Bones that do not inherit scale are still affected by this property. */\n\tpublic get scaleY () {\n\t\treturn this._scaleY * Skeleton.yDir;\n\t}\n\n\tpublic set scaleY (scaleY: number) {\n\t\tthis._scaleY = scaleY;\n\t}\n\n\t/** Sets the skeleton X position, which is added to the root bone worldX position.\n\t *\n\t * Bones that do not inherit translation are still affected by this property. */\n\tx = 0;\n\n\t/** Sets the skeleton Y position, which is added to the root bone worldY position.\n\t *\n\t * Bones that do not inherit translation are still affected by this property. */\n\ty = 0;\n\n\t/** Returns the skeleton's time, is used for time-based manipulations, such as {@link PhysicsConstraint}.\n\t *\n\t * See {@link _update}. */\n\ttime = 0;\n\n\t/** The x component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */\n\twindX = 1;\n\n\t/** The y component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */\n\twindY = 0;\n\n\t/** The x component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */\n\tgravityX = 0;\n\n\t/** The y component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */\n\tgravityY = 1;\n\n\t_update = 0;\n\n\tconstructor (data: SkeletonData) {\n\t\tif (!data) throw new Error(\"data cannot be null.\");\n\t\tthis.data = data;\n\n\t\tthis.bones = [] as Bone[];\n\t\tfor (let i = 0; i < data.bones.length; i++) {\n\t\t\tconst boneData = data.bones[i];\n\t\t\tlet bone: Bone;\n\t\t\tif (!boneData.parent)\n\t\t\t\tbone = new Bone(boneData, null);\n\t\t\telse {\n\t\t\t\tconst parent = this.bones[boneData.parent.index];\n\t\t\t\tbone = new Bone(boneData, parent);\n\t\t\t\tparent.children.push(bone);\n\t\t\t}\n\t\t\tthis.bones.push(bone);\n\t\t}\n\n\t\tthis.slots = [] as Slot[];\n\t\tfor (const slotData of this.data.slots)\n\t\t\tthis.slots.push(new Slot(slotData, this));\n\t\tthis.drawOrder = new DrawOrder(this.slots);\n\n\t\tthis.physics = [] as PhysicsConstraint[];\n\t\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\t\tthis.constraints = [] as Constraint<any, any, any>[];\n\t\tfor (const constraintData of this.data.constraints) {\n\t\t\tconst constraint = constraintData.create(this);\n\t\t\tif (constraint instanceof PhysicsConstraint) this.physics.push(constraint);\n\t\t\tthis.constraints.push(constraint);\n\t\t}\n\n\t\tthis.color = new Color(1, 1, 1, 1);\n\n\t\tthis.updateCache();\n\t}\n\n\t/** Caches information about bones and constraints. Must be called if the {@link skin} is modified or if bones, constraints,\n\t * or weighted path attachments are added or removed. */\n\tupdateCache () {\n\t\tthis._updateCache.length = 0;\n\t\tthis.resetCache.length = 0;\n\n\t\tthis.drawOrder.unconstrained();\n\t\tconst slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++)\n\t\t\tslots[i].unconstrained();\n\n\t\tconst bones = this.bones;\n\t\tconst boneCount = bones.length;\n\t\tfor (let i = 0, n = boneCount; i < n; i++) {\n\t\t\tconst bone = bones[i];\n\t\t\tbone.sorted = bone.data.skinRequired;\n\t\t\tbone.active = !bone.sorted;\n\t\t\tbone.unconstrained();\n\t\t}\n\t\tif (this.skin) {\n\t\t\tconst skinBones = this.skin.bones;\n\t\t\tfor (let i = 0, n = this.skin.bones.length; i < n; i++) {\n\t\t\t\tlet bone: Bone | null = this.bones[skinBones[i].index];\n\t\t\t\tdo {\n\t\t\t\t\tbone.sorted = false;\n\t\t\t\t\tbone.active = true;\n\t\t\t\t\tbone = bone.parent;\n\t\t\t\t} while (bone);\n\t\t\t}\n\t\t}\n\n\t\tconst constraints = this.constraints;\n\t\tlet n = this.constraints.length;\n\t\tfor (let i = 0; i < n; i++)\n\t\t\tconstraints[i].unconstrained();\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tconst constraint = constraints[i];\n\t\t\tconstraint.active = constraint.isSourceActive()\n\t\t\t\t// biome-ignore lint/complexity/useOptionalChain: changing to this might return undefined\n\t\t\t\t&& (!constraint.data.skinRequired || (this.skin != null && this.skin.constraints.includes(constraint.data)));\n\t\t\tif (constraint.active) constraint.sort(this);\n\t\t}\n\n\t\tfor (let i = 0; i < boneCount; i++)\n\t\t\tthis.sortBone(bones[i]);\n\n\t\tn = this._updateCache.length;\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tconst updateable = this._updateCache[i];\n\t\t\tif (updateable instanceof Bone) this._updateCache[i] = updateable.appliedPose;\n\t\t}\n\n\t}\n\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\tconstrained (object: Posed<any, any>) {\n\t\tif (object.pose === object.appliedPose) {\n\t\t\tobject.constrained();\n\t\t\tthis.resetCache.push(object);\n\t\t}\n\t}\n\n\tsortBone (bone: Bone) {\n\t\tif (bone.sorted || !bone.active) return;\n\t\tconst parent = bone.parent;\n\t\tif (parent) this.sortBone(parent);\n\t\tbone.sorted = true;\n\t\tthis._updateCache.push(bone);\n\t}\n\n\tsortReset (bones: Array<Bone>) {\n\t\tfor (let i = 0, n = bones.length; i < n; i++) {\n\t\t\tconst bone = bones[i];\n\t\t\tif (bone.active) {\n\t\t\t\tif (bone.sorted) this.sortReset(bone.children);\n\t\t\t\tbone.sorted = false;\n\t\t\t}\n\t\t}\n\t}\n\n\t/** Updates the world transform for each bone and applies all constraints.\n\t *\n\t * See <a href=\"https://esotericsoftware.com/spine-runtime-skeletons#World-transforms\">World transforms</a> in the Spine\n\t * Runtimes Guide. */\n\tupdateWorldTransform (physics: Physics): void {\n\t\tthis._update++;\n\n\t\tif (this.drawOrder.appliedPose === this.drawOrder.constrainedPose) this.drawOrder.resetConstrained();\n\t\tconst resetCache = this.resetCache;\n\t\tfor (let i = 0, n = this.resetCache.length; i < n; i++)\n\t\t\tresetCache[i].resetConstrained();\n\n\t\tconst updateCache = this._updateCache;\n\t\tfor (let i = 0, n = this._updateCache.length; i < n; i++)\n\t\t\tupdateCache[i].update(this, physics);\n\t}\n\n\t/** Sets the bones, constraints, and slots to their setup pose values. */\n\tsetupPose () {\n\t\tthis.setupPoseBones();\n\t\tthis.setupPoseSlots();\n\t}\n\n\t/** Sets the bones and constraints to their setup pose values. */\n\tsetupPoseBones () {\n\t\tconst bones = this.bones;\n\t\tfor (let i = 0, n = bones.length; i < n; i++)\n\t\t\tbones[i].setupPose();\n\n\t\tconst constraints = this.constraints;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++)\n\t\t\tconstraints[i].setupPose();\n\t}\n\n\t/** Sets the slots and draw order to their setup pose values. */\n\tsetupPoseSlots () {\n\t\tthis.drawOrder.setupPose();\n\t\tconst slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++)\n\t\t\tslots[i].setupPose();\n\t}\n\n\t/** Returns the root bone, or null if the skeleton has no bones. */\n\tgetRootBone () {\n\t\tif (this.bones.length === 0) return null;\n\t\treturn this.bones[0];\n\t}\n\n\t/** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it\n\t * repeatedly. */\n\tfindBone (boneName: string) {\n\t\tif (!boneName) throw new Error(\"boneName cannot be null.\");\n\t\tconst bones = this.bones;\n\t\tfor (let i = 0, n = bones.length; i < n; i++)\n\t\t\tif (bones[i].data.name === boneName) return bones[i];\n\t\treturn null;\n\t}\n\n\t/** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it\n\t * repeatedly. */\n\tfindSlot (slotName: string) {\n\t\tif (!slotName) throw new Error(\"slotName cannot be null.\");\n\t\tconst slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++)\n\t\t\tif (slots[i].data.name === slotName) return slots[i];\n\t\treturn null;\n\t}\n\n\t/** Sets a skin by name.\n\t *\n\t * See {@link setSkin}. */\n\tsetSkin (skinName: string): void;\n\n\t/** Sets the skin used to look up attachments before looking in {@link SkeletonData.defaultSkin}. If the skin is changed,\n\t * {@link updateCache} is called.\n\t *\n\t * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no\n\t * old skin, each slot's setup mode attachment is attached from the new skin.\n\t *\n\t * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling\n\t * {@link setupPoseSlots}. Also, often {@link AnimationState.apply} is called before the next time the skeleton is\n\t * rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new skin. */\n\tsetSkin (newSkin: Skin | null): void;\n\n\tsetSkin (newSkin: Skin | null | string): void {\n\t\tif (typeof newSkin === \"string\")\n\t\t\tthis.setSkinByName(newSkin);\n\t\telse\n\t\t\tthis.setSkinBySkin(newSkin);\n\t};\n\n\tprivate setSkinByName (skinName: string) {\n\t\tconst skin = this.data.findSkin(skinName);\n\t\tif (!skin) throw new Error(`Skin not found: ${skinName}`);\n\t\tthis.setSkin(skin);\n\t}\n\n\tprivate setSkinBySkin (newSkin: Skin | null) {\n\t\tif (newSkin === this.skin) return;\n\t\tif (newSkin) {\n\t\t\tif (this.skin)\n\t\t\t\tnewSkin.attachAll(this, this.skin);\n\t\t\telse {\n\t\t\t\tconst slots = this.slots;\n\t\t\t\tfor (let i = 0, n = slots.length; i < n; i++) {\n\t\t\t\t\tconst slot = slots[i];\n\t\t\t\t\tconst name = slot.data.attachmentName;\n\t\t\t\t\tif (name) {\n\t\t\t\t\t\tconst attachment = newSkin.getAttachment(i, name);\n\t\t\t\t\t\tif (attachment) slot.pose.setAttachment(attachment);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.skin = newSkin;\n\t\tthis.updateCache();\n\t}\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot name and attachment\n\t * name.\n\t *\n\t * See {@link getAttachment}. */\n\tgetAttachment (slotName: string, placeholder: string): Attachment | null;\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot index and\n\t * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.\n\t *\n\t * See <a href=\"https://esotericsoftware.com/spine-runtime-skins\">Runtime skins</a> in the Spine Runtimes Guide. */\n\tgetAttachment (slotIndex: number, placeholder: string): Attachment | null;\n\n\tgetAttachment (slotNameOrIndex: string | number, placeholder: string): Attachment | null {\n\t\tif (typeof slotNameOrIndex === 'string')\n\t\t\treturn this.getAttachmentByName(slotNameOrIndex, placeholder);\n\t\treturn this.getAttachmentByIndex(slotNameOrIndex, placeholder);\n\t}\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot name and attachment\n\t * name.\n\t *\n\t * See {@link getAttachment}.\n\t * @returns May be null. */\n\tprivate getAttachmentByName (slotName: string, placeholder: string): Attachment | null {\n\t\tconst slot = this.data.findSlot(slotName);\n\t\tif (!slot) throw new Error(`Can't find slot with name ${slotName}`);\n\t\treturn this.getAttachment(slot.index, placeholder);\n\t}\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot index and\n\t * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.\n\t *\n\t * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.\n\t * @returns May be null. */\n\tprivate getAttachmentByIndex (slotIndex: number, placeholder: string): Attachment | null {\n\t\tif (!placeholder) throw new Error(\"placeholder cannot be null.\");\n\t\tif (this.skin) {\n\t\t\tconst attachment = this.skin.getAttachment(slotIndex, placeholder);\n\t\t\tif (attachment) return attachment;\n\t\t}\n\t\tif (this.data.defaultSkin) return this.data.defaultSkin.getAttachment(slotIndex, placeholder);\n\t\treturn null;\n\t}\n\n\t/** A convenience method to set an attachment by finding the slot with {@link findSlot}, finding the attachment with\n\t * {@link getAttachment}, then setting the slot's {@link Slot.attachment}.\n\t * @param placeholder May be null to clear the slot's attachment. */\n\tsetAttachment (slotName: string, placeholder: string | null) {\n\t\tif (!slotName) throw new Error(\"slotName cannot be null.\");\n\t\tconst slot = this.findSlot(slotName);\n\t\tif (!slot) throw new Error(`Slot not found: ${slotName}`);\n\t\tlet attachment: Attachment | null = null;\n\t\tif (placeholder) {\n\t\t\tattachment = this.getAttachment(slot.data.index, placeholder);\n\t\t\tif (!attachment)\n\t\t\t\tthrow new Error(`Attachment not found: ${placeholder}, for slot: ${slotName}`);\n\t\t}\n\t\tslot.pose.setAttachment(attachment);\n\t}\n\n\t/** Finds a constraint of the specified type by comparing each constraints's name. It is more efficient to cache the results of\n\t * this method than to call it multiple times. */\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\tfindConstraint<T extends Constraint<any, any, any>> (constraintName: string, type: abstract new (...args: any[]) => T): T | null {\n\t\tif (constraintName == null) throw new Error(\"constraintName cannot be null.\");\n\t\tif (type == null) throw new Error(\"type cannot be null.\");\n\t\tconst constraints = this.constraints;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++) {\n\t\t\tconst constraint = constraints[i];\n\t\t\tif (constraint instanceof type && constraint.data.name === constraintName) return constraint as T;\n\t\t}\n\t\treturn null;\n\t}\n\n\t/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose.\n\t * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.\n\t * @param size An output value, the width and height of the AABB.\n\t * @param temp Working memory to temporarily store attachments' computed world vertices. */\n\tgetBoundsRect (clipper?: SkeletonClipping) {\n\t\tconst offset = new Vector2();\n\t\tconst size = new Vector2();\n\t\tthis.getBounds(offset, size, undefined, clipper);\n\t\treturn { x: offset.x, y: offset.y, width: size.x, height: size.y };\n\t}\n\n\t/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose. Optionally applies\n\t * clipping.\n\t * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.\n\t * @param size An output value, the width and height of the AABB.\n\t * @param temp Working memory to temporarily store attachments' computed world vertices.\n\t * @param clipper {@link SkeletonClipping} to use. If `null`, no clipping is applied. */\n\tgetBounds (offset: Vector2, size: Vector2, temp: Array<number> = new Array<number>(2), clipper: SkeletonClipping | null = null) {\n\t\tif (!offset) throw new Error(\"offset cannot be null.\");\n\t\tif (!size) throw new Error(\"size cannot be null.\");\n\t\tconst drawOrder = this.drawOrder.appliedPose;\n\t\tconst slots = drawOrder;\n\t\tlet minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;\n\t\tfor (let i = 0, n = drawOrder.length; i < n; i++) {\n\t\t\tconst slot = slots[i];\n\t\t\tif (!slot.bone.active) continue;\n\t\t\tlet verticesLength = 0;\n\t\t\tlet vertices: NumberArrayLike | null = null;\n\t\t\tlet triangles: NumberArrayLike | null = null;\n\t\t\tconst attachment = slot.appliedPose.attachment;\n\t\t\tif (attachment) {\n\t\t\t\tif (attachment instanceof RegionAttachment) {\n\t\t\t\t\tverticesLength = 8;\n\t\t\t\t\tvertices = Utils.setArraySize(temp, verticesLength, 0);\n\t\t\t\t\tattachment.computeWorldVertices(slot, attachment.getOffsets(slot.appliedPose), vertices, 0, 2);\n\t\t\t\t\ttriangles = Skeleton.quadTriangles;\n\t\t\t\t} else if (attachment instanceof MeshAttachment) {\n\t\t\t\t\tverticesLength = attachment.worldVerticesLength;\n\t\t\t\t\tvertices = Utils.setArraySize(temp, verticesLength, 0);\n\t\t\t\t\tattachment.computeWorldVertices(this, slot, 0, verticesLength, vertices, 0, 2);\n\t\t\t\t\ttriangles = attachment.triangles;\n\t\t\t\t} else if (attachment instanceof ClippingAttachment && clipper) {\n\t\t\t\t\tclipper.clipEnd(slot);\n\t\t\t\t\tclipper.clipStart(this, slot, attachment);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (vertices && triangles) {\n\t\t\t\t\tif (clipper?.isClipping() && clipper.clipTriangles(vertices, triangles, triangles.length)) {\n\t\t\t\t\t\tvertices = clipper.clippedVertices;\n\t\t\t\t\t\tverticesLength = clipper.clippedVertices.length;\n\t\t\t\t\t}\n\t\t\t\t\tfor (let ii = 0, nn = vertices.length; ii < nn; ii += 2) {\n\t\t\t\t\t\tconst x = vertices[ii], y = vertices[ii + 1];\n\t\t\t\t\t\tminX = Math.min(minX, x);\n\t\t\t\t\t\tminY = Math.min(minY, y);\n\t\t\t\t\t\tmaxX = Math.max(maxX, x);\n\t\t\t\t\t\tmaxY = Math.max(maxY, y);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (clipper) clipper.clipEnd(slot);\n\t\t}\n\t\tif (clipper) clipper.clipEnd();\n\t\toffset.set(minX, minY);\n\t\tsize.set(maxX - minX, maxY - minY);\n\t}\n\n\t/** Scales the entire skeleton on the X and Y axes.\n\t *\n\t * Bones that do not inherit scale are still affected by this property. */\n\tpublic setScale (scaleX: number, scaleY: number) {\n\t\tthis.scaleX = scaleX;\n\t\tthis.scaleY = scaleY;\n\t}\n\n\t/** Sets the skeleton X and Y position, which is added to the root bone worldX and worldY position.\n\t *\n\t * Bones that do not inherit translation are still affected by this property. */\n\tpublic setPosition (x: number, y: number) {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t}\n\n\t/** Increments the skeleton's {@link time}. */\n\tupdate (delta: number) {\n\t\tthis.time += delta;\n\t}\n\n\t/** Calls {@link PhysicsConstraint.translate} for each physics constraint. */\n\tphysicsTranslate (x: number, y: number) {\n\t\tconst constraints = this.physics;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++)\n\t\t\tconstraints[i].translate(x, y);\n\t}\n\n\t/** Calls {@link PhysicsConstraint.rotate} for each physics constraint. */\n\tphysicsRotate (x: number, y: number, degrees: number) {\n\t\tconst constraints = this.physics;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++)\n\t\t\tconstraints[i].rotate(x, y, degrees);\n\t}\n}\n"]}
|