@galacean/engine-spine 4.2.5 → 4.2.6

package/types/spine-core/SlotData.d.ts

@@ -0,0 +1,23 @@
+import { BoneData } from "./BoneData";
+import { Color } from "./Utils";
+import { BlendMode } from "./BlendMode";
+/** Stores the setup pose for a {@link Slot}. */
+export declare class SlotData {
+    /** The index of the slot in {@link Skeleton#getSlots()}. */
+    index: number;
+    /** The name of the slot, which is unique across all slots in the skeleton. */
+    name: string;
+    /** The bone this slot belongs to. */
+    boneData: BoneData;
+    /** The color used to tint the slot's attachment. If {@link #getDarkColor()} is set, this is used as the light color for two
+     * color tinting. */
+    color: Color;
+    /** The dark color used to tint the slot's attachment for two color tinting, or null if two color tinting is not used. The dark
+     * color's alpha is not used. */
+    darkColor: Color;
+    /** The name of the attachment that is visible for this slot in the setup pose, or null if no attachment is visible. */
+    attachmentName: string;
+    /** The blend mode for drawing the slot's attachment. */
+    blendMode: BlendMode;
+    constructor(index: number, name: string, boneData: BoneData);
+}

package/types/spine-core/Texture.d.ts

@@ -0,0 +1,46 @@
+import { Texture2D } from "@galacean/engine";
+export declare abstract class Texture {
+    protected _texture: Texture2D;
+    constructor(texture: Texture2D);
+    get width(): number;
+    get height(): number;
+    get texture(): Texture2D;
+    abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
+    abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
+    abstract dispose(): void;
+    static filterFromString(text: string): TextureFilter;
+    static wrapFromString(text: string): TextureWrap;
+}
+export declare enum TextureFilter {
+    Nearest = 9728,
+    Linear = 9729,
+    MipMap = 9987,
+    MipMapNearestNearest = 9984,
+    MipMapLinearNearest = 9985,
+    MipMapNearestLinear = 9986,
+    MipMapLinearLinear = 9987
+}
+export declare enum TextureWrap {
+    MirroredRepeat = 33648,
+    ClampToEdge = 33071,
+    Repeat = 10497
+}
+export declare class TextureRegion {
+    renderObject: any;
+    u: number;
+    v: number;
+    u2: number;
+    v2: number;
+    width: number;
+    height: number;
+    rotate: boolean;
+    offsetX: number;
+    offsetY: number;
+    originalWidth: number;
+    originalHeight: number;
+}
+export declare class FakeTexture extends Texture {
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
+    dispose(): void;
+}

package/types/spine-core/TextureAtlas.d.ts

@@ -0,0 +1,30 @@
+import { Disposable } from "./Utils";
+import { Texture, TextureFilter } from "./Texture";
+import { TextureWrap, TextureRegion } from "./Texture";
+export declare class TextureAtlas implements Disposable {
+    pages: TextureAtlasPage[];
+    regions: TextureAtlasRegion[];
+    constructor(atlasText: string, textureLoader: (path: string, width?: number, height?: number) => any);
+    private load;
+    findRegion(name: string): TextureAtlasRegion;
+    dispose(): void;
+}
+export declare class TextureAtlasPage {
+    name: string;
+    minFilter: TextureFilter;
+    magFilter: TextureFilter;
+    uWrap: TextureWrap;
+    vWrap: TextureWrap;
+    texture: Texture;
+    width: number;
+    height: number;
+}
+export declare class TextureAtlasRegion extends TextureRegion {
+    page: TextureAtlasPage;
+    name: string;
+    x: number;
+    y: number;
+    index: number;
+    degrees: number;
+    texture: Texture;
+}

package/types/spine-core/TransformConstraint.d.ts

@@ -0,0 +1,36 @@
+import { Updatable } from "./Updatable";
+import { TransformConstraintData } from "./TransformConstraintData";
+import { Bone } from "./Bone";
+import { Skeleton } from "./Skeleton";
+import { Vector2 } from "./Utils";
+/** Stores the current pose for a transform constraint. A transform constraint adjusts the world transform of the constrained
+ * bones to match that of the target bone.
+ *
+ * See [Transform constraints](http://esotericsoftware.com/spine-transform-constraints) in the Spine User Guide. */
+export declare class TransformConstraint implements Updatable {
+    /** The transform constraint's setup pose data. */
+    data: TransformConstraintData;
+    /** The bones that will be modified by this transform constraint. */
+    bones: Array<Bone>;
+    /** The target bone whose world transform will be copied to the constrained bones. */
+    target: Bone;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
+    rotateMix: number;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
+    translateMix: number;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained scales. */
+    scaleMix: number;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained scales. */
+    shearMix: number;
+    temp: Vector2;
+    active: boolean;
+    constructor(data: TransformConstraintData, skeleton: Skeleton);
+    isActive(): boolean;
+    /** Applies the constraint to the constrained bones. */
+    apply(): void;
+    update(): void;
+    applyAbsoluteWorld(): void;
+    applyRelativeWorld(): void;
+    applyAbsoluteLocal(): void;
+    applyRelativeLocal(): void;
+}

package/types/spine-core/TransformConstraintData.d.ts

@@ -0,0 +1,34 @@
+import { ConstraintData } from "./ConstraintData";
+import { BoneData } from "./BoneData";
+/** Stores the setup pose for a {@link TransformConstraint}.
+ *
+ * See [Transform constraints](http://esotericsoftware.com/spine-transform-constraints) in the Spine User Guide. */
+export declare class TransformConstraintData extends ConstraintData {
+    /** The bones that will be modified by this transform constraint. */
+    bones: BoneData[];
+    /** The target bone whose world transform will be copied to the constrained bones. */
+    target: BoneData;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
+    rotateMix: number;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
+    translateMix: number;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained scales. */
+    scaleMix: number;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained shears. */
+    shearMix: number;
+    /** An offset added to the constrained bone rotation. */
+    offsetRotation: number;
+    /** An offset added to the constrained bone X translation. */
+    offsetX: number;
+    /** An offset added to the constrained bone Y translation. */
+    offsetY: number;
+    /** An offset added to the constrained bone scaleX. */
+    offsetScaleX: number;
+    /** An offset added to the constrained bone scaleY. */
+    offsetScaleY: number;
+    /** An offset added to the constrained bone shearY. */
+    offsetShearY: number;
+    relative: boolean;
+    local: boolean;
+    constructor(name: string);
+}

package/types/spine-core/Triangulator.d.ts

@@ -0,0 +1,14 @@
+export declare class Triangulator {
+    private convexPolygons;
+    private convexPolygonsIndices;
+    private indicesArray;
+    private isConcaveArray;
+    private triangles;
+    private polygonPool;
+    private polygonIndicesPool;
+    triangulate(verticesArray: ArrayLike<number>): Array<number>;
+    decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
+    private static isConcave;
+    private static positiveArea;
+    private static winding;
+}

package/types/spine-core/Updatable.d.ts

@@ -0,0 +1,9 @@
+/** The interface for items updated by {@link Skeleton#updateWorldTransform()}. */
+export interface Updatable {
+    update(): void;
+    /** Returns false when this item has not been updated because a skin is required and the {@link Skeleton#skin active skin}
+     * does not contain this item.
+     * @see Skin#getBones()
+     * @see Skin#getConstraints() */
+    isActive(): boolean;
+}

package/types/spine-core/Utils.d.ts

@@ -0,0 +1,124 @@
+import { MixBlend } from "./Animation";
+import { Skeleton } from "./Skeleton";
+export interface Map<T> {
+    [key: string]: T;
+}
+export declare class IntSet {
+    array: number[];
+    add(value: number): boolean;
+    contains(value: number): boolean;
+    remove(value: number): void;
+    clear(): void;
+}
+export interface Disposable {
+    dispose(): void;
+}
+export interface Restorable {
+    restore(): void;
+}
+export declare class Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    static WHITE: Color;
+    static RED: Color;
+    static GREEN: Color;
+    static BLUE: Color;
+    static MAGENTA: Color;
+    constructor(r?: number, g?: number, b?: number, a?: number);
+    set(r: number, g: number, b: number, a: number): this;
+    setFromColor(c: Color): this;
+    setFromString(hex: string): this;
+    add(r: number, g: number, b: number, a: number): this;
+    clamp(): this;
+    static rgba8888ToColor(color: Color, value: number): void;
+    static rgb888ToColor(color: Color, value: number): void;
+}
+export declare class MathUtils {
+    static PI: number;
+    static PI2: number;
+    static radiansToDegrees: number;
+    static radDeg: number;
+    static degreesToRadians: number;
+    static degRad: number;
+    static clamp(value: number, min: number, max: number): number;
+    static cosDeg(degrees: number): number;
+    static sinDeg(degrees: number): number;
+    static signum(value: number): number;
+    static toInt(x: number): number;
+    static cbrt(x: number): number;
+    static randomTriangular(min: number, max: number): number;
+    static randomTriangularWith(min: number, max: number, mode: number): number;
+}
+export declare abstract class Interpolation {
+    protected abstract applyInternal(a: number): number;
+    apply(start: number, end: number, a: number): number;
+}
+export declare class Pow extends Interpolation {
+    protected power: number;
+    constructor(power: number);
+    applyInternal(a: number): number;
+}
+export declare class PowOut extends Pow {
+    constructor(power: number);
+    applyInternal(a: number): number;
+}
+export declare class Utils {
+    static SUPPORTS_TYPED_ARRAYS: boolean;
+    static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number): void;
+    static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>;
+    static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>;
+    static newArray<T>(size: number, defaultValue: T): Array<T>;
+    static newFloatArray(size: number): ArrayLike<number>;
+    static newShortArray(size: number): ArrayLike<number>;
+    static toFloatArray(array: Array<number>): number[] | Float32Array;
+    static toSinglePrecision(value: number): number;
+    static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
+    static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+}
+export declare class DebugUtils {
+    static logBones(skeleton: Skeleton): void;
+}
+export declare class Pool<T> {
+    private items;
+    private instantiator;
+    constructor(instantiator: () => T);
+    obtain(): T;
+    free(item: T): void;
+    freeAll(items: ArrayLike<T>): void;
+    clear(): void;
+}
+export declare class Vector2 {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    set(x: number, y: number): Vector2;
+    length(): number;
+    normalize(): this;
+}
+export declare class TimeKeeper {
+    maxDelta: number;
+    framesPerSecond: number;
+    delta: number;
+    totalTime: number;
+    private lastTime;
+    private frameCount;
+    private frameTime;
+    update(): void;
+}
+export interface ArrayLike<T> {
+    length: number;
+    [n: number]: T;
+}
+export declare class WindowedMean {
+    values: Array<number>;
+    addedValues: number;
+    lastValue: number;
+    mean: number;
+    dirty: boolean;
+    constructor(windowSize?: number);
+    hasEnoughData(): boolean;
+    addValue(value: number): void;
+    getMean(): number;
+}

package/types/spine-core/VertexEffect.d.ts

@@ -0,0 +1,7 @@
+import { Skeleton } from "./Skeleton";
+import { Color, Vector2 } from "./Utils";
+export interface VertexEffect {
+    begin(skeleton: Skeleton): void;
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+    end(): void;
+}

package/types/spine-core/attachments/Attachment.d.ts

@@ -0,0 +1,43 @@
+import { Slot } from "../Slot";
+import { ArrayLike } from "../Utils";
+/** The base class for all attachments. */
+export declare abstract class Attachment {
+    name: string;
+    constructor(name: string);
+    abstract copy(): Attachment;
+}
+/** Base class for an attachment with vertices that are transformed by one or more bones and can be deformed by a slot's
+ * {@link Slot#deform}. */
+export declare abstract class VertexAttachment extends Attachment {
+    private static nextID;
+    /** The unique ID for this attachment. */
+    id: number;
+    /** The bones which affect the {@link #getVertices()}. The array entries are, for each vertex, the number of bones affecting
+     * the vertex followed by that many bone indices, which is the index of the bone in {@link Skeleton#bones}. Will be null
+     * if this attachment has no weights. */
+    bones: Array<number>;
+    /** The vertex positions in the bone's coordinate system. For a non-weighted attachment, the values are `x,y`
+     * entries for each vertex. For a weighted attachment, the values are `x,y,weight` entries for each bone affecting
+     * each vertex. */
+    vertices: ArrayLike<number>;
+    /** The maximum number of world vertex values that can be output by
+     * {@link #computeWorldVertices()} using the `count` parameter. */
+    worldVerticesLength: number;
+    /** Deform keys for the deform attachment are also applied to this attachment. May be null if no deform keys should be applied. */
+    deformAttachment: VertexAttachment;
+    constructor(name: string);
+    /** Transforms the attachment's local {@link vertices} to world coordinates. If the slot's {@link Slot#deform} is
+     * not empty, it is used to deform the vertices.
+     *
+     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * Runtimes Guide.
+     * @param start The index of the first {@link #vertices} value to transform. Each vertex has 2 values, x and y.
+     * @param count The number of world vertex values to output. Must be <= {@link #worldVerticesLength} - `start`.
+     * @param worldVertices The output world vertices. Must have a length >= `offset` + `count` *
+     *           `stride` / 2.
+     * @param offset The `worldVertices` index to begin writing values.
+     * @param stride The number of `worldVertices` entries between the value pairs written. */
+    computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
+    /** Does not copy id (generated) or name (set on construction). **/
+    copyTo(attachment: VertexAttachment): void;
+}

package/types/spine-core/attachments/AttachmentLoader.d.ts

@@ -0,0 +1,25 @@
+import { RegionAttachment } from "./RegionAttachment";
+import { Skin } from "../Skin";
+import { BoundingBoxAttachment } from "./BoundingBoxAttachment";
+import { PathAttachment } from "./PathAttachment";
+import { PointAttachment } from "./PointAttachment";
+import { ClippingAttachment } from "./ClippingAttachment";
+import { MeshAttachment } from "./MeshAttachment";
+/** The interface which can be implemented to customize creating and populating attachments.
+ *
+ * See [Loading skeleton data](http://esotericsoftware.com/spine-loading-skeleton-data#AttachmentLoader) in the Spine
+ * Runtimes Guide. */
+export interface AttachmentLoader {
+    /** @return May be null to not load an attachment. */
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
+    /** @return May be null to not load an attachment. */
+    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
+    /** @return May be null to not load an attachment. */
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
+    /** @return May be null to not load an attachment */
+    newPathAttachment(skin: Skin, name: string): PathAttachment;
+    /** @return May be null to not load an attachment */
+    newPointAttachment(skin: Skin, name: string): PointAttachment;
+    /** @return May be null to not load an attachment */
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
+}

package/types/spine-core/attachments/AttachmentType.d.ts

@@ -0,0 +1,9 @@
+export declare enum AttachmentType {
+    Region = 0,
+    BoundingBox = 1,
+    Mesh = 2,
+    LinkedMesh = 3,
+    Path = 4,
+    Point = 5,
+    Clipping = 6
+}

package/types/spine-core/attachments/BoundingBoxAttachment.d.ts

@@ -0,0 +1,12 @@
+import { VertexAttachment, Attachment } from "./Attachment";
+import { Color } from "../Utils";
+/** An attachment with vertices that make up a polygon. Can be used for hit detection, creating physics bodies, spawning particle
+ * effects, and more.
+ *
+ * See {@link SkeletonBounds} and [Bounding Boxes](http://esotericsoftware.com/spine-bounding-boxes) in the Spine User
+ * Guide. */
+export declare class BoundingBoxAttachment extends VertexAttachment {
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

package/types/spine-core/attachments/ClippingAttachment.d.ts

@@ -0,0 +1,14 @@
+import { VertexAttachment, Attachment } from "./Attachment";
+import { SlotData } from "../SlotData";
+import { Color } from "../Utils";
+/** An attachment with vertices that make up a polygon used for clipping the rendering of other attachments. */
+export declare class ClippingAttachment extends VertexAttachment {
+    /** Clipping is performed between the clipping polygon's slot and the end slot. Returns null if clipping is done until the end of
+     * the skeleton's rendering. */
+    endSlot: SlotData;
+    /** The color of the clipping polygon as it was in Spine. Available only when nonessential data was exported. Clipping polygons
+     * are not usually rendered at runtime. */
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

package/types/spine-core/attachments/MeshAttachment.d.ts

@@ -0,0 +1,46 @@
+import { VertexAttachment, Attachment } from "./Attachment";
+import { TextureRegion } from "../Texture";
+import { Color, ArrayLike } from "../Utils";
+/** An attachment that displays a textured mesh. A mesh has hull vertices and internal vertices within the hull. Holes are not
+ * supported. Each vertex has UVs (texture coordinates) and triangles are used to map an image on to the mesh.
+ *
+ * See [Mesh attachments](http://esotericsoftware.com/spine-meshes) in the Spine User Guide. */
+export declare class MeshAttachment extends VertexAttachment {
+    region: TextureRegion;
+    /** The name of the texture region for this attachment. */
+    path: string;
+    /** The UV pair for each vertex, normalized within the texture region. */
+    regionUVs: ArrayLike<number>;
+    /** The UV pair for each vertex, normalized within the entire texture.
+     *
+     * See {@link #updateUVs}. */
+    uvs: ArrayLike<number>;
+    /** Triplets of vertex indices which describe the mesh's triangulation. */
+    triangles: Array<number>;
+    /** The color to tint the mesh. */
+    color: Color;
+    /** The width of the mesh's image. Available only when nonessential data was exported. */
+    width: number;
+    /** The height of the mesh's image. Available only when nonessential data was exported. */
+    height: number;
+    /** The number of entries at the beginning of {@link #vertices} that make up the mesh hull. */
+    hullLength: number;
+    /** Vertex index pairs describing edges for controling triangulation. Mesh triangles will never cross edges. Only available if
+     * nonessential data was exported. Triangulation is not performed at runtime. */
+    edges: Array<number>;
+    private parentMesh;
+    tempColor: Color;
+    constructor(name: string);
+    /** Calculates {@link #uvs} using {@link #regionUVs} and the {@link #region}. Must be called after changing the region UVs or
+     * region. */
+    updateUVs(): void;
+    /** The parent mesh if this is a linked mesh, else null. A linked mesh shares the {@link #bones}, {@link #vertices},
+     * {@link #regionUVs}, {@link #triangles}, {@link #hullLength}, {@link #edges}, {@link #width}, and {@link #height} with the
+     * parent mesh, but may have a different {@link #name} or {@link #path} (and therefore a different texture). */
+    getParentMesh(): MeshAttachment;
+    /** @param parentMesh May be null. */
+    setParentMesh(parentMesh: MeshAttachment): void;
+    copy(): Attachment;
+    /** Returns a new mesh with the {@link #parentMesh} set to this mesh's parent mesh, if any, else to this mesh. **/
+    newLinkedMesh(): MeshAttachment;
+}

package/types/spine-core/attachments/PathAttachment.d.ts

@@ -0,0 +1,19 @@
+import { VertexAttachment, Attachment } from "./Attachment";
+import { Color } from "../Utils";
+/** An attachment whose vertices make up a composite Bezier curve.
+ *
+ * See {@link PathConstraint} and [Paths](http://esotericsoftware.com/spine-paths) in the Spine User Guide. */
+export declare class PathAttachment extends VertexAttachment {
+    /** The lengths along the path in the setup pose from the start of the path to the end of each Bezier curve. */
+    lengths: Array<number>;
+    /** If true, the start and end knots are connected. */
+    closed: boolean;
+    /** If true, additional calculations are performed to make calculating positions along the path more accurate. If false, fewer
+     * calculations are performed but calculating positions along the path is less accurate. */
+    constantSpeed: boolean;
+    /** The color of the path as it was in Spine. Available only when nonessential data was exported. Paths are not usually
+     * rendered at runtime. */
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

package/types/spine-core/attachments/PointAttachment.d.ts

@@ -0,0 +1,20 @@
+import { VertexAttachment, Attachment } from "./Attachment";
+import { Color, Vector2 } from "../Utils";
+import { Bone } from "../Bone";
+/** An attachment which is a single point and a rotation. This can be used to spawn projectiles, particles, etc. A bone can be
+ * used in similar ways, but a PointAttachment is slightly less expensive to compute and can be hidden, shown, and placed in a
+ * skin.
+ *
+ * See [Point Attachments](http://esotericsoftware.com/spine-point-attachments) in the Spine User Guide. */
+export declare class PointAttachment extends VertexAttachment {
+    x: number;
+    y: number;
+    rotation: number;
+    /** The color of the point attachment as it was in Spine. Available only when nonessential data was exported. Point attachments
+     * are not usually rendered at runtime. */
+    color: Color;
+    constructor(name: string);
+    computeWorldPosition(bone: Bone, point: Vector2): Vector2;
+    computeWorldRotation(bone: Bone): number;
+    copy(): Attachment;
+}

package/types/spine-core/attachments/RegionAttachment.d.ts

@@ -0,0 +1,88 @@
+import { Attachment } from "./Attachment";
+import { Color, ArrayLike } from "../Utils";
+import { TextureRegion } from "../Texture";
+import { Bone } from "../Bone";
+/** An attachment that displays a textured quadrilateral.
+ *
+ * See [Region attachments](http://esotericsoftware.com/spine-regions) in the Spine User Guide. */
+export declare class RegionAttachment extends Attachment {
+    static OX1: number;
+    static OY1: number;
+    static OX2: number;
+    static OY2: number;
+    static OX3: number;
+    static OY3: number;
+    static OX4: number;
+    static OY4: number;
+    static X1: number;
+    static Y1: number;
+    static C1R: number;
+    static C1G: number;
+    static C1B: number;
+    static C1A: number;
+    static U1: number;
+    static V1: number;
+    static X2: number;
+    static Y2: number;
+    static C2R: number;
+    static C2G: number;
+    static C2B: number;
+    static C2A: number;
+    static U2: number;
+    static V2: number;
+    static X3: number;
+    static Y3: number;
+    static C3R: number;
+    static C3G: number;
+    static C3B: number;
+    static C3A: number;
+    static U3: number;
+    static V3: number;
+    static X4: number;
+    static Y4: number;
+    static C4R: number;
+    static C4G: number;
+    static C4B: number;
+    static C4A: number;
+    static U4: number;
+    static V4: number;
+    /** The local x translation. */
+    x: number;
+    /** The local y translation. */
+    y: number;
+    /** The local scaleX. */
+    scaleX: number;
+    /** The local scaleY. */
+    scaleY: number;
+    /** The local rotation. */
+    rotation: number;
+    /** The width of the region attachment in Spine. */
+    width: number;
+    /** The height of the region attachment in Spine. */
+    height: number;
+    /** The color to tint the region attachment. */
+    color: Color;
+    /** The name of the texture region for this attachment. */
+    path: string;
+    rendererObject: any;
+    region: TextureRegion;
+    /** For each of the 4 vertices, a pair of <code>x,y</code> values that is the local position of the vertex.
+     *
+     * See {@link #updateOffset()}. */
+    offset: ArrayLike<number>;
+    uvs: ArrayLike<number>;
+    tempColor: Color;
+    constructor(name: string);
+    /** Calculates the {@link #offset} using the region settings. Must be called after changing region settings. */
+    updateOffset(): void;
+    setRegion(region: TextureRegion): void;
+    /** Transforms the attachment's four vertices to world coordinates.
+     *
+     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * Runtimes Guide.
+     * @param worldVertices The output world vertices. Must have a length >= `offset` + 8.
+     * @param offset The `worldVertices` index to begin writing values.
+     * @param stride The number of `worldVertices` entries between the value pairs written. */
+    computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
+    copy(): Attachment;
+}

package/types/spine-core/polyfills.d.ts

@@ -0,0 +1,3 @@
+interface Math {
+    fround(n: number): number;
+}

package/types/spine-core/vertexeffects/JitterEffect.d.ts

@@ -0,0 +1,11 @@
+import { VertexEffect } from "../VertexEffect";
+import { Skeleton } from "../Skeleton";
+import { Color, Vector2 } from "../Utils";
+export declare class JitterEffect implements VertexEffect {
+    jitterX: number;
+    jitterY: number;
+    constructor(jitterX: number, jitterY: number);
+    begin(skeleton: Skeleton): void;
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+    end(): void;
+}

package/types/spine-core/vertexeffects/SwirlEffect.d.ts

@@ -0,0 +1,16 @@
+import { VertexEffect } from "../VertexEffect";
+import { PowOut, Color, Vector2 } from "../Utils";
+import { Skeleton } from "../Skeleton";
+export declare class SwirlEffect implements VertexEffect {
+    static interpolation: PowOut;
+    centerX: number;
+    centerY: number;
+    radius: number;
+    angle: number;
+    private worldX;
+    private worldY;
+    constructor(radius: number);
+    begin(skeleton: Skeleton): void;
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+    end(): void;
+}

package/types/types.d.ts

@@ -0,0 +1,4 @@
+export type SpineRenderSetting = {
+    useClipping: boolean;
+    zSpacing: number;
+};